{ "mode": "pydoc", "parameter": "numpy", "section": "", "url": "https://www.chedong.com/phpMan.php/pydoc/numpy/json", "generated": "2026-06-02T15:01:22Z", "sections": { "NAME": { "content": "numpy\n", "subsections": [] }, "DESCRIPTION": { "content": "NumPy\n=====\n\nProvides\n1. An array object of arbitrary homogeneous items\n2. Fast mathematical operations over arrays\n3. Linear Algebra, Fourier Transforms, Random Number Generation\n\nHow to use the documentation\n----------------------------\nDocumentation is available in two forms: docstrings provided\nwith the code, and a loose standing reference guide, available from\n`the NumPy homepage `.\n\nWe recommend exploring the docstrings using\n`IPython `, an advanced Python shell with\nTAB-completion and introspection capabilities. See below for further\ninstructions.\n\nThe docstring examples assume that `numpy` has been imported as `np`::\n\n>>> import numpy as np\n\nCode snippets are indicated by three greater-than signs::\n\n>>> x = 42\n>>> x = x + 1\n\nUse the built-in ``help`` function to view a function's docstring::\n\n>>> help(np.sort)\n... # doctest: +SKIP\n\nFor some objects, ``np.info(obj)`` may provide additional help. This is\nparticularly true if you see the line \"Help on ufunc object:\" at the top\nof the help() page. Ufuncs are implemented in C, not Python, for speed.\nThe native Python help() does not know how to view their help, but our\nnp.info() function does.\n\nTo search for documents containing a keyword, do::\n\n>>> np.lookfor('keyword')\n... # doctest: +SKIP\n\nGeneral-purpose documents like a glossary and help on the basic concepts\nof numpy are available under the ``doc`` sub-module::\n\n>>> from numpy import doc\n>>> help(doc)\n... # doctest: +SKIP\n\nAvailable subpackages\n---------------------\ndoc\nTopical documentation on broadcasting, indexing, etc.\nlib\nBasic functions used by several sub-packages.\nrandom\nCore Random Tools\nlinalg\nCore Linear Algebra Tools\nfft\nCore FFT routines\npolynomial\nPolynomial tools\ntesting\nNumPy testing tools\nf2py\nFortran to Python Interface Generator.\ndistutils\nEnhancements to distutils with support for\nFortran compilers support and more.\n\nUtilities\n---------\ntest\nRun numpy unittests\nshowconfig\nShow numpy build configuration\ndual\nOverwrite certain functions with high-performance SciPy tools.\nNote: `numpy.dual` is deprecated. Use the functions from NumPy or Scipy\ndirectly instead of importing them from `numpy.dual`.\nmatlib\nMake everything matrices.\nversion\nNumPy version string\n\nViewing documentation using IPython\n-----------------------------------\nStart IPython with the NumPy profile (``ipython -p numpy``), which will\nimport `numpy` under the alias `np`. Then, use the ``cpaste`` command to\npaste examples into the shell. To see which functions are available in\n`numpy`, type ``np.`` (where ```` refers to the TAB key), or use\n``np.*cos*?`` (where ```` refers to the ENTER key) to narrow\ndown the list. To view the docstring for a function, use\n``np.cos?`` (to view the docstring) and ``np.cos??`` (to view\nthe source code).\n\nCopies vs. in-place operation\n-----------------------------\nMost of the functions in `numpy` return a copy of the array argument\n(e.g., `np.sort`). In-place versions of these functions are often\navailable as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.\nExceptions to this rule are documented.\n", "subsections": [] }, "PACKAGE CONTENTS": { "content": "config\ndistributorinit\nglobals\npytesttester\nversion\ncompat (package)\nconftest\ncore (package)\nctypeslib\ndistutils (package)\ndoc (package)\ndual\nf2py (package)\nfft (package)\nlib (package)\nlinalg (package)\nma (package)\nmatlib\nmatrixlib (package)\npolynomial (package)\nrandom (package)\nsetup\ntesting (package)\ntests (package)\ntyping (package)\nversion\n", "subsections": [] }, "SUBMODULES": { "content": "mat\nchar\nemath\nrec\n", "subsections": [] }, "CLASSES": { "content": "builtins.DeprecationWarning(builtins.Warning)\nModuleDeprecationWarning\nbuiltins.IndexError(builtins.LookupError)\nAxisError(builtins.ValueError, builtins.IndexError)\nbuiltins.RuntimeError(builtins.Exception)\nTooHardError\nbuiltins.RuntimeWarning(builtins.Warning)\nComplexWarning\nbuiltins.UserWarning(builtins.Warning)\nRankWarning\nVisibleDeprecationWarning\nbuiltins.ValueError(builtins.Exception)\nAxisError(builtins.ValueError, builtins.IndexError)\nbuiltins.bytes(builtins.object)\nbytes(builtins.bytes, character)\nbuiltins.object\nDataSource\nMachAr\nbroadcast\nbusdaycalendar\ndtype\nfinfo\nflatiter\nformatparser\ngeneric\nbool\ndatetime64\nflexible\ncharacter\nbytes(builtins.bytes, character)\nstr(builtins.str, character)\nvoid\nrecord\nnumber\ninexact\ncomplexfloating\ncomplex128(complexfloating, builtins.complex)\ncomplex256\ncomplex64\nfloating\nfloat128\nfloat16\nfloat32\nfloat64(floating, builtins.float)\ninteger\nsignedinteger\nint16\nint32\nint64\nint8\nlonglong\ntimedelta64\nunsignedinteger\nuint16\nuint32\nuint64\nuint8\nulonglong\nobject\niinfo\nndarray\nchararray\nmatrix\nmemmap\nrecarray\nndenumerate\nndindex\nnditer\npoly1d\nufunc\nvectorize\nbuiltins.str(builtins.object)\nstr(builtins.str, character)\ncontextlib.ContextDecorator(builtins.object)\nerrstate\n", "subsections": [ { "name": "class AxisError", "content": "| AxisError(axis, ndim=None, msgprefix=None)\n|\n| Axis supplied was invalid.\n|\n| Method resolution order:\n| AxisError\n| builtins.ValueError\n| builtins.IndexError\n| builtins.LookupError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Methods defined here:\n|\n| init(self, axis, ndim=None, msgprefix=None)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.ValueError:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class ComplexWarning", "content": "| The warning raised when casting a complex dtype to a real dtype.\n|\n| As implemented, casting a complex number to a real discards its imaginary\n| part, but this behavior may not be what the user actually wants.\n|\n| Method resolution order:\n| ComplexWarning\n| builtins.RuntimeWarning\n| builtins.Warning\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.RuntimeWarning:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.RuntimeWarning:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class DataSource", "content": "| DataSource(destpath='.')\n|\n| DataSource(destpath='.')\n|\n| A generic data source file (file, http, ftp, ...).\n|\n| DataSources can be local files or remote files/URLs. The files may\n| also be compressed or uncompressed. DataSource hides some of the\n| low-level details of downloading the file, allowing you to simply pass\n| in a valid file path (or URL) and obtain a file object.\n|\n| Parameters\n| ----------\n| destpath : str or None, optional\n| Path to the directory where the source file gets downloaded to for\n| use. If `destpath` is None, a temporary directory will be created.\n| The default path is the current directory.\n|\n| Notes\n| -----\n| URLs require a scheme string (``http://``) to be used, without it they\n| will fail::\n|\n| >>> repos = np.DataSource()\n| >>> repos.exists('www.google.com/index.html')\n| False\n| >>> repos.exists('http://www.google.com/index.html')\n| True\n|\n| Temporary directories are deleted when the DataSource is deleted.\n|\n| Examples\n| --------\n| ::\n|\n| >>> ds = np.DataSource('/home/guido')\n| >>> urlname = 'http://www.google.com/'\n| >>> gfile = ds.open('http://www.google.com/')\n| >>> ds.abspath(urlname)\n| '/home/guido/www.google.com/index.html'\n|\n| >>> ds = np.DataSource(None) # use with temporary file\n| >>> ds.open('/home/guido/foobar.txt')\n| \n| >>> ds.abspath('/home/guido/foobar.txt')\n| '/tmp/.../home/guido/foobar.txt'\n|\n| Methods defined here:\n|\n| del(self)\n|\n| init(self, destpath='.')\n| Create a DataSource with a local path at destpath.\n|\n| abspath(self, path)\n| Return absolute path of file in the DataSource directory.\n|\n| If `path` is an URL, then `abspath` will return either the location\n| the file exists locally or the location it would exist when opened\n| using the `open` method.\n|\n| Parameters\n| ----------\n| path : str\n| Can be a local file or a remote URL.\n|\n| Returns\n| -------\n| out : str\n| Complete path, including the `DataSource` destination directory.\n|\n| Notes\n| -----\n| The functionality is based on `os.path.abspath`.\n|\n| exists(self, path)\n| Test if path exists.\n|\n| Test if `path` exists as (and in this order):\n|\n| - a local file.\n| - a remote URL that has been downloaded and stored locally in the\n| `DataSource` directory.\n| - a remote URL that has not been downloaded, but is valid and\n| accessible.\n|\n| Parameters\n| ----------\n| path : str\n| Can be a local file or a remote URL.\n|\n| Returns\n| -------\n| out : bool\n| True if `path` exists.\n|\n| Notes\n| -----\n| When `path` is an URL, `exists` will return True if it's either\n| stored locally in the `DataSource` directory, or is a valid remote\n| URL. `DataSource` does not discriminate between the two, the file\n| is accessible if it exists in either location.\n|\n| open(self, path, mode='r', encoding=None, newline=None)\n| Open and return file-like object.\n|\n| If `path` is an URL, it will be downloaded, stored in the\n| `DataSource` directory and opened from there.\n|\n| Parameters\n| ----------\n| path : str\n| Local file path or URL to open.\n| mode : {'r', 'w', 'a'}, optional\n| Mode to open `path`. Mode 'r' for reading, 'w' for writing,\n| 'a' to append. Available modes depend on the type of object\n| specified by `path`. Default is 'r'.\n| encoding : {None, str}, optional\n| Open text file with given encoding. The default encoding will be\n| what `io.open` uses.\n| newline : {None, str}, optional\n| Newline to use when reading text file.\n|\n| Returns\n| -------\n| out : file object\n| File object.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class MachAr", "content": "| MachAr(floatconv=, intconv=, floattofloat=, floattostr= at 0x7fd5c0397130>, title='Python floating point number')\n|\n| Diagnosing machine parameters.\n|\n| Attributes\n| ----------\n| ibeta : int\n| Radix in which numbers are represented.\n| it : int\n| Number of base-`ibeta` digits in the floating point mantissa M.\n| machep : int\n| Exponent of the smallest (most negative) power of `ibeta` that,\n| added to 1.0, gives something different from 1.0\n| eps : float\n| Floating-point number ``betamachep`` (floating point precision)\n| negep : int\n| Exponent of the smallest power of `ibeta` that, subtracted\n| from 1.0, gives something different from 1.0.\n| epsneg : float\n| Floating-point number ``betanegep``.\n| iexp : int\n| Number of bits in the exponent (including its sign and bias).\n| minexp : int\n| Smallest (most negative) power of `ibeta` consistent with there\n| being no leading zeros in the mantissa.\n| xmin : float\n| Floating-point number ``betaminexp`` (the smallest [in\n| magnitude] positive floating point number with full precision).\n| maxexp : int\n| Smallest (positive) power of `ibeta` that causes overflow.\n| xmax : float\n| ``(1-epsneg) * betamaxexp`` (the largest [in magnitude]\n| usable floating value).\n| irnd : int\n| In ``range(6)``, information on what kind of rounding is done\n| in addition, and on how underflow is handled.\n| ngrd : int\n| Number of 'guard digits' used when truncating the product\n| of two mantissas to fit the representation.\n| epsilon : float\n| Same as `eps`.\n| tiny : float\n| Same as `xmin`.\n| huge : float\n| Same as `xmax`.\n| precision : float\n| ``- int(-log10(eps))``\n| resolution : float\n| ``- 10(-precision)``\n|\n| Parameters\n| ----------\n| floatconv : function, optional\n| Function that converts an integer or integer array to a float\n| or float array. Default is `float`.\n| intconv : function, optional\n| Function that converts a float or float array to an integer or\n| integer array. Default is `int`.\n| floattofloat : function, optional\n| Function that converts a float array to float. Default is `float`.\n| Note that this does not seem to do anything useful in the current\n| implementation.\n| floattostr : function, optional\n| Function that converts a single float to a string. Default is\n| ``lambda v:'%24.16e' %v``.\n| title : str, optional\n| Title that is printed in the string representation of `MachAr`.\n|\n| See Also\n| --------\n| finfo : Machine limits for floating point types.\n| iinfo : Machine limits for integer types.\n|\n| References\n| ----------\n| .. [1] Press, Teukolsky, Vetterling and Flannery,\n| \"Numerical Recipes in C++,\" 2nd ed,\n| Cambridge University Press, 2002, p. 31.\n|\n| Methods defined here:\n|\n| init(self, floatconv=, intconv=, floattofloat=, floattostr= at 0x7fd5c0397130>, title='Python floating point number')\n| floatconv - convert integer to float (array)\n| intconv - convert float (array) to integer\n| floattofloat - convert float array to float\n| floattostr - convert array float to str\n| title - description of used floating point numbers\n|\n| str(self)\n| Return str(self).\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class ModuleDeprecationWarning", "content": "| Module deprecation warning.\n|\n| The nose tester turns ordinary Deprecation warnings into test failures.\n| That makes it hard to deprecate whole modules, because they get\n| imported by default. So this is a special Deprecation warning that the\n| nose tester will let pass without making tests fail.\n|\n| Method resolution order:\n| ModuleDeprecationWarning\n| builtins.DeprecationWarning\n| builtins.Warning\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.DeprecationWarning:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.DeprecationWarning:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class RankWarning", "content": "| Issued by `polyfit` when the Vandermonde matrix is rank deficient.\n|\n| For more information, a way to suppress the warning, and an example of\n| `RankWarning` being issued, see `polyfit`.\n|\n| Method resolution order:\n| RankWarning\n| builtins.UserWarning\n| builtins.Warning\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.UserWarning:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.UserWarning:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class TooHardError", "content": "| Method resolution order:\n| TooHardError\n| builtins.RuntimeError\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.RuntimeError:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.RuntimeError:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n" }, { "name": "class VisibleDeprecationWarning", "content": "| Visible deprecation warning.\n|\n| By default, python will not show deprecation warnings, so this class\n| can be used when a very visible warning is helpful, for example because\n| the usage is most likely a user bug.\n|\n| Method resolution order:\n| VisibleDeprecationWarning\n| builtins.UserWarning\n| builtins.Warning\n| builtins.Exception\n| builtins.BaseException\n| builtins.object\n|\n| Data descriptors defined here:\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.UserWarning:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.UserWarning:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.BaseException:\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| reduce(...)\n| Helper for pickle.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| setattr(self, name, value, /)\n| Implement setattr(self, name, value).\n|\n| setstate(...)\n|\n| str(self, /)\n| Return str(self).\n|\n| withtraceback(...)\n| Exception.withtraceback(tb) --\n| set self.traceback to tb and return self.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from builtins.BaseException:\n|\n| cause\n| exception cause\n|\n| context\n| exception context\n|\n| dict\n|\n| suppresscontext\n|\n| traceback\n|\n| args\n\nbool8 = class bool(generic)\n| Boolean type (True or False), stored as a byte.\n|\n| .. warning::\n|\n| The :class:`bool` type is not a subclass of the :class:`int` type\n| (the :class:`bool` is not even a number type). This is different\n| than Python's default implementation of :class:`bool` as a\n| sub-class of :class:`int`.\n|\n| :Character code: ``'?'``\n| :Alias: `numpy.bool8`\n|\n| Method resolution order:\n| bool\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class bool_", "content": "| Boolean type (True or False), stored as a byte.\n|\n| .. warning::\n|\n| The :class:`bool` type is not a subclass of the :class:`int` type\n| (the :class:`bool` is not even a number type). This is different\n| than Python's default implementation of :class:`bool` as a\n| sub-class of :class:`int`.\n|\n| :Character code: ``'?'``\n| :Alias: `numpy.bool8`\n|\n| Method resolution order:\n| bool\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class broadcast", "content": "| Produce an object that mimics broadcasting.\n|\n| Parameters\n| ----------\n| in1, in2, ... : arraylike\n| Input parameters.\n|\n| Returns\n| -------\n| b : broadcast object\n| Broadcast the input parameters against one another, and\n| return an object that encapsulates the result.\n| Amongst others, it has ``shape`` and ``nd`` properties, and\n| may be used as an iterator.\n|\n| See Also\n| --------\n| broadcastarrays\n| broadcastto\n| broadcastshapes\n|\n| Examples\n| --------\n|\n| Manually adding two vectors, using broadcasting:\n|\n| >>> x = np.array([[1], [2], [3]])\n| >>> y = np.array([4, 5, 6])\n| >>> b = np.broadcast(x, y)\n|\n| >>> out = np.empty(b.shape)\n| >>> out.flat = [u+v for (u,v) in b]\n| >>> out\n| array([[5., 6., 7.],\n| [6., 7., 8.],\n| [7., 8., 9.]])\n|\n| Compare against built-in broadcasting:\n|\n| >>> x + y\n| array([[5, 6, 7],\n| [6, 7, 8],\n| [7, 8, 9]])\n|\n| Methods defined here:\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| next(self, /)\n| Implement next(self).\n|\n| reset(...)\n| reset()\n|\n| Reset the broadcasted result's iterator(s).\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| None\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> y = np.array([[4], [5], [6]])\n| >>> b = np.broadcast(x, y)\n| >>> b.index\n| 0\n| >>> next(b), next(b), next(b)\n| ((1, 4), (2, 4), (3, 4))\n| >>> b.index\n| 3\n| >>> b.reset()\n| >>> b.index\n| 0\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| index\n| current index in broadcasted result\n|\n| Examples\n| --------\n| >>> x = np.array([[1], [2], [3]])\n| >>> y = np.array([4, 5, 6])\n| >>> b = np.broadcast(x, y)\n| >>> b.index\n| 0\n| >>> next(b), next(b), next(b)\n| ((1, 4), (1, 5), (1, 6))\n| >>> b.index\n| 3\n|\n| iters\n| tuple of iterators along ``self``'s \"components.\"\n|\n| Returns a tuple of `numpy.flatiter` objects, one for each \"component\"\n| of ``self``.\n|\n| See Also\n| --------\n| numpy.flatiter\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> y = np.array([[4], [5], [6]])\n| >>> b = np.broadcast(x, y)\n| >>> row, col = b.iters\n| >>> next(row), next(col)\n| (1, 4)\n|\n| nd\n| Number of dimensions of broadcasted result. For code intended for NumPy\n| 1.12.0 and later the more consistent `ndim` is preferred.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> y = np.array([[4], [5], [6]])\n| >>> b = np.broadcast(x, y)\n| >>> b.nd\n| 2\n|\n| ndim\n| Number of dimensions of broadcasted result. Alias for `nd`.\n|\n| .. versionadded:: 1.12.0\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> y = np.array([[4], [5], [6]])\n| >>> b = np.broadcast(x, y)\n| >>> b.ndim\n| 2\n|\n| numiter\n| Number of iterators possessed by the broadcasted result.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> y = np.array([[4], [5], [6]])\n| >>> b = np.broadcast(x, y)\n| >>> b.numiter\n| 2\n|\n| shape\n| Shape of broadcasted result.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> y = np.array([[4], [5], [6]])\n| >>> b = np.broadcast(x, y)\n| >>> b.shape\n| (3, 3)\n|\n| size\n| Total size of broadcasted result.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> y = np.array([[4], [5], [6]])\n| >>> b = np.broadcast(x, y)\n| >>> b.size\n| 9\n" }, { "name": "class busdaycalendar", "content": "| busdaycalendar(weekmask='1111100', holidays=None)\n|\n| A business day calendar object that efficiently stores information\n| defining valid days for the busday family of functions.\n|\n| The default valid days are Monday through Friday (\"business days\").\n| A busdaycalendar object can be specified with any set of weekly\n| valid days, plus an optional \"holiday\" dates that always will be invalid.\n|\n| Once a busdaycalendar object is created, the weekmask and holidays\n| cannot be modified.\n|\n| .. versionadded:: 1.7.0\n|\n| Parameters\n| ----------\n| weekmask : str or arraylike of bool, optional\n| A seven-element array indicating which of Monday through Sunday are\n| valid days. May be specified as a length-seven list or array, like\n| [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string\n| like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for\n| weekdays, optionally separated by white space. Valid abbreviations\n| are: Mon Tue Wed Thu Fri Sat Sun\n| holidays : arraylike of datetime64[D], optional\n| An array of dates to consider as invalid dates, no matter which\n| weekday they fall upon. Holiday dates may be specified in any\n| order, and NaT (not-a-time) dates are ignored. This list is\n| saved in a normalized form that is suited for fast calculations\n| of valid days.\n|\n| Returns\n| -------\n| out : busdaycalendar\n| A business day calendar object containing the specified\n| weekmask and holidays values.\n|\n| See Also\n| --------\n| isbusday : Returns a boolean array indicating valid days.\n| busdayoffset : Applies an offset counted in valid days.\n| busdaycount : Counts how many valid days are in a half-open date range.\n|\n| Attributes\n| ----------\n| Note: once a busdaycalendar object is created, you cannot modify the\n| weekmask or holidays. The attributes return copies of internal data.\n| weekmask : (copy) seven-element array of bool\n| holidays : (copy) sorted array of datetime64[D]\n|\n| Examples\n| --------\n| >>> # Some important days in July\n| ... bdd = np.busdaycalendar(\n| ... holidays=['2011-07-01', '2011-07-04', '2011-07-17'])\n| >>> # Default is Monday to Friday weekdays\n| ... bdd.weekmask\n| array([ True, True, True, True, True, False, False])\n| >>> # Any holidays already on the weekend are removed\n| ... bdd.holidays\n| array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]')\n|\n| Methods defined here:\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| holidays\n| A copy of the holiday array indicating additional invalid days.\n|\n| weekmask\n| A copy of the seven-element boolean mask indicating valid days.\n\nbyte = class int8(signedinteger)\n| Signed integer type, compatible with C ``char``.\n|\n| :Character code: ``'b'``\n| :Canonical name: `numpy.byte`\n| :Alias on this platform (Linux x8664): `numpy.int8`: 8-bit signed integer (``-128`` to ``127``).\n|\n| Method resolution order:\n| int8\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nbytes0 = class bytes(builtins.bytes, character)\n| A byte string.\n|\n| When used in arrays, this type strips trailing null bytes.\n|\n| :Character code: ``'S'``\n| :Alias: `numpy.string`\n|\n| Method resolution order:\n| bytes\n| builtins.bytes\n| character\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self copy of B\n|\n| Return a copy of B with only its first character capitalized (ASCII)\n| and the rest lower-cased.\n|\n| center(self, width, fillchar=b' ', /)\n| Return a centered string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| count(...)\n| B.count(sub[, start[, end]]) -> int\n|\n| Return the number of non-overlapping occurrences of subsection sub in\n| bytes B[start:end]. Optional arguments start and end are interpreted\n| as in slice notation.\n|\n| decode(self, /, encoding='utf-8', errors='strict')\n| Decode the bytes using the codec registered for encoding.\n|\n| encoding\n| The encoding with which to decode the bytes.\n| errors\n| The error handling scheme to use for the handling of decoding errors.\n| The default is 'strict' meaning that decoding errors raise a\n| UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n| as well as any other name registered with codecs.registererror that\n| can handle UnicodeDecodeErrors.\n|\n| endswith(...)\n| B.endswith(suffix[, start[, end]]) -> bool\n|\n| Return True if B ends with the specified suffix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| suffix can also be a tuple of bytes to try.\n|\n| expandtabs(self, /, tabsize=8)\n| Return a copy where all tab characters are expanded using spaces.\n|\n| If tabsize is not given, a tab size of 8 characters is assumed.\n|\n| find(...)\n| B.find(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| hex(...)\n| Create a string of hexadecimal numbers from a bytes object.\n|\n| sep\n| An optional single character or byte to separate hex bytes.\n| bytespersep\n| How many bytes between separators. Positive values count from the\n| right, negative values count from the left.\n|\n| Example:\n| >>> value = b'\\xb9\\x01\\xef'\n| >>> value.hex()\n| 'b901ef'\n| >>> value.hex(':')\n| 'b9:01:ef'\n| >>> value.hex(':', 2)\n| 'b9:01ef'\n| >>> value.hex(':', -2)\n| 'b901:ef'\n|\n| index(...)\n| B.index(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the subsection is not found.\n|\n| isalnum(...)\n| B.isalnum() -> bool\n|\n| Return True if all characters in B are alphanumeric\n| and there is at least one character in B, False otherwise.\n|\n| isalpha(...)\n| B.isalpha() -> bool\n|\n| Return True if all characters in B are alphabetic\n| and there is at least one character in B, False otherwise.\n|\n| isascii(...)\n| B.isascii() -> bool\n|\n| Return True if B is empty or all characters in B are ASCII,\n| False otherwise.\n|\n| isdigit(...)\n| B.isdigit() -> bool\n|\n| Return True if all characters in B are digits\n| and there is at least one character in B, False otherwise.\n|\n| islower(...)\n| B.islower() -> bool\n|\n| Return True if all cased characters in B are lowercase and there is\n| at least one cased character in B, False otherwise.\n|\n| isspace(...)\n| B.isspace() -> bool\n|\n| Return True if all characters in B are whitespace\n| and there is at least one character in B, False otherwise.\n|\n| istitle(...)\n| B.istitle() -> bool\n|\n| Return True if B is a titlecased string and there is at least one\n| character in B, i.e. uppercase characters may only follow uncased\n| characters and lowercase characters only cased ones. Return False\n| otherwise.\n|\n| isupper(...)\n| B.isupper() -> bool\n|\n| Return True if all cased characters in B are uppercase and there is\n| at least one cased character in B, False otherwise.\n|\n| join(self, iterableofbytes, /)\n| Concatenate any number of bytes objects.\n|\n| The bytes whose method is called is inserted in between each pair.\n|\n| The result is returned as a new bytes object.\n|\n| Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.\n|\n| ljust(self, width, fillchar=b' ', /)\n| Return a left-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| lower(...)\n| B.lower() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to lowercase.\n|\n| lstrip(self, bytes=None, /)\n| Strip leading bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading ASCII whitespace.\n|\n| partition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes. If the separator is found,\n| returns a 3-tuple containing the part before the separator, the separator\n| itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing the original bytes\n| object and two empty bytes objects.\n|\n| removeprefix(self, prefix, /)\n| Return a bytes object with the given prefix string removed if present.\n|\n| If the bytes starts with the prefix string, return bytes[len(prefix):].\n| Otherwise, return a copy of the original bytes.\n|\n| removesuffix(self, suffix, /)\n| Return a bytes object with the given suffix string removed if present.\n|\n| If the bytes ends with the suffix string and that suffix is not empty,\n| return bytes[:-len(prefix)]. Otherwise, return a copy of the original\n| bytes.\n|\n| replace(self, old, new, count=-1, /)\n| Return a copy with all occurrences of substring old replaced by new.\n|\n| count\n| Maximum number of occurrences to replace.\n| -1 (the default value) means replace all occurrences.\n|\n| If the optional argument count is given, only the first count occurrences are\n| replaced.\n|\n| rfind(...)\n| B.rfind(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| rindex(...)\n| B.rindex(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raise ValueError when the subsection is not found.\n|\n| rjust(self, width, fillchar=b' ', /)\n| Return a right-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| rpartition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes, starting at the end. If\n| the separator is found, returns a 3-tuple containing the part before the\n| separator, the separator itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing two empty bytes\n| objects and the original bytes object.\n|\n| rsplit(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| Splitting is done starting at the end of the bytes and working to the front.\n|\n| rstrip(self, bytes=None, /)\n| Strip trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip trailing ASCII whitespace.\n|\n| split(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| splitlines(self, /, keepends=False)\n| Return a list of the lines in the bytes, breaking at line boundaries.\n|\n| Line breaks are not included in the resulting list unless keepends is given and\n| true.\n|\n| startswith(...)\n| B.startswith(prefix[, start[, end]]) -> bool\n|\n| Return True if B starts with the specified prefix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| prefix can also be a tuple of bytes to try.\n|\n| strip(self, bytes=None, /)\n| Strip leading and trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading and trailing ASCII whitespace.\n|\n| swapcase(...)\n| B.swapcase() -> copy of B\n|\n| Return a copy of B with uppercase ASCII characters converted\n| to lowercase ASCII and vice versa.\n|\n| title(...)\n| B.title() -> copy of B\n|\n| Return a titlecased version of B, i.e. ASCII words start with uppercase\n| characters, all remaining cased characters have lowercase.\n|\n| translate(self, table, /, delete=b'')\n| Return a copy with each character mapped by the given translation table.\n|\n| table\n| Translation table, which must be a bytes object of length 256.\n|\n| All characters occurring in the optional argument delete are removed.\n| The remaining characters are mapped through the given translation table.\n|\n| upper(...)\n| B.upper() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to uppercase.\n|\n| zfill(self, width, /)\n| Pad a numeric string with zeros on the left, to fill a field of the given width.\n|\n| The original string is never truncated.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.bytes:\n|\n| fromhex(string, /) from builtins.type\n| Create a bytes object from a string of hexadecimal numbers.\n|\n| Spaces between two numbers are accepted.\n| Example: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.bytes:\n|\n| maketrans(frm, to, /)\n| Return a translation table useable for the bytes or bytearray translate method.\n|\n| The returned table will be one where each byte in frm is mapped to the byte at\n| the same position in to.\n|\n| The bytes objects frm and to must be of the same length.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class bytes_", "content": "| A byte string.\n|\n| When used in arrays, this type strips trailing null bytes.\n|\n| :Character code: ``'S'``\n| :Alias: `numpy.string`\n|\n| Method resolution order:\n| bytes\n| builtins.bytes\n| character\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self copy of B\n|\n| Return a copy of B with only its first character capitalized (ASCII)\n| and the rest lower-cased.\n|\n| center(self, width, fillchar=b' ', /)\n| Return a centered string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| count(...)\n| B.count(sub[, start[, end]]) -> int\n|\n| Return the number of non-overlapping occurrences of subsection sub in\n| bytes B[start:end]. Optional arguments start and end are interpreted\n| as in slice notation.\n|\n| decode(self, /, encoding='utf-8', errors='strict')\n| Decode the bytes using the codec registered for encoding.\n|\n| encoding\n| The encoding with which to decode the bytes.\n| errors\n| The error handling scheme to use for the handling of decoding errors.\n| The default is 'strict' meaning that decoding errors raise a\n| UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n| as well as any other name registered with codecs.registererror that\n| can handle UnicodeDecodeErrors.\n|\n| endswith(...)\n| B.endswith(suffix[, start[, end]]) -> bool\n|\n| Return True if B ends with the specified suffix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| suffix can also be a tuple of bytes to try.\n|\n| expandtabs(self, /, tabsize=8)\n| Return a copy where all tab characters are expanded using spaces.\n|\n| If tabsize is not given, a tab size of 8 characters is assumed.\n|\n| find(...)\n| B.find(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| hex(...)\n| Create a string of hexadecimal numbers from a bytes object.\n|\n| sep\n| An optional single character or byte to separate hex bytes.\n| bytespersep\n| How many bytes between separators. Positive values count from the\n| right, negative values count from the left.\n|\n| Example:\n| >>> value = b'\\xb9\\x01\\xef'\n| >>> value.hex()\n| 'b901ef'\n| >>> value.hex(':')\n| 'b9:01:ef'\n| >>> value.hex(':', 2)\n| 'b9:01ef'\n| >>> value.hex(':', -2)\n| 'b901:ef'\n|\n| index(...)\n| B.index(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the subsection is not found.\n|\n| isalnum(...)\n| B.isalnum() -> bool\n|\n| Return True if all characters in B are alphanumeric\n| and there is at least one character in B, False otherwise.\n|\n| isalpha(...)\n| B.isalpha() -> bool\n|\n| Return True if all characters in B are alphabetic\n| and there is at least one character in B, False otherwise.\n|\n| isascii(...)\n| B.isascii() -> bool\n|\n| Return True if B is empty or all characters in B are ASCII,\n| False otherwise.\n|\n| isdigit(...)\n| B.isdigit() -> bool\n|\n| Return True if all characters in B are digits\n| and there is at least one character in B, False otherwise.\n|\n| islower(...)\n| B.islower() -> bool\n|\n| Return True if all cased characters in B are lowercase and there is\n| at least one cased character in B, False otherwise.\n|\n| isspace(...)\n| B.isspace() -> bool\n|\n| Return True if all characters in B are whitespace\n| and there is at least one character in B, False otherwise.\n|\n| istitle(...)\n| B.istitle() -> bool\n|\n| Return True if B is a titlecased string and there is at least one\n| character in B, i.e. uppercase characters may only follow uncased\n| characters and lowercase characters only cased ones. Return False\n| otherwise.\n|\n| isupper(...)\n| B.isupper() -> bool\n|\n| Return True if all cased characters in B are uppercase and there is\n| at least one cased character in B, False otherwise.\n|\n| join(self, iterableofbytes, /)\n| Concatenate any number of bytes objects.\n|\n| The bytes whose method is called is inserted in between each pair.\n|\n| The result is returned as a new bytes object.\n|\n| Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.\n|\n| ljust(self, width, fillchar=b' ', /)\n| Return a left-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| lower(...)\n| B.lower() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to lowercase.\n|\n| lstrip(self, bytes=None, /)\n| Strip leading bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading ASCII whitespace.\n|\n| partition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes. If the separator is found,\n| returns a 3-tuple containing the part before the separator, the separator\n| itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing the original bytes\n| object and two empty bytes objects.\n|\n| removeprefix(self, prefix, /)\n| Return a bytes object with the given prefix string removed if present.\n|\n| If the bytes starts with the prefix string, return bytes[len(prefix):].\n| Otherwise, return a copy of the original bytes.\n|\n| removesuffix(self, suffix, /)\n| Return a bytes object with the given suffix string removed if present.\n|\n| If the bytes ends with the suffix string and that suffix is not empty,\n| return bytes[:-len(prefix)]. Otherwise, return a copy of the original\n| bytes.\n|\n| replace(self, old, new, count=-1, /)\n| Return a copy with all occurrences of substring old replaced by new.\n|\n| count\n| Maximum number of occurrences to replace.\n| -1 (the default value) means replace all occurrences.\n|\n| If the optional argument count is given, only the first count occurrences are\n| replaced.\n|\n| rfind(...)\n| B.rfind(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| rindex(...)\n| B.rindex(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raise ValueError when the subsection is not found.\n|\n| rjust(self, width, fillchar=b' ', /)\n| Return a right-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| rpartition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes, starting at the end. If\n| the separator is found, returns a 3-tuple containing the part before the\n| separator, the separator itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing two empty bytes\n| objects and the original bytes object.\n|\n| rsplit(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| Splitting is done starting at the end of the bytes and working to the front.\n|\n| rstrip(self, bytes=None, /)\n| Strip trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip trailing ASCII whitespace.\n|\n| split(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| splitlines(self, /, keepends=False)\n| Return a list of the lines in the bytes, breaking at line boundaries.\n|\n| Line breaks are not included in the resulting list unless keepends is given and\n| true.\n|\n| startswith(...)\n| B.startswith(prefix[, start[, end]]) -> bool\n|\n| Return True if B starts with the specified prefix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| prefix can also be a tuple of bytes to try.\n|\n| strip(self, bytes=None, /)\n| Strip leading and trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading and trailing ASCII whitespace.\n|\n| swapcase(...)\n| B.swapcase() -> copy of B\n|\n| Return a copy of B with uppercase ASCII characters converted\n| to lowercase ASCII and vice versa.\n|\n| title(...)\n| B.title() -> copy of B\n|\n| Return a titlecased version of B, i.e. ASCII words start with uppercase\n| characters, all remaining cased characters have lowercase.\n|\n| translate(self, table, /, delete=b'')\n| Return a copy with each character mapped by the given translation table.\n|\n| table\n| Translation table, which must be a bytes object of length 256.\n|\n| All characters occurring in the optional argument delete are removed.\n| The remaining characters are mapped through the given translation table.\n|\n| upper(...)\n| B.upper() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to uppercase.\n|\n| zfill(self, width, /)\n| Pad a numeric string with zeros on the left, to fill a field of the given width.\n|\n| The original string is never truncated.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.bytes:\n|\n| fromhex(string, /) from builtins.type\n| Create a bytes object from a string of hexadecimal numbers.\n|\n| Spaces between two numbers are accepted.\n| Example: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.bytes:\n|\n| maketrans(frm, to, /)\n| Return a translation table useable for the bytes or bytearray translate method.\n|\n| The returned table will be one where each byte in frm is mapped to the byte at\n| the same position in to.\n|\n| The bytes objects frm and to must be of the same length.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\ncdouble = class complex128(complexfloating, builtins.complex)\n| cdouble(real=0, imag=0)\n|\n| Complex number type composed of two double-precision floating-point\n| numbers, compatible with Python `complex`.\n|\n| :Character code: ``'D'``\n| :Canonical name: `numpy.cdouble`\n| :Alias: `numpy.cfloat`\n| :Alias: `numpy.complex`\n| :Alias on this platform (Linux x8664): `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers.\n|\n| Method resolution order:\n| complex128\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.complex\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.complex:\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getnewargs(self, /)\n\ncfloat = class complex128(complexfloating, builtins.complex)\n| cfloat(real=0, imag=0)\n|\n| Complex number type composed of two double-precision floating-point\n| numbers, compatible with Python `complex`.\n|\n| :Character code: ``'D'``\n| :Canonical name: `numpy.cdouble`\n| :Alias: `numpy.cfloat`\n| :Alias: `numpy.complex`\n| :Alias on this platform (Linux x8664): `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers.\n|\n| Method resolution order:\n| complex128\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.complex\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.complex:\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getnewargs(self, /)\n" }, { "name": "class character", "content": "| Abstract base class of all character string scalar types.\n|\n| Method resolution order:\n| character\n| flexible\n| generic\n| builtins.object\n|\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n" }, { "name": "class chararray", "content": "| chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order='C')\n|\n| chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,\n| strides=None, order=None)\n|\n| Provides a convenient view on arrays of string and unicode values.\n|\n| .. note::\n| The `chararray` class exists for backwards compatibility with\n| Numarray, it is not recommended for new development. Starting from numpy\n| 1.4, if one needs arrays of strings, it is recommended to use arrays of\n| `dtype` `object`, `string` or `unicode`, and use the free functions\n| in the `numpy.char` module for fast vectorized string operations.\n|\n| Versus a regular NumPy array of type `str` or `unicode`, this\n| class adds the following functionality:\n|\n| 1) values automatically have whitespace removed from the end\n| when indexed\n|\n| 2) comparison operators automatically remove whitespace from the\n| end when comparing values\n|\n| 3) vectorized string operations are provided as methods\n| (e.g. `.endswith`) and infix operators (e.g. ``\"+\", \"*\", \"%\"``)\n|\n| chararrays should be created using `numpy.char.array` or\n| `numpy.char.asarray`, rather than this constructor directly.\n|\n| This constructor creates the array, using `buffer` (with `offset`\n| and `strides`) if it is not ``None``. If `buffer` is ``None``, then\n| constructs a new array with `strides` in \"C order\", unless both\n| ``len(shape) >= 2`` and ``order='F'``, in which case `strides`\n| is in \"Fortran order\".\n|\n| Methods\n| -------\n| astype\n| argsort\n| copy\n| count\n| decode\n| dump\n| dumps\n| encode\n| endswith\n| expandtabs\n| fill\n| find\n| flatten\n| getfield\n| index\n| isalnum\n| isalpha\n| isdecimal\n| isdigit\n| islower\n| isnumeric\n| isspace\n| istitle\n| isupper\n| item\n| join\n| ljust\n| lower\n| lstrip\n| nonzero\n| put\n| ravel\n| repeat\n| replace\n| reshape\n| resize\n| rfind\n| rindex\n| rjust\n| rsplit\n| rstrip\n| searchsorted\n| setfield\n| setflags\n| sort\n| split\n| splitlines\n| squeeze\n| startswith\n| strip\n| swapaxes\n| swapcase\n| take\n| title\n| tofile\n| tolist\n| tostring\n| translate\n| transpose\n| upper\n| view\n| zfill\n|\n| Parameters\n| ----------\n| shape : tuple\n| Shape of the array.\n| itemsize : int, optional\n| Length of each array element, in number of characters. Default is 1.\n| unicode : bool, optional\n| Are the array elements of type unicode (True) or string (False).\n| Default is False.\n| buffer : object exposing the buffer interface or str, optional\n| Memory address of the start of the array data. Default is None,\n| in which case a new array is created.\n| offset : int, optional\n| Fixed stride displacement from the beginning of an axis?\n| Default is 0. Needs to be >=0.\n| strides : arraylike of ints, optional\n| Strides for the array (see `ndarray.strides` for full description).\n| Default is None.\n| order : {'C', 'F'}, optional\n| The order in which the array data is stored in memory: 'C' ->\n| \"row major\" order (the default), 'F' -> \"column major\"\n| (Fortran) order.\n|\n| Examples\n| --------\n| >>> charar = np.chararray((3, 3))\n| >>> charar[:] = 'a'\n| >>> charar\n| chararray([[b'a', b'a', b'a'],\n| [b'a', b'a', b'a'],\n| [b'a', b'a', b'a']], dtype='|S1')\n|\n| >>> charar = np.chararray(charar.shape, itemsize=5)\n| >>> charar[:] = 'abc'\n| >>> charar\n| chararray([[b'abc', b'abc', b'abc'],\n| [b'abc', b'abc', b'abc'],\n| [b'abc', b'abc', b'abc']], dtype='|S5')\n|\n| Method resolution order:\n| chararray\n| ndarray\n| builtins.object\n|\n| Methods defined here:\n|\n| add(self, other)\n| Return (self + other), that is string concatenation,\n| element-wise for a pair of arraylikes of str or unicode.\n|\n| See Also\n| --------\n| add\n|\n| arrayfinalize(self, obj)\n| None.\n|\n| eq(self, other)\n| Return (self == other) element-wise.\n|\n| See Also\n| --------\n| equal\n|\n| ge(self, other)\n| Return (self >= other) element-wise.\n|\n| See Also\n| --------\n| greaterequal\n|\n| getitem(self, obj)\n| Return self[key].\n|\n| gt(self, other)\n| Return (self > other) element-wise.\n|\n| See Also\n| --------\n| greater\n|\n| le(self, other)\n| Return (self <= other) element-wise.\n|\n| See Also\n| --------\n| lessequal\n|\n| lt(self, other)\n| Return (self < other) element-wise.\n|\n| See Also\n| --------\n| less\n|\n| mod(self, i)\n| Return (self % i), that is pre-Python 2.6 string formatting\n| (interpolation), element-wise for a pair of arraylikes of `string`\n| or `unicode`.\n|\n| See Also\n| --------\n| mod\n|\n| mul(self, i)\n| Return (self * i), that is string multiple concatenation,\n| element-wise.\n|\n| See Also\n| --------\n| multiply\n|\n| ne(self, other)\n| Return (self != other) element-wise.\n|\n| See Also\n| --------\n| notequal\n|\n| radd(self, other)\n| Return (other + self), that is string concatenation,\n| element-wise for a pair of arraylikes of `string` or `unicode`.\n|\n| See Also\n| --------\n| add\n|\n| rmod(self, other)\n| Return value%self.\n|\n| rmul(self, i)\n| Return (self * i), that is string multiple concatenation,\n| element-wise.\n|\n| See Also\n| --------\n| multiply\n|\n| argsort(self, axis=-1, kind=None, order=None)\n| a.argsort(axis=-1, kind=None, order=None)\n|\n| Returns the indices that would sort this array.\n|\n| Refer to `numpy.argsort` for full documentation.\n|\n| See Also\n| --------\n| numpy.argsort : equivalent function\n|\n| capitalize(self)\n| Return a copy of `self` with only the first character of each element\n| capitalized.\n|\n| See Also\n| --------\n| char.capitalize\n|\n| center(self, width, fillchar=' ')\n| Return a copy of `self` with its elements centered in a\n| string of length `width`.\n|\n| See Also\n| --------\n| center\n|\n| count(self, sub, start=0, end=None)\n| Returns an array with the number of non-overlapping occurrences of\n| substring `sub` in the range [`start`, `end`].\n|\n| See Also\n| --------\n| char.count\n|\n| decode(self, encoding=None, errors=None)\n| Calls `str.decode` element-wise.\n|\n| See Also\n| --------\n| char.decode\n|\n| encode(self, encoding=None, errors=None)\n| Calls `str.encode` element-wise.\n|\n| See Also\n| --------\n| char.encode\n|\n| endswith(self, suffix, start=0, end=None)\n| Returns a boolean array which is `True` where the string element\n| in `self` ends with `suffix`, otherwise `False`.\n|\n| See Also\n| --------\n| char.endswith\n|\n| expandtabs(self, tabsize=8)\n| Return a copy of each string element where all tab characters are\n| replaced by one or more spaces.\n|\n| See Also\n| --------\n| char.expandtabs\n|\n| find(self, sub, start=0, end=None)\n| For each element, return the lowest index in the string where\n| substring `sub` is found.\n|\n| See Also\n| --------\n| char.find\n|\n| index(self, sub, start=0, end=None)\n| Like `find`, but raises `ValueError` when the substring is not found.\n|\n| See Also\n| --------\n| char.index\n|\n| isalnum(self)\n| Returns true for each element if all characters in the string\n| are alphanumeric and there is at least one character, false\n| otherwise.\n|\n| See Also\n| --------\n| char.isalnum\n|\n| isalpha(self)\n| Returns true for each element if all characters in the string\n| are alphabetic and there is at least one character, false\n| otherwise.\n|\n| See Also\n| --------\n| char.isalpha\n|\n| isdecimal(self)\n| For each element in `self`, return True if there are only\n| decimal characters in the element.\n|\n| See Also\n| --------\n| char.isdecimal\n|\n| isdigit(self)\n| Returns true for each element if all characters in the string are\n| digits and there is at least one character, false otherwise.\n|\n| See Also\n| --------\n| char.isdigit\n|\n| islower(self)\n| Returns true for each element if all cased characters in the\n| string are lowercase and there is at least one cased character,\n| false otherwise.\n|\n| See Also\n| --------\n| char.islower\n|\n| isnumeric(self)\n| For each element in `self`, return True if there are only\n| numeric characters in the element.\n|\n| See Also\n| --------\n| char.isnumeric\n|\n| isspace(self)\n| Returns true for each element if there are only whitespace\n| characters in the string and there is at least one character,\n| false otherwise.\n|\n| See Also\n| --------\n| char.isspace\n|\n| istitle(self)\n| Returns true for each element if the element is a titlecased\n| string and there is at least one character, false otherwise.\n|\n| See Also\n| --------\n| char.istitle\n|\n| isupper(self)\n| Returns true for each element if all cased characters in the\n| string are uppercase and there is at least one character, false\n| otherwise.\n|\n| See Also\n| --------\n| char.isupper\n|\n| join(self, seq)\n| Return a string which is the concatenation of the strings in the\n| sequence `seq`.\n|\n| See Also\n| --------\n| char.join\n|\n| ljust(self, width, fillchar=' ')\n| Return an array with the elements of `self` left-justified in a\n| string of length `width`.\n|\n| See Also\n| --------\n| char.ljust\n|\n| lower(self)\n| Return an array with the elements of `self` converted to\n| lowercase.\n|\n| See Also\n| --------\n| char.lower\n|\n| lstrip(self, chars=None)\n| For each element in `self`, return a copy with the leading characters\n| removed.\n|\n| See Also\n| --------\n| char.lstrip\n|\n| partition(self, sep)\n| Partition each element in `self` around `sep`.\n|\n| See Also\n| --------\n| partition\n|\n| replace(self, old, new, count=None)\n| For each element in `self`, return a copy of the string with all\n| occurrences of substring `old` replaced by `new`.\n|\n| See Also\n| --------\n| char.replace\n|\n| rfind(self, sub, start=0, end=None)\n| For each element in `self`, return the highest index in the string\n| where substring `sub` is found, such that `sub` is contained\n| within [`start`, `end`].\n|\n| See Also\n| --------\n| char.rfind\n|\n| rindex(self, sub, start=0, end=None)\n| Like `rfind`, but raises `ValueError` when the substring `sub` is\n| not found.\n|\n| See Also\n| --------\n| char.rindex\n|\n| rjust(self, width, fillchar=' ')\n| Return an array with the elements of `self`\n| right-justified in a string of length `width`.\n|\n| See Also\n| --------\n| char.rjust\n|\n| rpartition(self, sep)\n| Partition each element in `self` around `sep`.\n|\n| See Also\n| --------\n| rpartition\n|\n| rsplit(self, sep=None, maxsplit=None)\n| For each element in `self`, return a list of the words in\n| the string, using `sep` as the delimiter string.\n|\n| See Also\n| --------\n| char.rsplit\n|\n| rstrip(self, chars=None)\n| For each element in `self`, return a copy with the trailing\n| characters removed.\n|\n| See Also\n| --------\n| char.rstrip\n|\n| split(self, sep=None, maxsplit=None)\n| For each element in `self`, return a list of the words in the\n| string, using `sep` as the delimiter string.\n|\n| See Also\n| --------\n| char.split\n|\n| splitlines(self, keepends=None)\n| For each element in `self`, return a list of the lines in the\n| element, breaking at line boundaries.\n|\n| See Also\n| --------\n| char.splitlines\n|\n| startswith(self, prefix, start=0, end=None)\n| Returns a boolean array which is `True` where the string element\n| in `self` starts with `prefix`, otherwise `False`.\n|\n| See Also\n| --------\n| char.startswith\n|\n| strip(self, chars=None)\n| For each element in `self`, return a copy with the leading and\n| trailing characters removed.\n|\n| See Also\n| --------\n| char.strip\n|\n| swapcase(self)\n| For each element in `self`, return a copy of the string with\n| uppercase characters converted to lowercase and vice versa.\n|\n| See Also\n| --------\n| char.swapcase\n|\n| title(self)\n| For each element in `self`, return a titlecased version of the\n| string: words start with uppercase characters, all remaining cased\n| characters are lowercase.\n|\n| See Also\n| --------\n| char.title\n|\n| translate(self, table, deletechars=None)\n| For each element in `self`, return a copy of the string where\n| all characters occurring in the optional argument\n| `deletechars` are removed, and the remaining characters have\n| been mapped through the given translation table.\n|\n| See Also\n| --------\n| char.translate\n|\n| upper(self)\n| Return an array with the elements of `self` converted to\n| uppercase.\n|\n| See Also\n| --------\n| char.upper\n|\n| zfill(self, width)\n| Return the numeric string left-filled with zeros in a string of\n| length `width`.\n|\n| See Also\n| --------\n| char.zfill\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(subtype, shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order='C')\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| hash = None\n|\n| ----------------------------------------------------------------------\n| Methods inherited from ndarray:\n|\n| abs(self, /)\n| abs(self)\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| a.array([dtype], /) -> reference if type unchanged, copy otherwise.\n|\n| Returns either a new reference to self if dtype is not given or a new array\n| of provided data type if dtype is different from the current dtype of the\n| array.\n|\n| arrayfunction(...)\n|\n| arrayprepare(...)\n| a.arrayprepare(obj) -> Object of same type as ndarray object obj.\n|\n| arrayufunc(...)\n|\n| arraywrap(...)\n| a.arraywrap(obj) -> Object of same type as ndarray object a.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| copy(...)\n| a.copy()\n|\n| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.\n|\n| Equivalent to ``a.copy(order='K')``.\n|\n| deepcopy(...)\n| a.deepcopy(memo, /) -> Deep copy of array.\n|\n| Used if :func:`copy.deepcopy` is called on an array.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| Default object formatter.\n|\n| iadd(self, value, /)\n| Return self+=value.\n|\n| iand(self, value, /)\n| Return self&=value.\n|\n| ifloordiv(self, value, /)\n| Return self//=value.\n|\n| ilshift(self, value, /)\n| Return self<<=value.\n|\n| imatmul(self, value, /)\n| Return self@=value.\n|\n| imod(self, value, /)\n| Return self%=value.\n|\n| imul(self, value, /)\n| Return self*=value.\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| ipow(self, value, /)\n| Return self=value.\n|\n| irshift(self, value, /)\n| Return self>>=value.\n|\n| isub(self, value, /)\n| Return self-=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| itruediv(self, value, /)\n| Return self/=value.\n|\n| ixor(self, value, /)\n| Return self^=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setitem(self, key, value, /)\n| Set self[key] to value.\n|\n| setstate(...)\n| a.setstate(state, /)\n|\n| For unpickling.\n|\n| The `state` argument must be a sequence that contains the following\n| elements:\n|\n| Parameters\n| ----------\n| version : int\n| optional pickle version. If omitted defaults to 0.\n| shape : tuple\n| dtype : data-type\n| isFortran : bool\n| rawdata : string or list\n| a binary string with the data (or a list if 'a' is an object array)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| a.all(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if all elements evaluate to True.\n|\n| Refer to `numpy.all` for full documentation.\n|\n| See Also\n| --------\n| numpy.all : equivalent function\n|\n| any(...)\n| a.any(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if any of the elements of `a` evaluate to True.\n|\n| Refer to `numpy.any` for full documentation.\n|\n| See Also\n| --------\n| numpy.any : equivalent function\n|\n| argmax(...)\n| a.argmax(axis=None, out=None)\n|\n| Return indices of the maximum values along the given axis.\n|\n| Refer to `numpy.argmax` for full documentation.\n|\n| See Also\n| --------\n| numpy.argmax : equivalent function\n|\n| argmin(...)\n| a.argmin(axis=None, out=None)\n|\n| Return indices of the minimum values along the given axis.\n|\n| Refer to `numpy.argmin` for detailed documentation.\n|\n| See Also\n| --------\n| numpy.argmin : equivalent function\n|\n| argpartition(...)\n| a.argpartition(kth, axis=-1, kind='introselect', order=None)\n|\n| Returns the indices that would partition this array.\n|\n| Refer to `numpy.argpartition` for full documentation.\n|\n| .. versionadded:: 1.8.0\n|\n| See Also\n| --------\n| numpy.argpartition : equivalent function\n|\n| astype(...)\n| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)\n|\n| Copy of the array, cast to a specified type.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| Typecode or data-type to which the array is cast.\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout order of the result.\n| 'C' means C order, 'F' means Fortran order, 'A'\n| means 'F' order if all the arrays are Fortran contiguous,\n| 'C' order otherwise, and 'K' means as close to the\n| order the array elements appear in memory as possible.\n| Default is 'K'.\n| casting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\n| Controls what kind of data casting may occur. Defaults to 'unsafe'\n| for backwards compatibility.\n|\n| * 'no' means the data types should not be cast at all.\n| * 'equiv' means only byte-order changes are allowed.\n| * 'safe' means only casts which can preserve values are allowed.\n| * 'samekind' means only safe casts or casts within a kind,\n| like float64 to float32, are allowed.\n| * 'unsafe' means any data conversions may be done.\n| subok : bool, optional\n| If True, then sub-classes will be passed-through (default), otherwise\n| the returned array will be forced to be a base-class array.\n| copy : bool, optional\n| By default, astype always returns a newly allocated array. If this\n| is set to false, and the `dtype`, `order`, and `subok`\n| requirements are satisfied, the input array is returned instead\n| of a copy.\n|\n| Returns\n| -------\n| arrt : ndarray\n| Unless `copy` is False and the other conditions for returning the input\n| array are satisfied (see description for `copy` input parameter), `arrt`\n| is a new array of the same shape as the input array, with dtype, order\n| given by `dtype`, `order`.\n|\n| Notes\n| -----\n| .. versionchanged:: 1.17.0\n| Casting between a simple data type and a structured one is possible only\n| for \"unsafe\" casting. Casting to multiple fields is allowed, but\n| casting from multiple fields is not.\n|\n| .. versionchanged:: 1.9.0\n| Casting from numeric to string types in 'safe' casting mode requires\n| that the string dtype length is long enough to store the max\n| integer/float value converted.\n|\n| Raises\n| ------\n| ComplexWarning\n| When casting from complex to float or int. To avoid this,\n| one should use ``a.real.astype(t)``.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 2.5])\n| >>> x\n| array([1. , 2. , 2.5])\n|\n| >>> x.astype(int)\n| array([1, 2, 2])\n|\n| byteswap(...)\n| a.byteswap(inplace=False)\n|\n| Swap the bytes of the array elements\n|\n| Toggle between low-endian and big-endian data representation by\n| returning a byteswapped array, optionally swapped in-place.\n| Arrays of byte-strings are not swapped. The real and imaginary\n| parts of a complex number are swapped individually.\n|\n| Parameters\n| ----------\n| inplace : bool, optional\n| If ``True``, swap bytes in-place, default is ``False``.\n|\n| Returns\n| -------\n| out : ndarray\n| The byteswapped array. If `inplace` is ``True``, this is\n| a view to self.\n|\n| Examples\n| --------\n| >>> A = np.array([1, 256, 8755], dtype=np.int16)\n| >>> list(map(hex, A))\n| ['0x1', '0x100', '0x2233']\n| >>> A.byteswap(inplace=True)\n| array([ 256, 1, 13090], dtype=int16)\n| >>> list(map(hex, A))\n| ['0x100', '0x1', '0x3322']\n|\n| Arrays of byte-strings are not swapped\n|\n| >>> A = np.array([b'ceg', b'fac'])\n| >>> A.byteswap()\n| array([b'ceg', b'fac'], dtype='|S3')\n|\n| ``A.newbyteorder().byteswap()`` produces an array with the same values\n| but different representation in memory\n|\n| >>> A = np.array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,\n| 0, 0], dtype=uint8)\n| >>> A.newbyteorder().byteswap(inplace=True)\n| array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,\n| 0, 3], dtype=uint8)\n|\n| choose(...)\n| a.choose(choices, out=None, mode='raise')\n|\n| Use an index array to construct a new array from a set of choices.\n|\n| Refer to `numpy.choose` for full documentation.\n|\n| See Also\n| --------\n| numpy.choose : equivalent function\n|\n| clip(...)\n| a.clip(min=None, max=None, out=None, kwargs)\n|\n| Return an array whose values are limited to ``[min, max]``.\n| One of max or min must be given.\n|\n| Refer to `numpy.clip` for full documentation.\n|\n| See Also\n| --------\n| numpy.clip : equivalent function\n|\n| compress(...)\n| a.compress(condition, axis=None, out=None)\n|\n| Return selected slices of this array along given axis.\n|\n| Refer to `numpy.compress` for full documentation.\n|\n| See Also\n| --------\n| numpy.compress : equivalent function\n|\n| conj(...)\n| a.conj()\n|\n| Complex-conjugate all elements.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| conjugate(...)\n| a.conjugate()\n|\n| Return the complex conjugate, element-wise.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| copy(...)\n| a.copy(order='C')\n|\n| Return a copy of the array.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout of the copy. 'C' means C-order,\n| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n| 'C' otherwise. 'K' means match the layout of `a` as closely\n| as possible. (Note that this function and :func:`numpy.copy` are very\n| similar but have different default values for their order=\n| arguments, and this function always passes sub-classes through.)\n|\n| See also\n| --------\n| numpy.copy : Similar function with different default behavior\n| numpy.copyto\n|\n| Notes\n| -----\n| This function is the preferred method for creating an array copy. The\n| function :func:`numpy.copy` is similar, but it defaults to using order 'K',\n| and will not pass sub-classes through by default.\n|\n| Examples\n| --------\n| >>> x = np.array([[1,2,3],[4,5,6]], order='F')\n|\n| >>> y = x.copy()\n|\n| >>> x.fill(0)\n|\n| >>> x\n| array([[0, 0, 0],\n| [0, 0, 0]])\n|\n| >>> y\n| array([[1, 2, 3],\n| [4, 5, 6]])\n|\n| >>> y.flags['CCONTIGUOUS']\n| True\n|\n| cumprod(...)\n| a.cumprod(axis=None, dtype=None, out=None)\n|\n| Return the cumulative product of the elements along the given axis.\n|\n| Refer to `numpy.cumprod` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumprod : equivalent function\n|\n| cumsum(...)\n| a.cumsum(axis=None, dtype=None, out=None)\n|\n| Return the cumulative sum of the elements along the given axis.\n|\n| Refer to `numpy.cumsum` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumsum : equivalent function\n|\n| diagonal(...)\n| a.diagonal(offset=0, axis1=0, axis2=1)\n|\n| Return specified diagonals. In NumPy 1.9 the returned array is a\n| read-only view instead of a copy as in previous NumPy versions. In\n| a future version the read-only restriction will be removed.\n|\n| Refer to :func:`numpy.diagonal` for full documentation.\n|\n| See Also\n| --------\n| numpy.diagonal : equivalent function\n|\n| dot(...)\n| a.dot(b, out=None)\n|\n| Dot product of two arrays.\n|\n| Refer to `numpy.dot` for full documentation.\n|\n| See Also\n| --------\n| numpy.dot : equivalent function\n|\n| Examples\n| --------\n| >>> a = np.eye(2)\n| >>> b = np.ones((2, 2)) * 2\n| >>> a.dot(b)\n| array([[2., 2.],\n| [2., 2.]])\n|\n| This array method can be conveniently chained:\n|\n| >>> a.dot(b).dot(b)\n| array([[8., 8.],\n| [8., 8.]])\n|\n| dump(...)\n| a.dump(file)\n|\n| Dump a pickle of the array to the specified file.\n| The array can be read back with pickle.load or numpy.load.\n|\n| Parameters\n| ----------\n| file : str or Path\n| A string naming the dump file.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| dumps(...)\n| a.dumps()\n|\n| Returns the pickle of the array as a string.\n| pickle.loads or numpy.loads will convert the string back to an array.\n|\n| Parameters\n| ----------\n| None\n|\n| fill(...)\n| a.fill(value)\n|\n| Fill the array with a scalar value.\n|\n| Parameters\n| ----------\n| value : scalar\n| All elements of `a` will be assigned this value.\n|\n| Examples\n| --------\n| >>> a = np.array([1, 2])\n| >>> a.fill(0)\n| >>> a\n| array([0, 0])\n| >>> a = np.empty(2)\n| >>> a.fill(1)\n| >>> a\n| array([1., 1.])\n|\n| flatten(...)\n| a.flatten(order='C')\n|\n| Return a copy of the array collapsed into one dimension.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| 'C' means to flatten in row-major (C-style) order.\n| 'F' means to flatten in column-major (Fortran-\n| style) order. 'A' means to flatten in column-major\n| order if `a` is Fortran *contiguous* in memory,\n| row-major order otherwise. 'K' means to flatten\n| `a` in the order the elements occur in memory.\n| The default is 'C'.\n|\n| Returns\n| -------\n| y : ndarray\n| A copy of the input array, flattened to one dimension.\n|\n| See Also\n| --------\n| ravel : Return a flattened array.\n| flat : A 1-D flat iterator over the array.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,2], [3,4]])\n| >>> a.flatten()\n| array([1, 2, 3, 4])\n| >>> a.flatten('F')\n| array([1, 3, 2, 4])\n|\n| getfield(...)\n| a.getfield(dtype, offset=0)\n|\n| Returns a field of the given array as a certain type.\n|\n| A field is a view of the array data with a given data-type. The values in\n| the view are determined by the given type and the offset into the current\n| array in bytes. The offset needs to be such that the view dtype fits in the\n| array dtype; for example an array of dtype complex128 has 16-byte elements.\n| If taking a view with a 32-bit integer (4 bytes), the offset needs to be\n| between 0 and 12 bytes.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| The data type of the view. The dtype size of the view can not be larger\n| than that of the array itself.\n| offset : int\n| Number of bytes to skip before beginning the element view.\n|\n| Examples\n| --------\n| >>> x = np.diag([1.+1.j]*2)\n| >>> x[1, 1] = 2 + 4.j\n| >>> x\n| array([[1.+1.j, 0.+0.j],\n| [0.+0.j, 2.+4.j]])\n| >>> x.getfield(np.float64)\n| array([[1., 0.],\n| [0., 2.]])\n|\n| By choosing an offset of 8 bytes we can select the complex part of the\n| array for our view:\n|\n| >>> x.getfield(np.float64, offset=8)\n| array([[1., 0.],\n| [0., 4.]])\n|\n| item(...)\n| a.item(*args)\n|\n| Copy an element of an array to a standard Python scalar and return it.\n|\n| Parameters\n| ----------\n| \\*args : Arguments (variable number and type)\n|\n| * none: in this case, the method only works for arrays\n| with one element (`a.size == 1`), which element is\n| copied into a standard Python scalar object and returned.\n|\n| * inttype: this argument is interpreted as a flat index into\n| the array, specifying which element to copy and return.\n|\n| * tuple of inttypes: functions as does a single inttype argument,\n| except that the argument is interpreted as an nd-index into the\n| array.\n|\n| Returns\n| -------\n| z : Standard Python scalar object\n| A copy of the specified element of the array as a suitable\n| Python scalar\n|\n| Notes\n| -----\n| When the data type of `a` is longdouble or clongdouble, item() returns\n| a scalar array object because there is no available Python scalar that\n| would not lose information. Void arrays return a buffer object for item(),\n| unless fields are defined, in which case a tuple is returned.\n|\n| `item` is very similar to a[args], except, instead of an array scalar,\n| a standard Python scalar is returned. This can be useful for speeding up\n| access to elements of the array and doing arithmetic on elements of the\n| array using Python's optimized math.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.item(3)\n| 1\n| >>> x.item(7)\n| 0\n| >>> x.item((0, 1))\n| 2\n| >>> x.item((2, 2))\n| 1\n|\n| itemset(...)\n| a.itemset(*args)\n|\n| Insert scalar into an array (scalar is cast to array's dtype, if possible)\n|\n| There must be at least 1 argument, and define the last argument\n| as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster\n| than ``a[args] = item``. The item should be a scalar value and `args`\n| must select a single item in the array `a`.\n|\n| Parameters\n| ----------\n| \\*args : Arguments\n| If one argument: a scalar, only used in case `a` is of size 1.\n| If two arguments: the last argument is the value to be set\n| and must be a scalar, the first argument specifies a single array\n| element location. It is either an int or a tuple.\n|\n| Notes\n| -----\n| Compared to indexing syntax, `itemset` provides some speed increase\n| for placing a scalar into a particular location in an `ndarray`,\n| if you must do this. However, generally this is discouraged:\n| among other problems, it complicates the appearance of the code.\n| Also, when using `itemset` (and `item`) inside a loop, be sure\n| to assign the methods to a local variable to avoid the attribute\n| look-up at each loop iteration.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.itemset(4, 0)\n| >>> x.itemset((2, 2), 9)\n| >>> x\n| array([[2, 2, 6],\n| [1, 0, 6],\n| [1, 0, 9]])\n|\n| max(...)\n| a.max(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the maximum along a given axis.\n|\n| Refer to `numpy.amax` for full documentation.\n|\n| See Also\n| --------\n| numpy.amax : equivalent function\n|\n| mean(...)\n| a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)\n|\n| Returns the average of the array elements along given axis.\n|\n| Refer to `numpy.mean` for full documentation.\n|\n| See Also\n| --------\n| numpy.mean : equivalent function\n|\n| min(...)\n| a.min(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the minimum along a given axis.\n|\n| Refer to `numpy.amin` for full documentation.\n|\n| See Also\n| --------\n| numpy.amin : equivalent function\n|\n| newbyteorder(...)\n| arr.newbyteorder(neworder='S', /)\n|\n| Return the array with the same data viewed with a different byte order.\n|\n| Equivalent to::\n|\n| arr.view(arr.dtype.newbytorder(neworder))\n|\n| Changes are also made in all fields and sub-arrays of the array data\n| type.\n|\n|\n|\n| Parameters\n| ----------\n| neworder : string, optional\n| Byte order to force; a value from the byte order specifications\n| below. `neworder` codes can be any of:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order, equivalent to `sys.byteorder`\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newarr : array\n| New array object with the dtype reflecting given change to the\n| byte order.\n|\n| nonzero(...)\n| a.nonzero()\n|\n| Return the indices of the elements that are non-zero.\n|\n| Refer to `numpy.nonzero` for full documentation.\n|\n| See Also\n| --------\n| numpy.nonzero : equivalent function\n|\n| prod(...)\n| a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)\n|\n| Return the product of the array elements over the given axis\n|\n| Refer to `numpy.prod` for full documentation.\n|\n| See Also\n| --------\n| numpy.prod : equivalent function\n|\n| ptp(...)\n| a.ptp(axis=None, out=None, keepdims=False)\n|\n| Peak to peak (maximum - minimum) value along a given axis.\n|\n| Refer to `numpy.ptp` for full documentation.\n|\n| See Also\n| --------\n| numpy.ptp : equivalent function\n|\n| put(...)\n| a.put(indices, values, mode='raise')\n|\n| Set ``a.flat[n] = values[n]`` for all `n` in indices.\n|\n| Refer to `numpy.put` for full documentation.\n|\n| See Also\n| --------\n| numpy.put : equivalent function\n|\n| ravel(...)\n| a.ravel([order])\n|\n| Return a flattened array.\n|\n| Refer to `numpy.ravel` for full documentation.\n|\n| See Also\n| --------\n| numpy.ravel : equivalent function\n|\n| ndarray.flat : a flat iterator on the array.\n|\n| repeat(...)\n| a.repeat(repeats, axis=None)\n|\n| Repeat elements of an array.\n|\n| Refer to `numpy.repeat` for full documentation.\n|\n| See Also\n| --------\n| numpy.repeat : equivalent function\n|\n| reshape(...)\n| a.reshape(shape, order='C')\n|\n| Returns an array containing the same data with a new shape.\n|\n| Refer to `numpy.reshape` for full documentation.\n|\n| See Also\n| --------\n| numpy.reshape : equivalent function\n|\n| Notes\n| -----\n| Unlike the free function `numpy.reshape`, this method on `ndarray` allows\n| the elements of the shape parameter to be passed in as separate arguments.\n| For example, ``a.reshape(10, 11)`` is equivalent to\n| ``a.reshape((10, 11))``.\n|\n| resize(...)\n| a.resize(newshape, refcheck=True)\n|\n| Change shape and size of array in-place.\n|\n| Parameters\n| ----------\n| newshape : tuple of ints, or `n` ints\n| Shape of resized array.\n| refcheck : bool, optional\n| If False, reference count will not be checked. Default is True.\n|\n| Returns\n| -------\n| None\n|\n| Raises\n| ------\n| ValueError\n| If `a` does not own its own data or references or views to it exist,\n| and the data memory must be changed.\n| PyPy only: will always raise if the data memory must be changed, since\n| there is no reliable way to determine if references or views to it\n| exist.\n|\n| SystemError\n| If the `order` keyword argument is specified. This behaviour is a\n| bug in NumPy.\n|\n| See Also\n| --------\n| resize : Return a new array with the specified shape.\n|\n| Notes\n| -----\n| This reallocates space for the data area if necessary.\n|\n| Only contiguous arrays (data elements consecutive in memory) can be\n| resized.\n|\n| The purpose of the reference count check is to make sure you\n| do not use this array as a buffer for another Python object and then\n| reallocate the memory. However, reference counts can increase in\n| other ways so if you are sure that you have not shared the memory\n| for this array with another Python object, then you may safely set\n| `refcheck` to False.\n|\n| Examples\n| --------\n| Shrinking an array: array is flattened (in the order that the data are\n| stored in memory), resized, and reshaped:\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='C')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [1]])\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='F')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [2]])\n|\n| Enlarging an array: as above, but missing entries are filled with zeros:\n|\n| >>> b = np.array([[0, 1], [2, 3]])\n| >>> b.resize(2, 3) # newshape parameter doesn't have to be a tuple\n| >>> b\n| array([[0, 1, 2],\n| [3, 0, 0]])\n|\n| Referencing an array prevents resizing...\n|\n| >>> c = a\n| >>> a.resize((1, 1))\n| Traceback (most recent call last):\n| ...\n| ValueError: cannot resize an array that references or is referenced ...\n|\n| Unless `refcheck` is False:\n|\n| >>> a.resize((1, 1), refcheck=False)\n| >>> a\n| array([[0]])\n| >>> c\n| array([[0]])\n|\n| round(...)\n| a.round(decimals=0, out=None)\n|\n| Return `a` with each element rounded to the given number of decimals.\n|\n| Refer to `numpy.around` for full documentation.\n|\n| See Also\n| --------\n| numpy.around : equivalent function\n|\n| searchsorted(...)\n| a.searchsorted(v, side='left', sorter=None)\n|\n| Find indices where elements of v should be inserted in a to maintain order.\n|\n| For full documentation, see `numpy.searchsorted`\n|\n| See Also\n| --------\n| numpy.searchsorted : equivalent function\n|\n| setfield(...)\n| a.setfield(val, dtype, offset=0)\n|\n| Put a value into a specified place in a field defined by a data-type.\n|\n| Place `val` into `a`'s field defined by `dtype` and beginning `offset`\n| bytes into the field.\n|\n| Parameters\n| ----------\n| val : object\n| Value to be placed in field.\n| dtype : dtype object\n| Data-type of the field in which to place `val`.\n| offset : int, optional\n| The number of bytes into the field at which to place `val`.\n|\n| Returns\n| -------\n| None\n|\n| See Also\n| --------\n| getfield\n|\n| Examples\n| --------\n| >>> x = np.eye(3)\n| >>> x.getfield(np.float64)\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n| >>> x.setfield(3, np.int32)\n| >>> x.getfield(np.int32)\n| array([[3, 3, 3],\n| [3, 3, 3],\n| [3, 3, 3]], dtype=int32)\n| >>> x\n| array([[1.0e+000, 1.5e-323, 1.5e-323],\n| [1.5e-323, 1.0e+000, 1.5e-323],\n| [1.5e-323, 1.5e-323, 1.0e+000]])\n| >>> x.setfield(np.eye(3), np.int32)\n| >>> x\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n|\n| setflags(...)\n| a.setflags(write=None, align=None, uic=None)\n|\n| Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),\n| respectively.\n|\n| These Boolean-valued flags affect how numpy interprets the memory\n| area used by `a` (see Notes below). The ALIGNED flag can only\n| be set to True if the data is actually aligned according to the type.\n| The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set\n| to True. The flag WRITEABLE can only be set to True if the array owns its\n| own memory, or the ultimate owner of the memory exposes a writeable buffer\n| interface, or is a string. (The exception for string is made so that\n| unpickling can be done without copying memory.)\n|\n| Parameters\n| ----------\n| write : bool, optional\n| Describes whether or not `a` can be written to.\n| align : bool, optional\n| Describes whether or not `a` is aligned properly for its type.\n| uic : bool, optional\n| Describes whether or not `a` is a copy of another \"base\" array.\n|\n| Notes\n| -----\n| Array flags provide information about how the memory area used\n| for the array is to be interpreted. There are 7 Boolean flags\n| in use, only four of which can be changed by the user:\n| WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.\n|\n| WRITEABLE (W) the data area can be written to;\n|\n| ALIGNED (A) the data and strides are aligned appropriately for the hardware\n| (as determined by the compiler);\n|\n| UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;\n|\n| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced\n| by .base). When the C-API function PyArrayResolveWritebackIfCopy is\n| called, the base array will be updated with the contents of this array.\n|\n| All flags can be accessed using the single (upper case) letter as well\n| as the full name.\n|\n| Examples\n| --------\n| >>> y = np.array([[3, 1, 7],\n| ... [2, 0, 0],\n| ... [8, 5, 9]])\n| >>> y\n| array([[3, 1, 7],\n| [2, 0, 0],\n| [8, 5, 9]])\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : True\n| ALIGNED : True\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(write=0, align=0)\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : False\n| ALIGNED : False\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(uic=1)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: cannot set WRITEBACKIFCOPY flag to True\n|\n| sort(...)\n| a.sort(axis=-1, kind=None, order=None)\n|\n| Sort an array in-place. Refer to `numpy.sort` for full documentation.\n|\n| Parameters\n| ----------\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'\n| and 'mergesort' use timsort under the covers and, in general, the\n| actual implementation will vary with datatype. The 'mergesort' option\n| is retained for backwards compatibility.\n|\n| .. versionchanged:: 1.15.0\n| The 'stable' option was added.\n|\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.sort : Return a sorted copy of an array.\n| numpy.argsort : Indirect sort.\n| numpy.lexsort : Indirect stable sort on multiple keys.\n| numpy.searchsorted : Find elements in sorted array.\n| numpy.partition: Partial sort.\n|\n| Notes\n| -----\n| See `numpy.sort` for notes on the different sorting algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,4], [3,1]])\n| >>> a.sort(axis=1)\n| >>> a\n| array([[1, 4],\n| [1, 3]])\n| >>> a.sort(axis=0)\n| >>> a\n| array([[1, 3],\n| [1, 4]])\n|\n| Use the `order` keyword to specify a field to use when sorting a\n| structured array:\n|\n| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])\n| >>> a.sort(order='y')\n| >>> a\n| array([(b'c', 1), (b'a', 2)],\n| dtype=[('x', 'S1'), ('y', '>> x = np.array([[0, 1], [2, 3]], dtype='>> x.tobytes()\n| b'\\x00\\x00\\x01\\x00\\x02\\x00\\x03\\x00'\n| >>> x.tobytes('C') == x.tobytes()\n| True\n| >>> x.tobytes('F')\n| b'\\x00\\x00\\x02\\x00\\x01\\x00\\x03\\x00'\n|\n| tofile(...)\n| a.tofile(fid, sep=\"\", format=\"%s\")\n|\n| Write array to a file as text or binary (default).\n|\n| Data is always written in 'C' order, independent of the order of `a`.\n| The data produced by this method can be recovered using the function\n| fromfile().\n|\n| Parameters\n| ----------\n| fid : file or str or Path\n| An open file object, or a string containing a filename.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| sep : str\n| Separator between array items for text output.\n| If \"\" (empty), a binary file is written, equivalent to\n| ``file.write(a.tobytes())``.\n| format : str\n| Format string for text file output.\n| Each entry in the array is formatted to text by first converting\n| it to the closest Python type, and then using \"format\" % item.\n|\n| Notes\n| -----\n| This is a convenience function for quick storage of array data.\n| Information on endianness and precision is lost, so this method is not a\n| good choice for files intended to archive data or transport data between\n| machines with different endianness. Some of these problems can be overcome\n| by outputting the data as text files, at the expense of speed and file\n| size.\n|\n| When fid is a file object, array contents are directly written to the\n| file, bypassing the file object's ``write`` method. As a result, tofile\n| cannot be used with files objects supporting compression (e.g., GzipFile)\n| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).\n|\n| tolist(...)\n| a.tolist()\n|\n| Return the array as an ``a.ndim``-levels deep nested list of Python scalars.\n|\n| Return a copy of the array data as a (nested) Python list.\n| Data items are converted to the nearest compatible builtin Python type, via\n| the `~numpy.ndarray.item` function.\n|\n| If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will\n| not be a list at all, but a simple Python scalar.\n|\n| Parameters\n| ----------\n| none\n|\n| Returns\n| -------\n| y : object, or list of object, or list of list of object, or ...\n| The possibly nested list of array elements.\n|\n| Notes\n| -----\n| The array may be recreated via ``a = np.array(a.tolist())``, although this\n| may sometimes lose precision.\n|\n| Examples\n| --------\n| For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,\n| except that ``tolist`` changes numpy scalars to Python scalars:\n|\n| >>> a = np.uint32([1, 2])\n| >>> alist = list(a)\n| >>> alist\n| [1, 2]\n| >>> type(alist[0])\n| \n| >>> atolist = a.tolist()\n| >>> atolist\n| [1, 2]\n| >>> type(atolist[0])\n| \n|\n| Additionally, for a 2D array, ``tolist`` applies recursively:\n|\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> list(a)\n| [array([1, 2]), array([3, 4])]\n| >>> a.tolist()\n| [[1, 2], [3, 4]]\n|\n| The base case for this recursion is a 0D array:\n|\n| >>> a = np.array(1)\n| >>> list(a)\n| Traceback (most recent call last):\n| ...\n| TypeError: iteration over a 0-d array\n| >>> a.tolist()\n| 1\n|\n| tostring(...)\n| a.tostring(order='C')\n|\n| A compatibility alias for `tobytes`, with exactly the same behavior.\n|\n| Despite its name, it returns `bytes` not `str`\\ s.\n|\n| .. deprecated:: 1.19.0\n|\n| trace(...)\n| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n|\n| Return the sum along diagonals of the array.\n|\n| Refer to `numpy.trace` for full documentation.\n|\n| See Also\n| --------\n| numpy.trace : equivalent function\n|\n| transpose(...)\n| a.transpose(*axes)\n|\n| Returns a view of the array with axes transposed.\n|\n| For a 1-D array this has no effect, as a transposed vector is simply the\n| same vector. To convert a 1-D array into a 2D column vector, an additional\n| dimension must be added. `np.atleast2d(a).T` achieves this, as does\n| `a[:, np.newaxis]`.\n| For a 2-D array, this is a standard matrix transpose.\n| For an n-D array, if axes are given, their order indicates how the\n| axes are permuted (see Examples). If axes are not provided and\n| ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then\n| ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.\n|\n| Parameters\n| ----------\n| axes : None, tuple of ints, or `n` ints\n|\n| * None or no argument: reverses the order of the axes.\n|\n| * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s\n| `i`-th axis becomes `a.transpose()`'s `j`-th axis.\n|\n| * `n` ints: same as an n-tuple of the same ints (this form is\n| intended simply as a \"convenience\" alternative to the tuple form)\n|\n| Returns\n| -------\n| out : ndarray\n| View of `a`, with axes suitably permuted.\n|\n| See Also\n| --------\n| transpose : Equivalent function\n| ndarray.T : Array property returning the array transposed.\n| ndarray.reshape : Give a new shape to an array without changing its data.\n|\n| Examples\n| --------\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> a\n| array([[1, 2],\n| [3, 4]])\n| >>> a.transpose()\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose((1, 0))\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose(1, 0)\n| array([[1, 3],\n| [2, 4]])\n|\n| var(...)\n| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)\n|\n| Returns the variance of the array elements, along given axis.\n|\n| Refer to `numpy.var` for full documentation.\n|\n| See Also\n| --------\n| numpy.var : equivalent function\n|\n| view(...)\n| a.view([dtype][, type])\n|\n| New view of array with the same data.\n|\n| .. note::\n| Passing None for ``dtype`` is different from omitting the parameter,\n| since the former invokes ``dtype(None)`` which is an alias for\n| ``dtype('float')``.\n|\n| Parameters\n| ----------\n| dtype : data-type or ndarray sub-class, optional\n| Data-type descriptor of the returned view, e.g., float32 or int16.\n| Omitting it results in the view having the same data-type as `a`.\n| This argument can also be specified as an ndarray sub-class, which\n| then specifies the type of the returned object (this is equivalent to\n| setting the ``type`` parameter).\n| type : Python type, optional\n| Type of the returned view, e.g., ndarray or matrix. Again, omission\n| of the parameter results in type preservation.\n|\n| Notes\n| -----\n| ``a.view()`` is used two different ways:\n|\n| ``a.view(somedtype)`` or ``a.view(dtype=somedtype)`` constructs a view\n| of the array's memory with a different data-type. This can cause a\n| reinterpretation of the bytes of memory.\n|\n| ``a.view(ndarraysubclass)`` or ``a.view(type=ndarraysubclass)`` just\n| returns an instance of `ndarraysubclass` that looks at the same array\n| (same shape, dtype, etc.) This does not cause a reinterpretation of the\n| memory.\n|\n| For ``a.view(somedtype)``, if ``somedtype`` has a different number of\n| bytes per entry than the previous dtype (for example, converting a\n| regular array to a structured array), then the behavior of the view\n| cannot be predicted just from the superficial appearance of ``a`` (shown\n| by ``print(a)``). It also depends on exactly how ``a`` is stored in\n| memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus\n| defined as a slice or transpose, etc., the view may give different\n| results.\n|\n|\n| Examples\n| --------\n| >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])\n|\n| Viewing array data using a different type and dtype:\n|\n| >>> y = x.view(dtype=np.int16, type=np.matrix)\n| >>> y\n| matrix([[513]], dtype=int16)\n| >>> print(type(y))\n| \n|\n| Creating a view on a structured array so it can be used in calculations\n|\n| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])\n| >>> xv = x.view(dtype=np.int8).reshape(-1,2)\n| >>> xv\n| array([[1, 2],\n| [3, 4]], dtype=int8)\n| >>> xv.mean(0)\n| array([2., 3.])\n|\n| Making changes to the view changes the underlying array\n|\n| >>> xv[0,1] = 20\n| >>> x\n| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])\n|\n| Using a view to convert an array to a recarray:\n|\n| >>> z = x.view(np.recarray)\n| >>> z.a\n| array([1, 3], dtype=int8)\n|\n| Views share data:\n|\n| >>> x[0] = (9, 10)\n| >>> z[0]\n| (9, 10)\n|\n| Views that change the dtype size (bytes per entry) should normally be\n| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:\n|\n| >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)\n| >>> y = x[:, 0:2]\n| >>> y\n| array([[1, 2],\n| [4, 5]], dtype=int16)\n| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])\n| Traceback (most recent call last):\n| ...\n| ValueError: To change to a dtype of a different size, the array must be C-contiguous\n| >>> z = y.copy()\n| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])\n| array([[(1, 2)],\n| [(4, 5)]], dtype=[('width', '>> x = np.array([[1.,2.],[3.,4.]])\n| >>> x\n| array([[ 1., 2.],\n| [ 3., 4.]])\n| >>> x.T\n| array([[ 1., 3.],\n| [ 2., 4.]])\n| >>> x = np.array([1.,2.,3.,4.])\n| >>> x\n| array([ 1., 2., 3., 4.])\n| >>> x.T\n| array([ 1., 2., 3., 4.])\n|\n| See Also\n| --------\n| transpose\n|\n| arrayinterface\n| Array protocol: Python side.\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: C-struct side.\n|\n| base\n| Base object if memory is from some other object.\n|\n| Examples\n| --------\n| The base of an array that owns its memory is None:\n|\n| >>> x = np.array([1,2,3,4])\n| >>> x.base is None\n| True\n|\n| Slicing creates a view, whose memory is shared with x:\n|\n| >>> y = x[2:]\n| >>> y.base is x\n| True\n|\n| ctypes\n| An object to simplify the interaction of the array with the ctypes\n| module.\n|\n| This attribute creates an object that makes it easier to use arrays\n| when calling shared libraries with the ctypes module. The returned\n| object has, among others, data, shape, and strides attributes (see\n| Notes below) which themselves return ctypes objects that can be used\n| as arguments to a shared library.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| c : Python object\n| Possessing attributes data, shape, strides, etc.\n|\n| See Also\n| --------\n| numpy.ctypeslib\n|\n| Notes\n| -----\n| Below are the public attributes of this object which were documented\n| in \"Guide to NumPy\" (we have omitted undocumented public attributes,\n| as well as documented private attributes):\n|\n| .. autoattribute:: numpy.core.internal.ctypes.data\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.shape\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.strides\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.dataas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.shapeas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.stridesas\n| :noindex:\n|\n| If the ctypes module is not available, then the ctypes attribute\n| of array objects still returns something useful, but ctypes objects\n| are not returned and errors may be raised instead. In particular,\n| the object will still have the ``asparameter`` attribute which will\n| return an integer equal to the data attribute.\n|\n| Examples\n| --------\n| >>> import ctypes\n| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)\n| >>> x\n| array([[0, 1],\n| [2, 3]], dtype=int32)\n| >>> x.ctypes.data\n| 31962608 # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32))\n| # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32)).contents\n| cuint(0)\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint64)).contents\n| culong(4294967296)\n| >>> x.ctypes.shape\n| # may vary\n| >>> x.ctypes.strides\n| # may vary\n|\n| data\n| Python buffer object pointing to the start of the array's data.\n|\n| dtype\n| Data-type of the array's elements.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| d : numpy dtype object\n|\n| See Also\n| --------\n| numpy.dtype\n|\n| Examples\n| --------\n| >>> x\n| array([[0, 1],\n| [2, 3]])\n| >>> x.dtype\n| dtype('int32')\n| >>> type(x.dtype)\n| \n|\n| flags\n| Information about the memory layout of the array.\n|\n| Attributes\n| ----------\n| CCONTIGUOUS (C)\n| The data is in a single, C-style contiguous segment.\n| FCONTIGUOUS (F)\n| The data is in a single, Fortran-style contiguous segment.\n| OWNDATA (O)\n| The array owns the memory it uses or borrows it from another object.\n| WRITEABLE (W)\n| The data area can be written to. Setting this to False locks\n| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE\n| from its base array at creation time, but a view of a writeable\n| array may be subsequently locked while the base array remains writeable.\n| (The opposite is not true, in that a view of a locked array may not\n| be made writeable. However, currently, locking a base object does not\n| lock any views that already reference it, so under that circumstance it\n| is possible to alter the contents of a locked array via a previously\n| created writeable view onto it.) Attempting to change a non-writeable\n| array raises a RuntimeError exception.\n| ALIGNED (A)\n| The data and all elements are aligned appropriately for the hardware.\n| WRITEBACKIFCOPY (X)\n| This array is a copy of some other array. The C-API function\n| PyArrayResolveWritebackIfCopy must be called before deallocating\n| to the base array will be updated with the contents of this array.\n| UPDATEIFCOPY (U)\n| (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.\n| When this array is\n| deallocated, the base array will be updated with the contents of\n| this array.\n| FNC\n| FCONTIGUOUS and not CCONTIGUOUS.\n| FORC\n| FCONTIGUOUS or CCONTIGUOUS (one-segment test).\n| BEHAVED (B)\n| ALIGNED and WRITEABLE.\n| CARRAY (CA)\n| BEHAVED and CCONTIGUOUS.\n| FARRAY (FA)\n| BEHAVED and FCONTIGUOUS and not CCONTIGUOUS.\n|\n| Notes\n| -----\n| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),\n| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag\n| names are only supported in dictionary access.\n|\n| Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be\n| changed by the user, via direct assignment to the attribute or dictionary\n| entry, or by calling `ndarray.setflags`.\n|\n| The array flags cannot be set arbitrarily:\n|\n| - UPDATEIFCOPY can only be set ``False``.\n| - WRITEBACKIFCOPY can only be set ``False``.\n| - ALIGNED can only be set ``True`` if the data is truly aligned.\n| - WRITEABLE can only be set ``True`` if the array owns its own memory\n| or the ultimate owner of the memory exposes a writeable buffer\n| interface or is a string.\n|\n| Arrays can be both C-style and Fortran-style contiguous simultaneously.\n| This is clear for 1-dimensional arrays, but can also be true for higher\n| dimensional arrays.\n|\n| Even for contiguous arrays a stride for a given dimension\n| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``\n| or the array has no elements.\n| It does *not* generally hold that ``self.strides[-1] == self.itemsize``\n| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for\n| Fortran-style contiguous arrays is true.\n|\n| flat\n| A 1-D iterator over the array.\n|\n| This is a `numpy.flatiter` instance, which acts similarly to, but is not\n| a subclass of, Python's built-in iterator object.\n|\n| See Also\n| --------\n| flatten : Return a copy of the array collapsed into one dimension.\n|\n| flatiter\n|\n| Examples\n| --------\n| >>> x = np.arange(1, 7).reshape(2, 3)\n| >>> x\n| array([[1, 2, 3],\n| [4, 5, 6]])\n| >>> x.flat[3]\n| 4\n| >>> x.T\n| array([[1, 4],\n| [2, 5],\n| [3, 6]])\n| >>> x.T.flat[3]\n| 5\n| >>> type(x.flat)\n| \n|\n| An assignment example:\n|\n| >>> x.flat = 3; x\n| array([[3, 3, 3],\n| [3, 3, 3]])\n| >>> x.flat[[1,4]] = 1; x\n| array([[3, 1, 3],\n| [3, 1, 3]])\n|\n| imag\n| The imaginary part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.imag\n| array([ 0. , 0.70710678])\n| >>> x.imag.dtype\n| dtype('float64')\n|\n| itemsize\n| Length of one array element in bytes.\n|\n| Examples\n| --------\n| >>> x = np.array([1,2,3], dtype=np.float64)\n| >>> x.itemsize\n| 8\n| >>> x = np.array([1,2,3], dtype=np.complex128)\n| >>> x.itemsize\n| 16\n|\n| nbytes\n| Total bytes consumed by the elements of the array.\n|\n| Notes\n| -----\n| Does not include memory consumed by non-element attributes of the\n| array object.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3,5,2), dtype=np.complex128)\n| >>> x.nbytes\n| 480\n| >>> np.prod(x.shape) * x.itemsize\n| 480\n|\n| ndim\n| Number of array dimensions.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> x.ndim\n| 1\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.ndim\n| 3\n|\n| real\n| The real part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.real\n| array([ 1. , 0.70710678])\n| >>> x.real.dtype\n| dtype('float64')\n|\n| See Also\n| --------\n| numpy.real : equivalent function\n|\n| shape\n| Tuple of array dimensions.\n|\n| The shape property is usually used to get the current shape of an array,\n| but may also be used to reshape the array in-place by assigning a tuple of\n| array dimensions to it. As with `numpy.reshape`, one of the new shape\n| dimensions can be -1, in which case its value is inferred from the size of\n| the array and the remaining dimensions. Reshaping an array in-place will\n| fail if a copy is required.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3, 4])\n| >>> x.shape\n| (4,)\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.shape\n| (2, 3, 4)\n| >>> y.shape = (3, 8)\n| >>> y\n| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.]])\n| >>> y.shape = (3, 6)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: total size of new array must be unchanged\n| >>> np.zeros((4,2))[::2].shape = (-1,)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| AttributeError: Incompatible shape for in-place modification. Use\n| `.reshape()` to make a copy with the desired shape.\n|\n| See Also\n| --------\n| numpy.reshape : similar function\n| ndarray.reshape : similar method\n|\n| size\n| Number of elements in the array.\n|\n| Equal to ``np.prod(a.shape)``, i.e., the product of the array's\n| dimensions.\n|\n| Notes\n| -----\n| `a.size` returns a standard arbitrary precision Python integer. This\n| may not be the case with other methods of obtaining the same value\n| (like the suggested ``np.prod(a.shape)``, which returns an instance\n| of ``np.int``), and may be relevant if the value is used further in\n| calculations that may overflow a fixed size integer type.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)\n| >>> x.size\n| 30\n| >>> np.prod(x.shape)\n| 30\n|\n| strides\n| Tuple of bytes to step in each dimension when traversing an array.\n|\n| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`\n| is::\n|\n| offset = sum(np.array(i) * a.strides)\n|\n| A more detailed explanation of strides can be found in the\n| \"ndarray.rst\" file in the NumPy reference guide.\n|\n| Notes\n| -----\n| Imagine an array of 32-bit integers (each 4 bytes)::\n|\n| x = np.array([[0, 1, 2, 3, 4],\n| [5, 6, 7, 8, 9]], dtype=np.int32)\n|\n| This array is stored in memory as 40 bytes, one after the other\n| (known as a contiguous block of memory). The strides of an array tell\n| us how many bytes we have to skip in memory to move to the next position\n| along a certain axis. For example, we have to skip 4 bytes (1 value) to\n| move to the next column, but 20 bytes (5 values) to get to the same\n| position in the next row. As such, the strides for the array `x` will be\n| ``(20, 4)``.\n|\n| See Also\n| --------\n| numpy.lib.stridetricks.asstrided\n|\n| Examples\n| --------\n| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))\n| >>> y\n| array([[[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]],\n| [[12, 13, 14, 15],\n| [16, 17, 18, 19],\n| [20, 21, 22, 23]]])\n| >>> y.strides\n| (48, 16, 4)\n| >>> y[1,1,1]\n| 17\n| >>> offset=sum(y.strides * np.array((1,1,1)))\n| >>> offset/y.itemsize\n| 17\n|\n| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)\n| >>> x.strides\n| (32, 4, 224, 1344)\n| >>> i = np.array([3,5,2,2])\n| >>> offset = sum(i * x.strides)\n| >>> x[3,5,2,2]\n| 813\n| >>> offset / x.itemsize\n| 813\n\nclongdouble = class complex256(complexfloating)\n| Complex number type composed of two extended-precision floating-point\n| numbers.\n|\n| :Character code: ``'G'``\n| :Canonical name: `numpy.clongdouble`\n| :Alias: `numpy.clongfloat`\n| :Alias: `numpy.longcomplex`\n| :Alias on this platform (Linux x8664): `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers.\n|\n| Method resolution order:\n| complex256\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nclongfloat = class complex256(complexfloating)\n| Complex number type composed of two extended-precision floating-point\n| numbers.\n|\n| :Character code: ``'G'``\n| :Canonical name: `numpy.clongdouble`\n| :Alias: `numpy.clongfloat`\n| :Alias: `numpy.longcomplex`\n| :Alias on this platform (Linux x8664): `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers.\n|\n| Method resolution order:\n| complex256\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class complex128", "content": "| complex128(real=0, imag=0)\n|\n| Complex number type composed of two double-precision floating-point\n| numbers, compatible with Python `complex`.\n|\n| :Character code: ``'D'``\n| :Canonical name: `numpy.cdouble`\n| :Alias: `numpy.cfloat`\n| :Alias: `numpy.complex`\n| :Alias on this platform (Linux x8664): `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers.\n|\n| Method resolution order:\n| complex128\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.complex\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.complex:\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getnewargs(self, /)\n" }, { "name": "class complex256", "content": "| Complex number type composed of two extended-precision floating-point\n| numbers.\n|\n| :Character code: ``'G'``\n| :Canonical name: `numpy.clongdouble`\n| :Alias: `numpy.clongfloat`\n| :Alias: `numpy.longcomplex`\n| :Alias on this platform (Linux x8664): `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers.\n|\n| Method resolution order:\n| complex256\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class complex64", "content": "| Complex number type composed of two single-precision floating-point\n| numbers.\n|\n| :Character code: ``'F'``\n| :Canonical name: `numpy.csingle`\n| :Alias: `numpy.singlecomplex`\n| :Alias on this platform (Linux x8664): `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers.\n|\n| Method resolution order:\n| complex64\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\ncomplex = class complex128(complexfloating, builtins.complex)\n| complex(real=0, imag=0)\n|\n| Complex number type composed of two double-precision floating-point\n| numbers, compatible with Python `complex`.\n|\n| :Character code: ``'D'``\n| :Canonical name: `numpy.cdouble`\n| :Alias: `numpy.cfloat`\n| :Alias: `numpy.complex`\n| :Alias on this platform (Linux x8664): `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers.\n|\n| Method resolution order:\n| complex128\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.complex\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.complex:\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getnewargs(self, /)\n" }, { "name": "class complexfloating", "content": "| Abstract base class of all complex number scalar types that are made up of\n| floating-point numbers.\n|\n| Method resolution order:\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n\ncsingle = class complex64(complexfloating)\n| Complex number type composed of two single-precision floating-point\n| numbers.\n|\n| :Character code: ``'F'``\n| :Canonical name: `numpy.csingle`\n| :Alias: `numpy.singlecomplex`\n| :Alias on this platform (Linux x8664): `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers.\n|\n| Method resolution order:\n| complex64\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class datetime64", "content": "| If created from a 64-bit integer, it represents an offset from\n| ``1970-01-01T00:00:00``.\n| If created from string, the string can be in ISO 8601 date\n| or datetime format.\n|\n| >>> np.datetime64(10, 'Y')\n| numpy.datetime64('1980')\n| >>> np.datetime64('1980', 'Y')\n| numpy.datetime64('1980')\n| >>> np.datetime64(10, 'D')\n| numpy.datetime64('1970-01-11')\n|\n| See :ref:`arrays.datetime` for more information.\n|\n| :Character code: ``'M'``\n|\n| Method resolution order:\n| datetime64\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\ndouble = class float64(floating, builtins.float)\n| double(x=0, /)\n|\n| Double-precision floating-point number type, compatible with Python `float`\n| and C ``double``.\n|\n| :Character code: ``'d'``\n| :Canonical name: `numpy.double`\n| :Alias: `numpy.float`\n| :Alias on this platform (Linux x8664): `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.\n|\n| Method resolution order:\n| float64\n| floating\n| inexact\n| number\n| generic\n| builtins.float\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.double(10.0).asintegerratio()\n| (10, 1)\n| >>> np.double(0.0).asintegerratio()\n| (0, 1)\n| >>> np.double(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.float:\n|\n| ceil(self, /)\n| Return the ceiling as an Integral.\n|\n| floor(self, /)\n| Return the floor as an Integral.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getnewargs(self, /)\n|\n| trunc(self, /)\n| Return the Integral closest to x between 0 and x.\n|\n| hex(self, /)\n| Return a hexadecimal representation of a floating-point number.\n|\n| >>> (-0.1).hex()\n| '-0x1.999999999999ap-4'\n| >>> 3.14159.hex()\n| '0x1.921f9f01b866ep+1'\n|\n| isinteger(self, /)\n| Return True if the float is an integer.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.float:\n|\n| getformat(typestr, /) from builtins.type\n| You probably don't want to use this function.\n|\n| typestr\n| Must be 'double' or 'float'.\n|\n| It exists mainly to be used in Python's test suite.\n|\n| This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,\n| little-endian' best describes the format of floating point numbers used by the\n| C type named by typestr.\n|\n| setformat(typestr, fmt, /) from builtins.type\n| You probably don't want to use this function.\n|\n| typestr\n| Must be 'double' or 'float'.\n| fmt\n| Must be one of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian',\n| and in addition can only be one of the latter two if it appears to\n| match the underlying C reality.\n|\n| It exists mainly to be used in Python's test suite.\n|\n| Override the automatic determination of C-level floating point type.\n| This affects how floats are converted to and from binary strings.\n|\n| fromhex(string, /) from builtins.type\n| Create a floating-point number from a hexadecimal string.\n|\n| >>> float.fromhex('0x1.ffffp10')\n| 2047.984375\n| >>> float.fromhex('-0x1p-1074')\n| -5e-324\n" }, { "name": "class dtype", "content": "| dtype(dtype, align=False, copy=False)\n|\n| Create a data type object.\n|\n| A numpy array is homogeneous, and contains elements described by a\n| dtype object. A dtype object can be constructed from different\n| combinations of fundamental numeric types.\n|\n| Parameters\n| ----------\n| dtype\n| Object to be converted to a data type object.\n| align : bool, optional\n| Add padding to the fields to match what a C compiler would output\n| for a similar C-struct. Can be ``True`` only if `obj` is a dictionary\n| or a comma-separated string. If a struct dtype is being created,\n| this also sets a sticky alignment flag ``isalignedstruct``.\n| copy : bool, optional\n| Make a new copy of the data-type object. If ``False``, the result\n| may just be a reference to a built-in data-type object.\n|\n| See also\n| --------\n| resulttype\n|\n| Examples\n| --------\n| Using array-scalar type:\n|\n| >>> np.dtype(np.int16)\n| dtype('int16')\n|\n| Structured type, one field name 'f1', containing int16:\n|\n| >>> np.dtype([('f1', np.int16)])\n| dtype([('f1', '>> np.dtype([('f1', [('f1', np.int16)])])\n| dtype([('f1', [('f1', '>> np.dtype([('f1', np.uint64), ('f2', np.int32)])\n| dtype([('f1', '>> np.dtype([('a','f8'),('b','S10')])\n| dtype([('a', '>> np.dtype(\"i4, (2,3)f8\")\n| dtype([('f0', '>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)])\n| dtype([('hello', '>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))\n| dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')]))\n|\n| Using dictionaries. Two fields named 'gender' and 'age':\n|\n| >>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})\n| dtype([('gender', 'S1'), ('age', 'u1')])\n|\n| Offsets in bytes, here 0 and 25:\n|\n| >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})\n| dtype([('surname', 'S25'), ('age', 'u1')])\n|\n| Methods defined here:\n|\n| bool(self, /)\n| True if self else False\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Returns\n| -------\n| newdtype : dtype\n| New dtype object with the given change to the byte order.\n|\n| Notes\n| -----\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| Examples\n| --------\n| >>> import sys\n| >>> sysisle = sys.byteorder == 'little'\n| >>> nativecode = sysisle and '<' or '>'\n| >>> swappedcode = sysisle and '>' or '<'\n| >>> nativedt = np.dtype(nativecode+'i2')\n| >>> swappeddt = np.dtype(swappedcode+'i2')\n| >>> nativedt.newbyteorder('S') == swappeddt\n| True\n| >>> nativedt.newbyteorder() == swappeddt\n| True\n| >>> nativedt == swappeddt.newbyteorder('S')\n| True\n| >>> nativedt == swappeddt.newbyteorder('=')\n| True\n| >>> nativedt == swappeddt.newbyteorder('N')\n| True\n| >>> nativedt == nativedt.newbyteorder('|')\n| True\n| >>> np.dtype('>> np.dtype('>> np.dtype('>i2') == nativedt.newbyteorder('>')\n| True\n| >>> np.dtype('>i2') == nativedt.newbyteorder('B')\n| True\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from DTypeMeta\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| alignment\n| The required alignment (bytes) of this data-type according to the compiler.\n|\n| More information is available in the C-API section of the manual.\n|\n| Examples\n| --------\n|\n| >>> x = np.dtype('i4')\n| >>> x.alignment\n| 4\n|\n| >>> x = np.dtype(float)\n| >>> x.alignment\n| 8\n|\n| base\n| Returns dtype for the base element of the subarrays,\n| regardless of their dimension or shape.\n|\n| See Also\n| --------\n| dtype.subdtype\n|\n| Examples\n| --------\n| >>> x = numpy.dtype('8f')\n| >>> x.base\n| dtype('float32')\n|\n| >>> x = numpy.dtype('i2')\n| >>> x.base\n| dtype('int16')\n|\n| byteorder\n| A character indicating the byte-order of this data-type object.\n|\n| One of:\n|\n| === ==============\n| '=' native\n| '<' little-endian\n| '>' big-endian\n| '|' not applicable\n| === ==============\n|\n| All built-in data-type objects have byteorder either '=' or '|'.\n|\n| Examples\n| --------\n|\n| >>> dt = np.dtype('i2')\n| >>> dt.byteorder\n| '='\n| >>> # endian is not relevant for 8 bit numbers\n| >>> np.dtype('i1').byteorder\n| '|'\n| >>> # or ASCII strings\n| >>> np.dtype('S2').byteorder\n| '|'\n| >>> # Even if specific code is given, and it is native\n| >>> # '=' is the byteorder\n| >>> import sys\n| >>> sysisle = sys.byteorder == 'little'\n| >>> nativecode = sysisle and '<' or '>'\n| >>> swappedcode = sysisle and '>' or '<'\n| >>> dt = np.dtype(nativecode + 'i2')\n| >>> dt.byteorder\n| '='\n| >>> # Swapped code shows up as itself\n| >>> dt = np.dtype(swappedcode + 'i2')\n| >>> dt.byteorder == swappedcode\n| True\n|\n| char\n| A unique character code for each of the 21 different built-in types.\n|\n| Examples\n| --------\n|\n| >>> x = np.dtype(float)\n| >>> x.char\n| 'd'\n|\n| descr\n| `arrayinterface` description of the data-type.\n|\n| The format is that required by the 'descr' key in the\n| `arrayinterface` attribute.\n|\n| Warning: This attribute exists specifically for `arrayinterface`,\n| and passing it directly to `np.dtype` will not accurately reconstruct\n| some dtypes (e.g., scalar and subarray dtypes).\n|\n| Examples\n| --------\n|\n| >>> x = np.dtype(float)\n| >>> x.descr\n| [('', '>> dt = np.dtype([('name', np.str, 16), ('grades', np.float64, (2,))])\n| >>> dt.descr\n| [('name', '>> dt = np.dtype([('name', np.str, 16), ('grades', np.float64, (2,))])\n| >>> print(dt.fields)\n| {'grades': (dtype(('float64',(2,))), 16), 'name': (dtype('|S16'), 0)}\n|\n| flags\n| Bit-flags describing how this data type is to be interpreted.\n|\n| Bit-masks are in `numpy.core.multiarray` as the constants\n| `ITEMHASOBJECT`, `LISTPICKLE`, `ITEMISPOINTER`, `NEEDSINIT`,\n| `NEEDSPYAPI`, `USEGETITEM`, `USESETITEM`. A full explanation\n| of these flags is in C-API documentation; they are largely useful\n| for user-defined data-types.\n|\n| The following example demonstrates that operations on this particular\n| dtype requires Python C-API.\n|\n| Examples\n| --------\n|\n| >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])\n| >>> x.flags\n| 16\n| >>> np.core.multiarray.NEEDSPYAPI\n| 16\n|\n| hasobject\n| Boolean indicating whether this dtype contains any reference-counted\n| objects in any fields or sub-dtypes.\n|\n| Recall that what is actually in the ndarray memory representing\n| the Python object is the memory address of that object (a pointer).\n| Special handling may be required, and this attribute is useful for\n| distinguishing data types that may contain arbitrary Python objects\n| and data-types that won't.\n|\n| isalignedstruct\n| Boolean indicating whether the dtype is a struct which maintains\n| field alignment. This flag is sticky, so when combining multiple\n| structs together, it is preserved and produces new dtypes which\n| are also aligned.\n|\n| isbuiltin\n| Integer indicating how this dtype relates to the built-in dtypes.\n|\n| Read-only.\n|\n| = ========================================================================\n| 0 if this is a structured array type, with fields\n| 1 if this is a dtype compiled into numpy (such as ints, floats etc)\n| 2 if the dtype is for a user-defined numpy type\n| A user-defined type uses the numpy C-API machinery to extend\n| numpy to handle a new array type. See\n| :ref:`user.user-defined-data-types` in the NumPy manual.\n| = ========================================================================\n|\n| Examples\n| --------\n| >>> dt = np.dtype('i2')\n| >>> dt.isbuiltin\n| 1\n| >>> dt = np.dtype('f8')\n| >>> dt.isbuiltin\n| 1\n| >>> dt = np.dtype([('field1', 'f8')])\n| >>> dt.isbuiltin\n| 0\n|\n| isnative\n| Boolean indicating whether the byte order of this dtype is native\n| to the platform.\n|\n| itemsize\n| The element size of this data-type object.\n|\n| For 18 of the 21 types this number is fixed by the data-type.\n| For the flexible data-types, this number can be anything.\n|\n| Examples\n| --------\n|\n| >>> arr = np.array([[1, 2], [3, 4]])\n| >>> arr.dtype\n| dtype('int64')\n| >>> arr.itemsize\n| 8\n|\n| >>> dt = np.dtype([('name', np.str, 16), ('grades', np.float64, (2,))])\n| >>> dt.itemsize\n| 80\n|\n| kind\n| A character code (one of 'biufcmMOSUV') identifying the general kind of data.\n|\n| = ======================\n| b boolean\n| i signed integer\n| u unsigned integer\n| f floating-point\n| c complex floating-point\n| m timedelta\n| M datetime\n| O object\n| S (byte-)string\n| U Unicode\n| V void\n| = ======================\n|\n| Examples\n| --------\n|\n| >>> dt = np.dtype('i4')\n| >>> dt.kind\n| 'i'\n| >>> dt = np.dtype('f8')\n| >>> dt.kind\n| 'f'\n| >>> dt = np.dtype([('field1', 'f8')])\n| >>> dt.kind\n| 'V'\n|\n| metadata\n| Either ``None`` or a readonly dictionary of metadata (mappingproxy).\n|\n| The metadata field can be set using any dictionary at data-type\n| creation. NumPy currently has no uniform approach to propagating\n| metadata; although some array operations preserve it, there is no\n| guarantee that others will.\n|\n| .. warning::\n|\n| Although used in certain projects, this feature was long undocumented\n| and is not well supported. Some aspects of metadata propagation\n| are expected to change in the future.\n|\n| Examples\n| --------\n|\n| >>> dt = np.dtype(float, metadata={\"key\": \"value\"})\n| >>> dt.metadata[\"key\"]\n| 'value'\n| >>> arr = np.array([1, 2, 3], dtype=dt)\n| >>> arr.dtype.metadata\n| mappingproxy({'key': 'value'})\n|\n| Adding arrays with identical datatypes currently preserves the metadata:\n|\n| >>> (arr + arr).dtype.metadata\n| mappingproxy({'key': 'value'})\n|\n| But if the arrays have different dtype metadata, the metadata may be\n| dropped:\n|\n| >>> dt2 = np.dtype(float, metadata={\"key2\": \"value2\"})\n| >>> arr2 = np.array([3, 2, 1], dtype=dt2)\n| >>> (arr + arr2).dtype.metadata is None\n| True # The metadata field is cleared so None is returned\n|\n| name\n| A bit-width name for this data-type.\n|\n| Un-sized flexible data-type objects do not have this attribute.\n|\n| Examples\n| --------\n|\n| >>> x = np.dtype(float)\n| >>> x.name\n| 'float64'\n| >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])\n| >>> x.name\n| 'void640'\n|\n| names\n| Ordered list of field names, or ``None`` if there are no fields.\n|\n| The names are ordered according to increasing byte offset. This can be\n| used, for example, to walk through all of the named fields in offset order.\n|\n| Examples\n| --------\n| >>> dt = np.dtype([('name', np.str, 16), ('grades', np.float64, (2,))])\n| >>> dt.names\n| ('name', 'grades')\n|\n| ndim\n| Number of dimensions of the sub-array if this data type describes a\n| sub-array, and ``0`` otherwise.\n|\n| .. versionadded:: 1.13.0\n|\n| Examples\n| --------\n| >>> x = np.dtype(float)\n| >>> x.ndim\n| 0\n|\n| >>> x = np.dtype((float, 8))\n| >>> x.ndim\n| 1\n|\n| >>> x = np.dtype(('i4', (3, 4)))\n| >>> x.ndim\n| 2\n|\n| num\n| A unique number for each of the 21 different built-in types.\n|\n| These are roughly ordered from least-to-most precision.\n|\n| Examples\n| --------\n|\n| >>> dt = np.dtype(str)\n| >>> dt.num\n| 19\n|\n| >>> dt = np.dtype(float)\n| >>> dt.num\n| 12\n|\n| shape\n| Shape tuple of the sub-array if this data type describes a sub-array,\n| and ``()`` otherwise.\n|\n| Examples\n| --------\n|\n| >>> dt = np.dtype(('i4', 4))\n| >>> dt.shape\n| (4,)\n|\n| >>> dt = np.dtype(('i4', (2, 3)))\n| >>> dt.shape\n| (2, 3)\n|\n| str\n| The array-protocol typestring of this data-type object.\n|\n| subdtype\n| Tuple ``(itemdtype, shape)`` if this `dtype` describes a sub-array, and\n| None otherwise.\n|\n| The *shape* is the fixed shape of the sub-array described by this\n| data type, and *itemdtype* the data type of the array.\n|\n| If a field whose dtype object has this attribute is retrieved,\n| then the extra dimensions implied by *shape* are tacked on to\n| the end of the retrieved array.\n|\n| See Also\n| --------\n| dtype.base\n|\n| Examples\n| --------\n| >>> x = numpy.dtype('8f')\n| >>> x.subdtype\n| (dtype('float32'), (8,))\n|\n| >>> x = numpy.dtype('i2')\n| >>> x.subdtype\n| >>>\n|\n| type\n" }, { "name": "class errstate", "content": "| errstate(*, call=, kwargs)\n|\n| errstate(kwargs)\n|\n| Context manager for floating-point error handling.\n|\n| Using an instance of `errstate` as a context manager allows statements in\n| that context to execute with a known error handling behavior. Upon entering\n| the context the error handling is set with `seterr` and `seterrcall`, and\n| upon exiting it is reset to what it was before.\n|\n| .. versionchanged:: 1.17.0\n| `errstate` is also usable as a function decorator, saving\n| a level of indentation if an entire function is wrapped.\n| See :py:class:`contextlib.ContextDecorator` for more information.\n|\n| Parameters\n| ----------\n| kwargs : {divide, over, under, invalid}\n| Keyword arguments. The valid keywords are the possible floating-point\n| exceptions. Each keyword should have a string value that defines the\n| treatment for the particular error. Possible values are\n| {'ignore', 'warn', 'raise', 'call', 'print', 'log'}.\n|\n| See Also\n| --------\n| seterr, geterr, seterrcall, geterrcall\n|\n| Notes\n| -----\n| For complete documentation of the types of floating-point exceptions and\n| treatment options, see `seterr`.\n|\n| Examples\n| --------\n| >>> olderr = np.seterr(all='ignore') # Set error handling to known state.\n|\n| >>> np.arange(3) / 0.\n| array([nan, inf, inf])\n| >>> with np.errstate(divide='warn'):\n| ... np.arange(3) / 0.\n| array([nan, inf, inf])\n|\n| >>> np.sqrt(-1)\n| nan\n| >>> with np.errstate(invalid='raise'):\n| ... np.sqrt(-1)\n| Traceback (most recent call last):\n| File \"\", line 2, in \n| FloatingPointError: invalid value encountered in sqrt\n|\n| Outside the context the error handling behavior has not changed:\n|\n| >>> np.geterr()\n| {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}\n|\n| Method resolution order:\n| errstate\n| contextlib.ContextDecorator\n| builtins.object\n|\n| Methods defined here:\n|\n| enter(self)\n|\n| exit(self, *excinfo)\n|\n| init(self, *, call=, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from contextlib.ContextDecorator:\n|\n| call(self, func)\n| Call self as a function.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from contextlib.ContextDecorator:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class finfo", "content": "| finfo(dtype)\n|\n| finfo(dtype)\n|\n| Machine limits for floating point types.\n|\n| Attributes\n| ----------\n| bits : int\n| The number of bits occupied by the type.\n| eps : float\n| The difference between 1.0 and the next smallest representable float\n| larger than 1.0. For example, for 64-bit binary floats in the IEEE-754\n| standard, ``eps = 2-52``, approximately 2.22e-16.\n| epsneg : float\n| The difference between 1.0 and the next smallest representable float\n| less than 1.0. For example, for 64-bit binary floats in the IEEE-754\n| standard, ``epsneg = 2-53``, approximately 1.11e-16.\n| iexp : int\n| The number of bits in the exponent portion of the floating point\n| representation.\n| machar : MachAr\n| The object which calculated these parameters and holds more\n| detailed information.\n| machep : int\n| The exponent that yields `eps`.\n| max : floating point number of the appropriate type\n| The largest representable number.\n| maxexp : int\n| The smallest positive power of the base (2) that causes overflow.\n| min : floating point number of the appropriate type\n| The smallest representable number, typically ``-max``.\n| minexp : int\n| The most negative power of the base (2) consistent with there\n| being no leading 0's in the mantissa.\n| negep : int\n| The exponent that yields `epsneg`.\n| nexp : int\n| The number of bits in the exponent including its sign and bias.\n| nmant : int\n| The number of bits in the mantissa.\n| precision : int\n| The approximate number of decimal digits to which this kind of\n| float is precise.\n| resolution : floating point number of the appropriate type\n| The approximate decimal resolution of this type, i.e.,\n| ``10-precision``.\n| tiny : float\n| The smallest positive floating point number with full precision\n| (see Notes).\n|\n| Parameters\n| ----------\n| dtype : float, dtype, or instance\n| Kind of floating point data-type about which to get information.\n|\n| See Also\n| --------\n| MachAr : The implementation of the tests that produce this information.\n| iinfo : The equivalent for integer data types.\n| spacing : The distance between a value and the nearest adjacent number\n| nextafter : The next floating point value after x1 towards x2\n|\n| Notes\n| -----\n| For developers of NumPy: do not instantiate this at the module level.\n| The initial calculation of these parameters is expensive and negatively\n| impacts import times. These objects are cached, so calling ``finfo()``\n| repeatedly inside your functions is not a problem.\n|\n| Note that ``tiny`` is not actually the smallest positive representable\n| value in a NumPy floating point type. As in the IEEE-754 standard [1],\n| NumPy floating point types make use of subnormal numbers to fill the\n| gap between 0 and ``tiny``. However, subnormal numbers may have\n| significantly reduced precision [2].\n|\n| References\n| ----------\n| .. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008,\n| pp.1-70, 2008, http://www.doi.org/10.1109/IEEESTD.2008.4610935\n| .. [2] Wikipedia, \"Denormal Numbers\",\n| https://en.wikipedia.org/wiki/Denormalnumber\n|\n| Methods defined here:\n|\n| repr(self)\n| Return repr(self).\n|\n| str(self)\n| Return str(self).\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(cls, dtype)\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class flatiter", "content": "| Flat iterator object to iterate over arrays.\n|\n| A `flatiter` iterator is returned by ``x.flat`` for any array `x`.\n| It allows iterating over the array as if it were a 1-D array,\n| either in a for-loop or by calling its `next` method.\n|\n| Iteration is done in row-major, C-style order (the last\n| index varying the fastest). The iterator can also be indexed using\n| basic slicing or advanced indexing.\n|\n| See Also\n| --------\n| ndarray.flat : Return a flat iterator over an array.\n| ndarray.flatten : Returns a flattened copy of an array.\n|\n| Notes\n| -----\n| A `flatiter` iterator can not be constructed directly from Python code\n| by calling the `flatiter` constructor.\n|\n| Examples\n| --------\n| >>> x = np.arange(6).reshape(2, 3)\n| >>> fl = x.flat\n| >>> type(fl)\n| \n| >>> for item in fl:\n| ... print(item)\n| ...\n| 0\n| 1\n| 2\n| 3\n| 4\n| 5\n|\n| >>> fl[2:4]\n| array([2, 3])\n|\n| Methods defined here:\n|\n| array(...)\n| array(type=None) Get array from iterator\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self>> x = np.arange(6).reshape(2, 3)\n| >>> x\n| array([[0, 1, 2],\n| [3, 4, 5]])\n| >>> fl = x.flat\n| >>> fl.copy()\n| array([0, 1, 2, 3, 4, 5])\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| base\n| A reference to the array that is iterated over.\n|\n| Examples\n| --------\n| >>> x = np.arange(5)\n| >>> fl = x.flat\n| >>> fl.base is x\n| True\n|\n| coords\n| An N-dimensional tuple of current coordinates.\n|\n| Examples\n| --------\n| >>> x = np.arange(6).reshape(2, 3)\n| >>> fl = x.flat\n| >>> fl.coords\n| (0, 0)\n| >>> next(fl)\n| 0\n| >>> fl.coords\n| (0, 1)\n|\n| index\n| Current flat index into the array.\n|\n| Examples\n| --------\n| >>> x = np.arange(6).reshape(2, 3)\n| >>> fl = x.flat\n| >>> fl.index\n| 0\n| >>> next(fl)\n| 0\n| >>> fl.index\n| 1\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| hash = None\n" }, { "name": "class flexible", "content": "| Abstract base class of all scalar types without predefined length.\n| The actual size of these types depends on the specific `np.dtype`\n| instantiation.\n|\n| Method resolution order:\n| flexible\n| generic\n| builtins.object\n|\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n" }, { "name": "class float128", "content": "| Extended-precision floating-point number type, compatible with C\n| ``long double`` but not necessarily with IEEE 754 quadruple-precision.\n|\n| :Character code: ``'g'``\n| :Canonical name: `numpy.longdouble`\n| :Alias: `numpy.longfloat`\n| :Alias on this platform (Linux x8664): `numpy.float128`: 128-bit extended-precision floating-point number type.\n|\n| Method resolution order:\n| float128\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.longdouble(10.0).asintegerratio()\n| (10, 1)\n| >>> np.longdouble(0.0).asintegerratio()\n| (0, 1)\n| >>> np.longdouble(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class float16", "content": "| Half-precision floating-point number type.\n|\n| :Character code: ``'e'``\n| :Canonical name: `numpy.half`\n| :Alias on this platform (Linux x8664): `numpy.float16`: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.\n|\n| Method resolution order:\n| float16\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.half(10.0).asintegerratio()\n| (10, 1)\n| >>> np.half(0.0).asintegerratio()\n| (0, 1)\n| >>> np.half(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class float32", "content": "| Single-precision floating-point number type, compatible with C ``float``.\n|\n| :Character code: ``'f'``\n| :Canonical name: `numpy.single`\n| :Alias on this platform (Linux x8664): `numpy.float32`: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.\n|\n| Method resolution order:\n| float32\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.single(10.0).asintegerratio()\n| (10, 1)\n| >>> np.single(0.0).asintegerratio()\n| (0, 1)\n| >>> np.single(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class float64", "content": "| float64(x=0, /)\n|\n| Double-precision floating-point number type, compatible with Python `float`\n| and C ``double``.\n|\n| :Character code: ``'d'``\n| :Canonical name: `numpy.double`\n| :Alias: `numpy.float`\n| :Alias on this platform (Linux x8664): `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.\n|\n| Method resolution order:\n| float64\n| floating\n| inexact\n| number\n| generic\n| builtins.float\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.double(10.0).asintegerratio()\n| (10, 1)\n| >>> np.double(0.0).asintegerratio()\n| (0, 1)\n| >>> np.double(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.float:\n|\n| ceil(self, /)\n| Return the ceiling as an Integral.\n|\n| floor(self, /)\n| Return the floor as an Integral.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getnewargs(self, /)\n|\n| trunc(self, /)\n| Return the Integral closest to x between 0 and x.\n|\n| hex(self, /)\n| Return a hexadecimal representation of a floating-point number.\n|\n| >>> (-0.1).hex()\n| '-0x1.999999999999ap-4'\n| >>> 3.14159.hex()\n| '0x1.921f9f01b866ep+1'\n|\n| isinteger(self, /)\n| Return True if the float is an integer.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.float:\n|\n| getformat(typestr, /) from builtins.type\n| You probably don't want to use this function.\n|\n| typestr\n| Must be 'double' or 'float'.\n|\n| It exists mainly to be used in Python's test suite.\n|\n| This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,\n| little-endian' best describes the format of floating point numbers used by the\n| C type named by typestr.\n|\n| setformat(typestr, fmt, /) from builtins.type\n| You probably don't want to use this function.\n|\n| typestr\n| Must be 'double' or 'float'.\n| fmt\n| Must be one of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian',\n| and in addition can only be one of the latter two if it appears to\n| match the underlying C reality.\n|\n| It exists mainly to be used in Python's test suite.\n|\n| Override the automatic determination of C-level floating point type.\n| This affects how floats are converted to and from binary strings.\n|\n| fromhex(string, /) from builtins.type\n| Create a floating-point number from a hexadecimal string.\n|\n| >>> float.fromhex('0x1.ffffp10')\n| 2047.984375\n| >>> float.fromhex('-0x1p-1074')\n| -5e-324\n\nfloat = class float64(floating, builtins.float)\n| float(x=0, /)\n|\n| Double-precision floating-point number type, compatible with Python `float`\n| and C ``double``.\n|\n| :Character code: ``'d'``\n| :Canonical name: `numpy.double`\n| :Alias: `numpy.float`\n| :Alias on this platform (Linux x8664): `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.\n|\n| Method resolution order:\n| float64\n| floating\n| inexact\n| number\n| generic\n| builtins.float\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.double(10.0).asintegerratio()\n| (10, 1)\n| >>> np.double(0.0).asintegerratio()\n| (0, 1)\n| >>> np.double(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from builtins.float:\n|\n| ceil(self, /)\n| Return the ceiling as an Integral.\n|\n| floor(self, /)\n| Return the floor as an Integral.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getnewargs(self, /)\n|\n| trunc(self, /)\n| Return the Integral closest to x between 0 and x.\n|\n| hex(self, /)\n| Return a hexadecimal representation of a floating-point number.\n|\n| >>> (-0.1).hex()\n| '-0x1.999999999999ap-4'\n| >>> 3.14159.hex()\n| '0x1.921f9f01b866ep+1'\n|\n| isinteger(self, /)\n| Return True if the float is an integer.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.float:\n|\n| getformat(typestr, /) from builtins.type\n| You probably don't want to use this function.\n|\n| typestr\n| Must be 'double' or 'float'.\n|\n| It exists mainly to be used in Python's test suite.\n|\n| This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,\n| little-endian' best describes the format of floating point numbers used by the\n| C type named by typestr.\n|\n| setformat(typestr, fmt, /) from builtins.type\n| You probably don't want to use this function.\n|\n| typestr\n| Must be 'double' or 'float'.\n| fmt\n| Must be one of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian',\n| and in addition can only be one of the latter two if it appears to\n| match the underlying C reality.\n|\n| It exists mainly to be used in Python's test suite.\n|\n| Override the automatic determination of C-level floating point type.\n| This affects how floats are converted to and from binary strings.\n|\n| fromhex(string, /) from builtins.type\n| Create a floating-point number from a hexadecimal string.\n|\n| >>> float.fromhex('0x1.ffffp10')\n| 2047.984375\n| >>> float.fromhex('-0x1p-1074')\n| -5e-324\n" }, { "name": "class floating", "content": "| Abstract base class of all floating-point scalar types.\n|\n| Method resolution order:\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n" }, { "name": "class format_parser", "content": "| formatparser(formats, names, titles, aligned=False, byteorder=None)\n|\n| Class to convert formats, names, titles description to a dtype.\n|\n| After constructing the formatparser object, the dtype attribute is\n| the converted data-type:\n| ``dtype = formatparser(formats, names, titles).dtype``\n|\n| Attributes\n| ----------\n| dtype : dtype\n| The converted data-type.\n|\n| Parameters\n| ----------\n| formats : str or list of str\n| The format description, either specified as a string with\n| comma-separated format descriptions in the form ``'f8, i4, a5'``, or\n| a list of format description strings in the form\n| ``['f8', 'i4', 'a5']``.\n| names : str or list/tuple of str\n| The field names, either specified as a comma-separated string in the\n| form ``'col1, col2, col3'``, or as a list or tuple of strings in the\n| form ``['col1', 'col2', 'col3']``.\n| An empty list can be used, in that case default field names\n| ('f0', 'f1', ...) are used.\n| titles : sequence\n| Sequence of title strings. An empty list can be used to leave titles\n| out.\n| aligned : bool, optional\n| If True, align the fields by padding as the C-compiler would.\n| Default is False.\n| byteorder : str, optional\n| If specified, all the fields will be changed to the\n| provided byte-order. Otherwise, the default byte-order is\n| used. For all available string specifiers, see `dtype.newbyteorder`.\n|\n| See Also\n| --------\n| dtype, typename, sctype2char\n|\n| Examples\n| --------\n| >>> np.formatparser(['>> np.formatparser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],\n| ... []).dtype\n| dtype([('col1', '>> np.formatparser(['=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| hash = None\n\nhalf = class float16(floating)\n| Half-precision floating-point number type.\n|\n| :Character code: ``'e'``\n| :Canonical name: `numpy.half`\n| :Alias on this platform (Linux x8664): `numpy.float16`: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.\n|\n| Method resolution order:\n| float16\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.half(10.0).asintegerratio()\n| (10, 1)\n| >>> np.half(0.0).asintegerratio()\n| (0, 1)\n| >>> np.half(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class iinfo", "content": "| iinfo(inttype)\n|\n| iinfo(type)\n|\n| Machine limits for integer types.\n|\n| Attributes\n| ----------\n| bits : int\n| The number of bits occupied by the type.\n| min : int\n| The smallest integer expressible by the type.\n| max : int\n| The largest integer expressible by the type.\n|\n| Parameters\n| ----------\n| inttype : integer type, dtype, or instance\n| The kind of integer data type to get information about.\n|\n| See Also\n| --------\n| finfo : The equivalent for floating point data types.\n|\n| Examples\n| --------\n| With types:\n|\n| >>> ii16 = np.iinfo(np.int16)\n| >>> ii16.min\n| -32768\n| >>> ii16.max\n| 32767\n| >>> ii32 = np.iinfo(np.int32)\n| >>> ii32.min\n| -2147483648\n| >>> ii32.max\n| 2147483647\n|\n| With instances:\n|\n| >>> ii32 = np.iinfo(np.int32(10))\n| >>> ii32.min\n| -2147483648\n| >>> ii32.max\n| 2147483647\n|\n| Methods defined here:\n|\n| init(self, inttype)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| repr(self)\n| Return repr(self).\n|\n| str(self)\n| String representation.\n|\n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| max\n| Maximum value of given dtype.\n|\n| min\n| Minimum value of given dtype.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class inexact", "content": "| Abstract base class of all numeric scalar types with a (potentially)\n| inexact representation of the values in its range, such as\n| floating-point numbers.\n|\n| Method resolution order:\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n\nint0 = class int64(signedinteger)\n| Signed integer type, compatible with Python `int` and C ``long``.\n|\n| :Character code: ``'l'``\n| :Canonical name: `numpy.int`\n| :Alias on this platform (Linux x8664): `numpy.int64`: 64-bit signed integer (``-9223372036854775808`` to ``9223372036854775807``).\n| :Alias on this platform (Linux x8664): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptrt``.\n|\n| Method resolution order:\n| int64\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class int16", "content": "| Signed integer type, compatible with C ``short``.\n|\n| :Character code: ``'h'``\n| :Canonical name: `numpy.short`\n| :Alias on this platform (Linux x8664): `numpy.int16`: 16-bit signed integer (``-32768`` to ``32767``).\n|\n| Method resolution order:\n| int16\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class int32", "content": "| Signed integer type, compatible with C ``int``.\n|\n| :Character code: ``'i'``\n| :Canonical name: `numpy.intc`\n| :Alias on this platform (Linux x8664): `numpy.int32`: 32-bit signed integer (``-2147483648`` to ``2147483647``).\n|\n| Method resolution order:\n| int32\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class int64", "content": "| Signed integer type, compatible with Python `int` and C ``long``.\n|\n| :Character code: ``'l'``\n| :Canonical name: `numpy.int`\n| :Alias on this platform (Linux x8664): `numpy.int64`: 64-bit signed integer (``-9223372036854775808`` to ``9223372036854775807``).\n| :Alias on this platform (Linux x8664): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptrt``.\n|\n| Method resolution order:\n| int64\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class int8", "content": "| Signed integer type, compatible with C ``char``.\n|\n| :Character code: ``'b'``\n| :Canonical name: `numpy.byte`\n| :Alias on this platform (Linux x8664): `numpy.int8`: 8-bit signed integer (``-128`` to ``127``).\n|\n| Method resolution order:\n| int8\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nint = class int64(signedinteger)\n| Signed integer type, compatible with Python `int` and C ``long``.\n|\n| :Character code: ``'l'``\n| :Canonical name: `numpy.int`\n| :Alias on this platform (Linux x8664): `numpy.int64`: 64-bit signed integer (``-9223372036854775808`` to ``9223372036854775807``).\n| :Alias on this platform (Linux x8664): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptrt``.\n|\n| Method resolution order:\n| int64\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nintc = class int32(signedinteger)\n| Signed integer type, compatible with C ``int``.\n|\n| :Character code: ``'i'``\n| :Canonical name: `numpy.intc`\n| :Alias on this platform (Linux x8664): `numpy.int32`: 32-bit signed integer (``-2147483648`` to ``2147483647``).\n|\n| Method resolution order:\n| int32\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class integer", "content": "| Abstract base class of all integer scalar types.\n|\n| Method resolution order:\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n\nintp = class int64(signedinteger)\n| Signed integer type, compatible with Python `int` and C ``long``.\n|\n| :Character code: ``'l'``\n| :Canonical name: `numpy.int`\n| :Alias on this platform (Linux x8664): `numpy.int64`: 64-bit signed integer (``-9223372036854775808`` to ``9223372036854775807``).\n| :Alias on this platform (Linux x8664): `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptrt``.\n|\n| Method resolution order:\n| int64\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nlongcomplex = class complex256(complexfloating)\n| Complex number type composed of two extended-precision floating-point\n| numbers.\n|\n| :Character code: ``'G'``\n| :Canonical name: `numpy.clongdouble`\n| :Alias: `numpy.clongfloat`\n| :Alias: `numpy.longcomplex`\n| :Alias on this platform (Linux x8664): `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers.\n|\n| Method resolution order:\n| complex256\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nlongdouble = class float128(floating)\n| Extended-precision floating-point number type, compatible with C\n| ``long double`` but not necessarily with IEEE 754 quadruple-precision.\n|\n| :Character code: ``'g'``\n| :Canonical name: `numpy.longdouble`\n| :Alias: `numpy.longfloat`\n| :Alias on this platform (Linux x8664): `numpy.float128`: 128-bit extended-precision floating-point number type.\n|\n| Method resolution order:\n| float128\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.longdouble(10.0).asintegerratio()\n| (10, 1)\n| >>> np.longdouble(0.0).asintegerratio()\n| (0, 1)\n| >>> np.longdouble(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nlongfloat = class float128(floating)\n| Extended-precision floating-point number type, compatible with C\n| ``long double`` but not necessarily with IEEE 754 quadruple-precision.\n|\n| :Character code: ``'g'``\n| :Canonical name: `numpy.longdouble`\n| :Alias: `numpy.longfloat`\n| :Alias on this platform (Linux x8664): `numpy.float128`: 128-bit extended-precision floating-point number type.\n|\n| Method resolution order:\n| float128\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.longdouble(10.0).asintegerratio()\n| (10, 1)\n| >>> np.longdouble(0.0).asintegerratio()\n| (0, 1)\n| >>> np.longdouble(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class longlong", "content": "| Signed integer type, compatible with C ``long long``.\n|\n| :Character code: ``'q'``\n|\n| Method resolution order:\n| longlong\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class matrix", "content": "| matrix(data, dtype=None, copy=True)\n|\n| matrix(data, dtype=None, copy=True)\n|\n| .. note:: It is no longer recommended to use this class, even for linear\n| algebra. Instead use regular arrays. The class may be removed\n| in the future.\n|\n| Returns a matrix from an array-like object, or from a string of data.\n| A matrix is a specialized 2-D array that retains its 2-D nature\n| through operations. It has certain special operators, such as ``*``\n| (matrix multiplication) and ```` (matrix power).\n|\n| Parameters\n| ----------\n| data : arraylike or string\n| If `data` is a string, it is interpreted as a matrix with commas\n| or spaces separating columns, and semicolons separating rows.\n| dtype : data-type\n| Data-type of the output matrix.\n| copy : bool\n| If `data` is already an `ndarray`, then this flag determines\n| whether the data is copied (the default), or whether a view is\n| constructed.\n|\n| See Also\n| --------\n| array\n|\n| Examples\n| --------\n| >>> a = np.matrix('1 2; 3 4')\n| >>> a\n| matrix([[1, 2],\n| [3, 4]])\n|\n| >>> np.matrix([[1, 2], [3, 4]])\n| matrix([[1, 2],\n| [3, 4]])\n|\n| Method resolution order:\n| matrix\n| ndarray\n| builtins.object\n|\n| Methods defined here:\n|\n| arrayfinalize(self, obj)\n| None.\n|\n| getitem(self, index)\n| Return self[key].\n|\n| imul(self, other)\n| Return self*=value.\n|\n| ipow(self, other)\n| Return self=value.\n|\n| mul(self, other)\n| Return self*value.\n|\n| pow(self, other)\n| Return pow(self, value, mod).\n|\n| rmul(self, other)\n| Return value*self.\n|\n| rpow(self, other)\n| Return pow(value, self, mod).\n|\n| all(self, axis=None, out=None)\n| Test whether all matrix elements along a given axis evaluate to True.\n|\n| Parameters\n| ----------\n| See `numpy.all` for complete descriptions\n|\n| See Also\n| --------\n| numpy.all\n|\n| Notes\n| -----\n| This is the same as `ndarray.all`, but it returns a `matrix` object.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> y = x[0]; y\n| matrix([[0, 1, 2, 3]])\n| >>> (x == y)\n| matrix([[ True, True, True, True],\n| [False, False, False, False],\n| [False, False, False, False]])\n| >>> (x == y).all()\n| False\n| >>> (x == y).all(0)\n| matrix([[False, False, False, False]])\n| >>> (x == y).all(1)\n| matrix([[ True],\n| [False],\n| [False]])\n|\n| any(self, axis=None, out=None)\n| Test whether any array element along a given axis evaluates to True.\n|\n| Refer to `numpy.any` for full documentation.\n|\n| Parameters\n| ----------\n| axis : int, optional\n| Axis along which logical OR is performed\n| out : ndarray, optional\n| Output to existing array instead of creating new one, must have\n| same shape as expected output\n|\n| Returns\n| -------\n| any : bool, ndarray\n| Returns a single bool if `axis` is ``None``; otherwise,\n| returns `ndarray`\n|\n| argmax(self, axis=None, out=None)\n| Indexes of the maximum values along an axis.\n|\n| Return the indexes of the first occurrences of the maximum values\n| along the specified axis. If axis is None, the index is for the\n| flattened matrix.\n|\n| Parameters\n| ----------\n| See `numpy.argmax` for complete descriptions\n|\n| See Also\n| --------\n| numpy.argmax\n|\n| Notes\n| -----\n| This is the same as `ndarray.argmax`, but returns a `matrix` object\n| where `ndarray.argmax` would return an `ndarray`.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.argmax()\n| 11\n| >>> x.argmax(0)\n| matrix([[2, 2, 2, 2]])\n| >>> x.argmax(1)\n| matrix([[3],\n| [3],\n| [3]])\n|\n| argmin(self, axis=None, out=None)\n| Indexes of the minimum values along an axis.\n|\n| Return the indexes of the first occurrences of the minimum values\n| along the specified axis. If axis is None, the index is for the\n| flattened matrix.\n|\n| Parameters\n| ----------\n| See `numpy.argmin` for complete descriptions.\n|\n| See Also\n| --------\n| numpy.argmin\n|\n| Notes\n| -----\n| This is the same as `ndarray.argmin`, but returns a `matrix` object\n| where `ndarray.argmin` would return an `ndarray`.\n|\n| Examples\n| --------\n| >>> x = -np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, -1, -2, -3],\n| [ -4, -5, -6, -7],\n| [ -8, -9, -10, -11]])\n| >>> x.argmin()\n| 11\n| >>> x.argmin(0)\n| matrix([[2, 2, 2, 2]])\n| >>> x.argmin(1)\n| matrix([[3],\n| [3],\n| [3]])\n|\n| flatten(self, order='C')\n| Return a flattened copy of the matrix.\n|\n| All `N` elements of the matrix are placed into a single row.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| 'C' means to flatten in row-major (C-style) order. 'F' means to\n| flatten in column-major (Fortran-style) order. 'A' means to\n| flatten in column-major order if `m` is Fortran *contiguous* in\n| memory, row-major order otherwise. 'K' means to flatten `m` in\n| the order the elements occur in memory. The default is 'C'.\n|\n| Returns\n| -------\n| y : matrix\n| A copy of the matrix, flattened to a `(1, N)` matrix where `N`\n| is the number of elements in the original matrix.\n|\n| See Also\n| --------\n| ravel : Return a flattened array.\n| flat : A 1-D flat iterator over the matrix.\n|\n| Examples\n| --------\n| >>> m = np.matrix([[1,2], [3,4]])\n| >>> m.flatten()\n| matrix([[1, 2, 3, 4]])\n| >>> m.flatten('F')\n| matrix([[1, 3, 2, 4]])\n|\n| getA = A(self)\n| Return `self` as an `ndarray` object.\n|\n| Equivalent to ``np.asarray(self)``.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : ndarray\n| `self` as an `ndarray`\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.getA()\n| array([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n|\n| getA1 = A1(self)\n| Return `self` as a flattened `ndarray`.\n|\n| Equivalent to ``np.asarray(x).ravel()``\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : ndarray\n| `self`, 1-D, as an `ndarray`\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.getA1()\n| array([ 0, 1, 2, ..., 9, 10, 11])\n|\n| getH = H(self)\n| Returns the (complex) conjugate transpose of `self`.\n|\n| Equivalent to ``np.transpose(self)`` if `self` is real-valued.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : matrix object\n| complex conjugate transpose of `self`\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4)))\n| >>> z = x - 1j*x; z\n| matrix([[ 0. +0.j, 1. -1.j, 2. -2.j, 3. -3.j],\n| [ 4. -4.j, 5. -5.j, 6. -6.j, 7. -7.j],\n| [ 8. -8.j, 9. -9.j, 10.-10.j, 11.-11.j]])\n| >>> z.getH()\n| matrix([[ 0. -0.j, 4. +4.j, 8. +8.j],\n| [ 1. +1.j, 5. +5.j, 9. +9.j],\n| [ 2. +2.j, 6. +6.j, 10.+10.j],\n| [ 3. +3.j, 7. +7.j, 11.+11.j]])\n|\n| getI = I(self)\n| Returns the (multiplicative) inverse of invertible `self`.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : matrix object\n| If `self` is non-singular, `ret` is such that ``ret * self`` ==\n| ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return\n| ``True``.\n|\n| Raises\n| ------\n| numpy.linalg.LinAlgError: Singular matrix\n| If `self` is singular.\n|\n| See Also\n| --------\n| linalg.inv\n|\n| Examples\n| --------\n| >>> m = np.matrix('[1, 2; 3, 4]'); m\n| matrix([[1, 2],\n| [3, 4]])\n| >>> m.getI()\n| matrix([[-2. , 1. ],\n| [ 1.5, -0.5]])\n| >>> m.getI() * m\n| matrix([[ 1., 0.], # may vary\n| [ 0., 1.]])\n|\n| getT = T(self)\n| Returns the transpose of the matrix.\n|\n| Does *not* conjugate! For the complex conjugate transpose, use ``.H``.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : matrix object\n| The (non-conjugated) transpose of the matrix.\n|\n| See Also\n| --------\n| transpose, getH\n|\n| Examples\n| --------\n| >>> m = np.matrix('[1, 2; 3, 4]')\n| >>> m\n| matrix([[1, 2],\n| [3, 4]])\n| >>> m.getT()\n| matrix([[1, 3],\n| [2, 4]])\n|\n| max(self, axis=None, out=None)\n| Return the maximum value along an axis.\n|\n| Parameters\n| ----------\n| See `amax` for complete descriptions\n|\n| See Also\n| --------\n| amax, ndarray.max\n|\n| Notes\n| -----\n| This is the same as `ndarray.max`, but returns a `matrix` object\n| where `ndarray.max` would return an ndarray.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.max()\n| 11\n| >>> x.max(0)\n| matrix([[ 8, 9, 10, 11]])\n| >>> x.max(1)\n| matrix([[ 3],\n| [ 7],\n| [11]])\n|\n| mean(self, axis=None, dtype=None, out=None)\n| Returns the average of the matrix elements along the given axis.\n|\n| Refer to `numpy.mean` for full documentation.\n|\n| See Also\n| --------\n| numpy.mean\n|\n| Notes\n| -----\n| Same as `ndarray.mean` except that, where that returns an `ndarray`,\n| this returns a `matrix` object.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3, 4)))\n| >>> x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.mean()\n| 5.5\n| >>> x.mean(0)\n| matrix([[4., 5., 6., 7.]])\n| >>> x.mean(1)\n| matrix([[ 1.5],\n| [ 5.5],\n| [ 9.5]])\n|\n| min(self, axis=None, out=None)\n| Return the minimum value along an axis.\n|\n| Parameters\n| ----------\n| See `amin` for complete descriptions.\n|\n| See Also\n| --------\n| amin, ndarray.min\n|\n| Notes\n| -----\n| This is the same as `ndarray.min`, but returns a `matrix` object\n| where `ndarray.min` would return an ndarray.\n|\n| Examples\n| --------\n| >>> x = -np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, -1, -2, -3],\n| [ -4, -5, -6, -7],\n| [ -8, -9, -10, -11]])\n| >>> x.min()\n| -11\n| >>> x.min(0)\n| matrix([[ -8, -9, -10, -11]])\n| >>> x.min(1)\n| matrix([[ -3],\n| [ -7],\n| [-11]])\n|\n| prod(self, axis=None, dtype=None, out=None)\n| Return the product of the array elements over the given axis.\n|\n| Refer to `prod` for full documentation.\n|\n| See Also\n| --------\n| prod, ndarray.prod\n|\n| Notes\n| -----\n| Same as `ndarray.prod`, except, where that returns an `ndarray`, this\n| returns a `matrix` object instead.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.prod()\n| 0\n| >>> x.prod(0)\n| matrix([[ 0, 45, 120, 231]])\n| >>> x.prod(1)\n| matrix([[ 0],\n| [ 840],\n| [7920]])\n|\n| ptp(self, axis=None, out=None)\n| Peak-to-peak (maximum - minimum) value along the given axis.\n|\n| Refer to `numpy.ptp` for full documentation.\n|\n| See Also\n| --------\n| numpy.ptp\n|\n| Notes\n| -----\n| Same as `ndarray.ptp`, except, where that would return an `ndarray` object,\n| this returns a `matrix` object.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.ptp()\n| 11\n| >>> x.ptp(0)\n| matrix([[8, 8, 8, 8]])\n| >>> x.ptp(1)\n| matrix([[3],\n| [3],\n| [3]])\n|\n| ravel(self, order='C')\n| Return a flattened matrix.\n|\n| Refer to `numpy.ravel` for more documentation.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| The elements of `m` are read using this index order. 'C' means to\n| index the elements in C-like order, with the last axis index\n| changing fastest, back to the first axis index changing slowest.\n| 'F' means to index the elements in Fortran-like index order, with\n| the first index changing fastest, and the last index changing\n| slowest. Note that the 'C' and 'F' options take no account of the\n| memory layout of the underlying array, and only refer to the order\n| of axis indexing. 'A' means to read the elements in Fortran-like\n| index order if `m` is Fortran *contiguous* in memory, C-like order\n| otherwise. 'K' means to read the elements in the order they occur\n| in memory, except for reversing the data when strides are negative.\n| By default, 'C' index order is used.\n|\n| Returns\n| -------\n| ret : matrix\n| Return the matrix flattened to shape `(1, N)` where `N`\n| is the number of elements in the original matrix.\n| A copy is made only if necessary.\n|\n| See Also\n| --------\n| matrix.flatten : returns a similar output matrix but always a copy\n| matrix.flat : a flat iterator on the array.\n| numpy.ravel : related function which returns an ndarray\n|\n| squeeze(self, axis=None)\n| Return a possibly reshaped matrix.\n|\n| Refer to `numpy.squeeze` for more documentation.\n|\n| Parameters\n| ----------\n| axis : None or int or tuple of ints, optional\n| Selects a subset of the axes of length one in the shape.\n| If an axis is selected with shape entry greater than one,\n| an error is raised.\n|\n| Returns\n| -------\n| squeezed : matrix\n| The matrix, but as a (1, N) matrix if it had shape (N, 1).\n|\n| See Also\n| --------\n| numpy.squeeze : related function\n|\n| Notes\n| -----\n| If `m` has a single column then that column is returned\n| as the single row of a matrix. Otherwise `m` is returned.\n| The returned matrix is always either `m` itself or a view into `m`.\n| Supplying an axis keyword argument will not affect the returned matrix\n| but it may cause an error to be raised.\n|\n| Examples\n| --------\n| >>> c = np.matrix([[1], [2]])\n| >>> c\n| matrix([[1],\n| [2]])\n| >>> c.squeeze()\n| matrix([[1, 2]])\n| >>> r = c.T\n| >>> r\n| matrix([[1, 2]])\n| >>> r.squeeze()\n| matrix([[1, 2]])\n| >>> m = np.matrix([[1, 2], [3, 4]])\n| >>> m.squeeze()\n| matrix([[1, 2],\n| [3, 4]])\n|\n| std(self, axis=None, dtype=None, out=None, ddof=0)\n| Return the standard deviation of the array elements along the given axis.\n|\n| Refer to `numpy.std` for full documentation.\n|\n| See Also\n| --------\n| numpy.std\n|\n| Notes\n| -----\n| This is the same as `ndarray.std`, except that where an `ndarray` would\n| be returned, a `matrix` object is returned instead.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3, 4)))\n| >>> x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.std()\n| 3.4520525295346629 # may vary\n| >>> x.std(0)\n| matrix([[ 3.26598632, 3.26598632, 3.26598632, 3.26598632]]) # may vary\n| >>> x.std(1)\n| matrix([[ 1.11803399],\n| [ 1.11803399],\n| [ 1.11803399]])\n|\n| sum(self, axis=None, dtype=None, out=None)\n| Returns the sum of the matrix elements, along the given axis.\n|\n| Refer to `numpy.sum` for full documentation.\n|\n| See Also\n| --------\n| numpy.sum\n|\n| Notes\n| -----\n| This is the same as `ndarray.sum`, except that where an `ndarray` would\n| be returned, a `matrix` object is returned instead.\n|\n| Examples\n| --------\n| >>> x = np.matrix([[1, 2], [4, 3]])\n| >>> x.sum()\n| 10\n| >>> x.sum(axis=1)\n| matrix([[3],\n| [7]])\n| >>> x.sum(axis=1, dtype='float')\n| matrix([[3.],\n| [7.]])\n| >>> out = np.zeros((2, 1), dtype='float')\n| >>> x.sum(axis=1, dtype='float', out=np.asmatrix(out))\n| matrix([[3.],\n| [7.]])\n|\n| tolist(self)\n| Return the matrix as a (possibly nested) list.\n|\n| See `ndarray.tolist` for full documentation.\n|\n| See Also\n| --------\n| ndarray.tolist\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.tolist()\n| [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]\n|\n| var(self, axis=None, dtype=None, out=None, ddof=0)\n| Returns the variance of the matrix elements, along the given axis.\n|\n| Refer to `numpy.var` for full documentation.\n|\n| See Also\n| --------\n| numpy.var\n|\n| Notes\n| -----\n| This is the same as `ndarray.var`, except that where an `ndarray` would\n| be returned, a `matrix` object is returned instead.\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3, 4)))\n| >>> x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.var()\n| 11.916666666666666\n| >>> x.var(0)\n| matrix([[ 10.66666667, 10.66666667, 10.66666667, 10.66666667]]) # may vary\n| >>> x.var(1)\n| matrix([[1.25],\n| [1.25],\n| [1.25]])\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(subtype, data, dtype=None, copy=True)\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| A\n| Return `self` as an `ndarray` object.\n|\n| Equivalent to ``np.asarray(self)``.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : ndarray\n| `self` as an `ndarray`\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.getA()\n| array([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n|\n| A1\n| Return `self` as a flattened `ndarray`.\n|\n| Equivalent to ``np.asarray(x).ravel()``\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : ndarray\n| `self`, 1-D, as an `ndarray`\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4))); x\n| matrix([[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]])\n| >>> x.getA1()\n| array([ 0, 1, 2, ..., 9, 10, 11])\n|\n| H\n| Returns the (complex) conjugate transpose of `self`.\n|\n| Equivalent to ``np.transpose(self)`` if `self` is real-valued.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : matrix object\n| complex conjugate transpose of `self`\n|\n| Examples\n| --------\n| >>> x = np.matrix(np.arange(12).reshape((3,4)))\n| >>> z = x - 1j*x; z\n| matrix([[ 0. +0.j, 1. -1.j, 2. -2.j, 3. -3.j],\n| [ 4. -4.j, 5. -5.j, 6. -6.j, 7. -7.j],\n| [ 8. -8.j, 9. -9.j, 10.-10.j, 11.-11.j]])\n| >>> z.getH()\n| matrix([[ 0. -0.j, 4. +4.j, 8. +8.j],\n| [ 1. +1.j, 5. +5.j, 9. +9.j],\n| [ 2. +2.j, 6. +6.j, 10.+10.j],\n| [ 3. +3.j, 7. +7.j, 11.+11.j]])\n|\n| I\n| Returns the (multiplicative) inverse of invertible `self`.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : matrix object\n| If `self` is non-singular, `ret` is such that ``ret * self`` ==\n| ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return\n| ``True``.\n|\n| Raises\n| ------\n| numpy.linalg.LinAlgError: Singular matrix\n| If `self` is singular.\n|\n| See Also\n| --------\n| linalg.inv\n|\n| Examples\n| --------\n| >>> m = np.matrix('[1, 2; 3, 4]'); m\n| matrix([[1, 2],\n| [3, 4]])\n| >>> m.getI()\n| matrix([[-2. , 1. ],\n| [ 1.5, -0.5]])\n| >>> m.getI() * m\n| matrix([[ 1., 0.], # may vary\n| [ 0., 1.]])\n|\n| T\n| Returns the transpose of the matrix.\n|\n| Does *not* conjugate! For the complex conjugate transpose, use ``.H``.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| ret : matrix object\n| The (non-conjugated) transpose of the matrix.\n|\n| See Also\n| --------\n| transpose, getH\n|\n| Examples\n| --------\n| >>> m = np.matrix('[1, 2; 3, 4]')\n| >>> m\n| matrix([[1, 2],\n| [3, 4]])\n| >>> m.getT()\n| matrix([[1, 3],\n| [2, 4]])\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| annotations = {}\n|\n| arraypriority = 10.0\n|\n| ----------------------------------------------------------------------\n| Methods inherited from ndarray:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| a.array([dtype], /) -> reference if type unchanged, copy otherwise.\n|\n| Returns either a new reference to self if dtype is not given or a new array\n| of provided data type if dtype is different from the current dtype of the\n| array.\n|\n| arrayfunction(...)\n|\n| arrayprepare(...)\n| a.arrayprepare(obj) -> Object of same type as ndarray object obj.\n|\n| arrayufunc(...)\n|\n| arraywrap(...)\n| a.arraywrap(obj) -> Object of same type as ndarray object a.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| copy(...)\n| a.copy()\n|\n| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.\n|\n| Equivalent to ``a.copy(order='K')``.\n|\n| deepcopy(...)\n| a.deepcopy(memo, /) -> Deep copy of array.\n|\n| Used if :func:`copy.deepcopy` is called on an array.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| Default object formatter.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| iadd(self, value, /)\n| Return self+=value.\n|\n| iand(self, value, /)\n| Return self&=value.\n|\n| ifloordiv(self, value, /)\n| Return self//=value.\n|\n| ilshift(self, value, /)\n| Return self<<=value.\n|\n| imatmul(self, value, /)\n| Return self@=value.\n|\n| imod(self, value, /)\n| Return self%=value.\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| irshift(self, value, /)\n| Return self>>=value.\n|\n| isub(self, value, /)\n| Return self-=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| itruediv(self, value, /)\n| Return self/=value.\n|\n| ixor(self, value, /)\n| Return self^=value.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setitem(self, key, value, /)\n| Set self[key] to value.\n|\n| setstate(...)\n| a.setstate(state, /)\n|\n| For unpickling.\n|\n| The `state` argument must be a sequence that contains the following\n| elements:\n|\n| Parameters\n| ----------\n| version : int\n| optional pickle version. If omitted defaults to 0.\n| shape : tuple\n| dtype : data-type\n| isFortran : bool\n| rawdata : string or list\n| a binary string with the data (or a list if 'a' is an object array)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| argpartition(...)\n| a.argpartition(kth, axis=-1, kind='introselect', order=None)\n|\n| Returns the indices that would partition this array.\n|\n| Refer to `numpy.argpartition` for full documentation.\n|\n| .. versionadded:: 1.8.0\n|\n| See Also\n| --------\n| numpy.argpartition : equivalent function\n|\n| argsort(...)\n| a.argsort(axis=-1, kind=None, order=None)\n|\n| Returns the indices that would sort this array.\n|\n| Refer to `numpy.argsort` for full documentation.\n|\n| See Also\n| --------\n| numpy.argsort : equivalent function\n|\n| astype(...)\n| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)\n|\n| Copy of the array, cast to a specified type.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| Typecode or data-type to which the array is cast.\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout order of the result.\n| 'C' means C order, 'F' means Fortran order, 'A'\n| means 'F' order if all the arrays are Fortran contiguous,\n| 'C' order otherwise, and 'K' means as close to the\n| order the array elements appear in memory as possible.\n| Default is 'K'.\n| casting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\n| Controls what kind of data casting may occur. Defaults to 'unsafe'\n| for backwards compatibility.\n|\n| * 'no' means the data types should not be cast at all.\n| * 'equiv' means only byte-order changes are allowed.\n| * 'safe' means only casts which can preserve values are allowed.\n| * 'samekind' means only safe casts or casts within a kind,\n| like float64 to float32, are allowed.\n| * 'unsafe' means any data conversions may be done.\n| subok : bool, optional\n| If True, then sub-classes will be passed-through (default), otherwise\n| the returned array will be forced to be a base-class array.\n| copy : bool, optional\n| By default, astype always returns a newly allocated array. If this\n| is set to false, and the `dtype`, `order`, and `subok`\n| requirements are satisfied, the input array is returned instead\n| of a copy.\n|\n| Returns\n| -------\n| arrt : ndarray\n| Unless `copy` is False and the other conditions for returning the input\n| array are satisfied (see description for `copy` input parameter), `arrt`\n| is a new array of the same shape as the input array, with dtype, order\n| given by `dtype`, `order`.\n|\n| Notes\n| -----\n| .. versionchanged:: 1.17.0\n| Casting between a simple data type and a structured one is possible only\n| for \"unsafe\" casting. Casting to multiple fields is allowed, but\n| casting from multiple fields is not.\n|\n| .. versionchanged:: 1.9.0\n| Casting from numeric to string types in 'safe' casting mode requires\n| that the string dtype length is long enough to store the max\n| integer/float value converted.\n|\n| Raises\n| ------\n| ComplexWarning\n| When casting from complex to float or int. To avoid this,\n| one should use ``a.real.astype(t)``.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 2.5])\n| >>> x\n| array([1. , 2. , 2.5])\n|\n| >>> x.astype(int)\n| array([1, 2, 2])\n|\n| byteswap(...)\n| a.byteswap(inplace=False)\n|\n| Swap the bytes of the array elements\n|\n| Toggle between low-endian and big-endian data representation by\n| returning a byteswapped array, optionally swapped in-place.\n| Arrays of byte-strings are not swapped. The real and imaginary\n| parts of a complex number are swapped individually.\n|\n| Parameters\n| ----------\n| inplace : bool, optional\n| If ``True``, swap bytes in-place, default is ``False``.\n|\n| Returns\n| -------\n| out : ndarray\n| The byteswapped array. If `inplace` is ``True``, this is\n| a view to self.\n|\n| Examples\n| --------\n| >>> A = np.array([1, 256, 8755], dtype=np.int16)\n| >>> list(map(hex, A))\n| ['0x1', '0x100', '0x2233']\n| >>> A.byteswap(inplace=True)\n| array([ 256, 1, 13090], dtype=int16)\n| >>> list(map(hex, A))\n| ['0x100', '0x1', '0x3322']\n|\n| Arrays of byte-strings are not swapped\n|\n| >>> A = np.array([b'ceg', b'fac'])\n| >>> A.byteswap()\n| array([b'ceg', b'fac'], dtype='|S3')\n|\n| ``A.newbyteorder().byteswap()`` produces an array with the same values\n| but different representation in memory\n|\n| >>> A = np.array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,\n| 0, 0], dtype=uint8)\n| >>> A.newbyteorder().byteswap(inplace=True)\n| array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,\n| 0, 3], dtype=uint8)\n|\n| choose(...)\n| a.choose(choices, out=None, mode='raise')\n|\n| Use an index array to construct a new array from a set of choices.\n|\n| Refer to `numpy.choose` for full documentation.\n|\n| See Also\n| --------\n| numpy.choose : equivalent function\n|\n| clip(...)\n| a.clip(min=None, max=None, out=None, kwargs)\n|\n| Return an array whose values are limited to ``[min, max]``.\n| One of max or min must be given.\n|\n| Refer to `numpy.clip` for full documentation.\n|\n| See Also\n| --------\n| numpy.clip : equivalent function\n|\n| compress(...)\n| a.compress(condition, axis=None, out=None)\n|\n| Return selected slices of this array along given axis.\n|\n| Refer to `numpy.compress` for full documentation.\n|\n| See Also\n| --------\n| numpy.compress : equivalent function\n|\n| conj(...)\n| a.conj()\n|\n| Complex-conjugate all elements.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| conjugate(...)\n| a.conjugate()\n|\n| Return the complex conjugate, element-wise.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| copy(...)\n| a.copy(order='C')\n|\n| Return a copy of the array.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout of the copy. 'C' means C-order,\n| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n| 'C' otherwise. 'K' means match the layout of `a` as closely\n| as possible. (Note that this function and :func:`numpy.copy` are very\n| similar but have different default values for their order=\n| arguments, and this function always passes sub-classes through.)\n|\n| See also\n| --------\n| numpy.copy : Similar function with different default behavior\n| numpy.copyto\n|\n| Notes\n| -----\n| This function is the preferred method for creating an array copy. The\n| function :func:`numpy.copy` is similar, but it defaults to using order 'K',\n| and will not pass sub-classes through by default.\n|\n| Examples\n| --------\n| >>> x = np.array([[1,2,3],[4,5,6]], order='F')\n|\n| >>> y = x.copy()\n|\n| >>> x.fill(0)\n|\n| >>> x\n| array([[0, 0, 0],\n| [0, 0, 0]])\n|\n| >>> y\n| array([[1, 2, 3],\n| [4, 5, 6]])\n|\n| >>> y.flags['CCONTIGUOUS']\n| True\n|\n| cumprod(...)\n| a.cumprod(axis=None, dtype=None, out=None)\n|\n| Return the cumulative product of the elements along the given axis.\n|\n| Refer to `numpy.cumprod` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumprod : equivalent function\n|\n| cumsum(...)\n| a.cumsum(axis=None, dtype=None, out=None)\n|\n| Return the cumulative sum of the elements along the given axis.\n|\n| Refer to `numpy.cumsum` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumsum : equivalent function\n|\n| diagonal(...)\n| a.diagonal(offset=0, axis1=0, axis2=1)\n|\n| Return specified diagonals. In NumPy 1.9 the returned array is a\n| read-only view instead of a copy as in previous NumPy versions. In\n| a future version the read-only restriction will be removed.\n|\n| Refer to :func:`numpy.diagonal` for full documentation.\n|\n| See Also\n| --------\n| numpy.diagonal : equivalent function\n|\n| dot(...)\n| a.dot(b, out=None)\n|\n| Dot product of two arrays.\n|\n| Refer to `numpy.dot` for full documentation.\n|\n| See Also\n| --------\n| numpy.dot : equivalent function\n|\n| Examples\n| --------\n| >>> a = np.eye(2)\n| >>> b = np.ones((2, 2)) * 2\n| >>> a.dot(b)\n| array([[2., 2.],\n| [2., 2.]])\n|\n| This array method can be conveniently chained:\n|\n| >>> a.dot(b).dot(b)\n| array([[8., 8.],\n| [8., 8.]])\n|\n| dump(...)\n| a.dump(file)\n|\n| Dump a pickle of the array to the specified file.\n| The array can be read back with pickle.load or numpy.load.\n|\n| Parameters\n| ----------\n| file : str or Path\n| A string naming the dump file.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| dumps(...)\n| a.dumps()\n|\n| Returns the pickle of the array as a string.\n| pickle.loads or numpy.loads will convert the string back to an array.\n|\n| Parameters\n| ----------\n| None\n|\n| fill(...)\n| a.fill(value)\n|\n| Fill the array with a scalar value.\n|\n| Parameters\n| ----------\n| value : scalar\n| All elements of `a` will be assigned this value.\n|\n| Examples\n| --------\n| >>> a = np.array([1, 2])\n| >>> a.fill(0)\n| >>> a\n| array([0, 0])\n| >>> a = np.empty(2)\n| >>> a.fill(1)\n| >>> a\n| array([1., 1.])\n|\n| getfield(...)\n| a.getfield(dtype, offset=0)\n|\n| Returns a field of the given array as a certain type.\n|\n| A field is a view of the array data with a given data-type. The values in\n| the view are determined by the given type and the offset into the current\n| array in bytes. The offset needs to be such that the view dtype fits in the\n| array dtype; for example an array of dtype complex128 has 16-byte elements.\n| If taking a view with a 32-bit integer (4 bytes), the offset needs to be\n| between 0 and 12 bytes.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| The data type of the view. The dtype size of the view can not be larger\n| than that of the array itself.\n| offset : int\n| Number of bytes to skip before beginning the element view.\n|\n| Examples\n| --------\n| >>> x = np.diag([1.+1.j]*2)\n| >>> x[1, 1] = 2 + 4.j\n| >>> x\n| array([[1.+1.j, 0.+0.j],\n| [0.+0.j, 2.+4.j]])\n| >>> x.getfield(np.float64)\n| array([[1., 0.],\n| [0., 2.]])\n|\n| By choosing an offset of 8 bytes we can select the complex part of the\n| array for our view:\n|\n| >>> x.getfield(np.float64, offset=8)\n| array([[1., 0.],\n| [0., 4.]])\n|\n| item(...)\n| a.item(*args)\n|\n| Copy an element of an array to a standard Python scalar and return it.\n|\n| Parameters\n| ----------\n| \\*args : Arguments (variable number and type)\n|\n| * none: in this case, the method only works for arrays\n| with one element (`a.size == 1`), which element is\n| copied into a standard Python scalar object and returned.\n|\n| * inttype: this argument is interpreted as a flat index into\n| the array, specifying which element to copy and return.\n|\n| * tuple of inttypes: functions as does a single inttype argument,\n| except that the argument is interpreted as an nd-index into the\n| array.\n|\n| Returns\n| -------\n| z : Standard Python scalar object\n| A copy of the specified element of the array as a suitable\n| Python scalar\n|\n| Notes\n| -----\n| When the data type of `a` is longdouble or clongdouble, item() returns\n| a scalar array object because there is no available Python scalar that\n| would not lose information. Void arrays return a buffer object for item(),\n| unless fields are defined, in which case a tuple is returned.\n|\n| `item` is very similar to a[args], except, instead of an array scalar,\n| a standard Python scalar is returned. This can be useful for speeding up\n| access to elements of the array and doing arithmetic on elements of the\n| array using Python's optimized math.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.item(3)\n| 1\n| >>> x.item(7)\n| 0\n| >>> x.item((0, 1))\n| 2\n| >>> x.item((2, 2))\n| 1\n|\n| itemset(...)\n| a.itemset(*args)\n|\n| Insert scalar into an array (scalar is cast to array's dtype, if possible)\n|\n| There must be at least 1 argument, and define the last argument\n| as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster\n| than ``a[args] = item``. The item should be a scalar value and `args`\n| must select a single item in the array `a`.\n|\n| Parameters\n| ----------\n| \\*args : Arguments\n| If one argument: a scalar, only used in case `a` is of size 1.\n| If two arguments: the last argument is the value to be set\n| and must be a scalar, the first argument specifies a single array\n| element location. It is either an int or a tuple.\n|\n| Notes\n| -----\n| Compared to indexing syntax, `itemset` provides some speed increase\n| for placing a scalar into a particular location in an `ndarray`,\n| if you must do this. However, generally this is discouraged:\n| among other problems, it complicates the appearance of the code.\n| Also, when using `itemset` (and `item`) inside a loop, be sure\n| to assign the methods to a local variable to avoid the attribute\n| look-up at each loop iteration.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.itemset(4, 0)\n| >>> x.itemset((2, 2), 9)\n| >>> x\n| array([[2, 2, 6],\n| [1, 0, 6],\n| [1, 0, 9]])\n|\n| newbyteorder(...)\n| arr.newbyteorder(neworder='S', /)\n|\n| Return the array with the same data viewed with a different byte order.\n|\n| Equivalent to::\n|\n| arr.view(arr.dtype.newbytorder(neworder))\n|\n| Changes are also made in all fields and sub-arrays of the array data\n| type.\n|\n|\n|\n| Parameters\n| ----------\n| neworder : string, optional\n| Byte order to force; a value from the byte order specifications\n| below. `neworder` codes can be any of:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order, equivalent to `sys.byteorder`\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newarr : array\n| New array object with the dtype reflecting given change to the\n| byte order.\n|\n| nonzero(...)\n| a.nonzero()\n|\n| Return the indices of the elements that are non-zero.\n|\n| Refer to `numpy.nonzero` for full documentation.\n|\n| See Also\n| --------\n| numpy.nonzero : equivalent function\n|\n| partition(...)\n| a.partition(kth, axis=-1, kind='introselect', order=None)\n|\n| Rearranges the elements in the array in such a way that the value of the\n| element in kth position is in the position it would be in a sorted array.\n| All elements smaller than the kth element are moved before this element and\n| all equal or greater are moved behind it. The ordering of the elements in\n| the two partitions is undefined.\n|\n| .. versionadded:: 1.8.0\n|\n| Parameters\n| ----------\n| kth : int or sequence of ints\n| Element index to partition by. The kth element value will be in its\n| final sorted position and all smaller elements will be moved before it\n| and all equal or greater elements behind it.\n| The order of all elements in the partitions is undefined.\n| If provided with a sequence of kth it will partition all elements\n| indexed by kth of them into their sorted position at once.\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'introselect'}, optional\n| Selection algorithm. Default is 'introselect'.\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need to be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.partition : Return a parititioned copy of an array.\n| argpartition : Indirect partition.\n| sort : Full sort.\n|\n| Notes\n| -----\n| See ``np.partition`` for notes on the different algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([3, 4, 2, 1])\n| >>> a.partition(3)\n| >>> a\n| array([2, 1, 3, 4])\n|\n| >>> a.partition((1, 3))\n| >>> a\n| array([1, 2, 3, 4])\n|\n| put(...)\n| a.put(indices, values, mode='raise')\n|\n| Set ``a.flat[n] = values[n]`` for all `n` in indices.\n|\n| Refer to `numpy.put` for full documentation.\n|\n| See Also\n| --------\n| numpy.put : equivalent function\n|\n| repeat(...)\n| a.repeat(repeats, axis=None)\n|\n| Repeat elements of an array.\n|\n| Refer to `numpy.repeat` for full documentation.\n|\n| See Also\n| --------\n| numpy.repeat : equivalent function\n|\n| reshape(...)\n| a.reshape(shape, order='C')\n|\n| Returns an array containing the same data with a new shape.\n|\n| Refer to `numpy.reshape` for full documentation.\n|\n| See Also\n| --------\n| numpy.reshape : equivalent function\n|\n| Notes\n| -----\n| Unlike the free function `numpy.reshape`, this method on `ndarray` allows\n| the elements of the shape parameter to be passed in as separate arguments.\n| For example, ``a.reshape(10, 11)`` is equivalent to\n| ``a.reshape((10, 11))``.\n|\n| resize(...)\n| a.resize(newshape, refcheck=True)\n|\n| Change shape and size of array in-place.\n|\n| Parameters\n| ----------\n| newshape : tuple of ints, or `n` ints\n| Shape of resized array.\n| refcheck : bool, optional\n| If False, reference count will not be checked. Default is True.\n|\n| Returns\n| -------\n| None\n|\n| Raises\n| ------\n| ValueError\n| If `a` does not own its own data or references or views to it exist,\n| and the data memory must be changed.\n| PyPy only: will always raise if the data memory must be changed, since\n| there is no reliable way to determine if references or views to it\n| exist.\n|\n| SystemError\n| If the `order` keyword argument is specified. This behaviour is a\n| bug in NumPy.\n|\n| See Also\n| --------\n| resize : Return a new array with the specified shape.\n|\n| Notes\n| -----\n| This reallocates space for the data area if necessary.\n|\n| Only contiguous arrays (data elements consecutive in memory) can be\n| resized.\n|\n| The purpose of the reference count check is to make sure you\n| do not use this array as a buffer for another Python object and then\n| reallocate the memory. However, reference counts can increase in\n| other ways so if you are sure that you have not shared the memory\n| for this array with another Python object, then you may safely set\n| `refcheck` to False.\n|\n| Examples\n| --------\n| Shrinking an array: array is flattened (in the order that the data are\n| stored in memory), resized, and reshaped:\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='C')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [1]])\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='F')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [2]])\n|\n| Enlarging an array: as above, but missing entries are filled with zeros:\n|\n| >>> b = np.array([[0, 1], [2, 3]])\n| >>> b.resize(2, 3) # newshape parameter doesn't have to be a tuple\n| >>> b\n| array([[0, 1, 2],\n| [3, 0, 0]])\n|\n| Referencing an array prevents resizing...\n|\n| >>> c = a\n| >>> a.resize((1, 1))\n| Traceback (most recent call last):\n| ...\n| ValueError: cannot resize an array that references or is referenced ...\n|\n| Unless `refcheck` is False:\n|\n| >>> a.resize((1, 1), refcheck=False)\n| >>> a\n| array([[0]])\n| >>> c\n| array([[0]])\n|\n| round(...)\n| a.round(decimals=0, out=None)\n|\n| Return `a` with each element rounded to the given number of decimals.\n|\n| Refer to `numpy.around` for full documentation.\n|\n| See Also\n| --------\n| numpy.around : equivalent function\n|\n| searchsorted(...)\n| a.searchsorted(v, side='left', sorter=None)\n|\n| Find indices where elements of v should be inserted in a to maintain order.\n|\n| For full documentation, see `numpy.searchsorted`\n|\n| See Also\n| --------\n| numpy.searchsorted : equivalent function\n|\n| setfield(...)\n| a.setfield(val, dtype, offset=0)\n|\n| Put a value into a specified place in a field defined by a data-type.\n|\n| Place `val` into `a`'s field defined by `dtype` and beginning `offset`\n| bytes into the field.\n|\n| Parameters\n| ----------\n| val : object\n| Value to be placed in field.\n| dtype : dtype object\n| Data-type of the field in which to place `val`.\n| offset : int, optional\n| The number of bytes into the field at which to place `val`.\n|\n| Returns\n| -------\n| None\n|\n| See Also\n| --------\n| getfield\n|\n| Examples\n| --------\n| >>> x = np.eye(3)\n| >>> x.getfield(np.float64)\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n| >>> x.setfield(3, np.int32)\n| >>> x.getfield(np.int32)\n| array([[3, 3, 3],\n| [3, 3, 3],\n| [3, 3, 3]], dtype=int32)\n| >>> x\n| array([[1.0e+000, 1.5e-323, 1.5e-323],\n| [1.5e-323, 1.0e+000, 1.5e-323],\n| [1.5e-323, 1.5e-323, 1.0e+000]])\n| >>> x.setfield(np.eye(3), np.int32)\n| >>> x\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n|\n| setflags(...)\n| a.setflags(write=None, align=None, uic=None)\n|\n| Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),\n| respectively.\n|\n| These Boolean-valued flags affect how numpy interprets the memory\n| area used by `a` (see Notes below). The ALIGNED flag can only\n| be set to True if the data is actually aligned according to the type.\n| The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set\n| to True. The flag WRITEABLE can only be set to True if the array owns its\n| own memory, or the ultimate owner of the memory exposes a writeable buffer\n| interface, or is a string. (The exception for string is made so that\n| unpickling can be done without copying memory.)\n|\n| Parameters\n| ----------\n| write : bool, optional\n| Describes whether or not `a` can be written to.\n| align : bool, optional\n| Describes whether or not `a` is aligned properly for its type.\n| uic : bool, optional\n| Describes whether or not `a` is a copy of another \"base\" array.\n|\n| Notes\n| -----\n| Array flags provide information about how the memory area used\n| for the array is to be interpreted. There are 7 Boolean flags\n| in use, only four of which can be changed by the user:\n| WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.\n|\n| WRITEABLE (W) the data area can be written to;\n|\n| ALIGNED (A) the data and strides are aligned appropriately for the hardware\n| (as determined by the compiler);\n|\n| UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;\n|\n| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced\n| by .base). When the C-API function PyArrayResolveWritebackIfCopy is\n| called, the base array will be updated with the contents of this array.\n|\n| All flags can be accessed using the single (upper case) letter as well\n| as the full name.\n|\n| Examples\n| --------\n| >>> y = np.array([[3, 1, 7],\n| ... [2, 0, 0],\n| ... [8, 5, 9]])\n| >>> y\n| array([[3, 1, 7],\n| [2, 0, 0],\n| [8, 5, 9]])\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : True\n| ALIGNED : True\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(write=0, align=0)\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : False\n| ALIGNED : False\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(uic=1)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: cannot set WRITEBACKIFCOPY flag to True\n|\n| sort(...)\n| a.sort(axis=-1, kind=None, order=None)\n|\n| Sort an array in-place. Refer to `numpy.sort` for full documentation.\n|\n| Parameters\n| ----------\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'\n| and 'mergesort' use timsort under the covers and, in general, the\n| actual implementation will vary with datatype. The 'mergesort' option\n| is retained for backwards compatibility.\n|\n| .. versionchanged:: 1.15.0\n| The 'stable' option was added.\n|\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.sort : Return a sorted copy of an array.\n| numpy.argsort : Indirect sort.\n| numpy.lexsort : Indirect stable sort on multiple keys.\n| numpy.searchsorted : Find elements in sorted array.\n| numpy.partition: Partial sort.\n|\n| Notes\n| -----\n| See `numpy.sort` for notes on the different sorting algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,4], [3,1]])\n| >>> a.sort(axis=1)\n| >>> a\n| array([[1, 4],\n| [1, 3]])\n| >>> a.sort(axis=0)\n| >>> a\n| array([[1, 3],\n| [1, 4]])\n|\n| Use the `order` keyword to specify a field to use when sorting a\n| structured array:\n|\n| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])\n| >>> a.sort(order='y')\n| >>> a\n| array([(b'c', 1), (b'a', 2)],\n| dtype=[('x', 'S1'), ('y', '>> x = np.array([[0, 1], [2, 3]], dtype='>> x.tobytes()\n| b'\\x00\\x00\\x01\\x00\\x02\\x00\\x03\\x00'\n| >>> x.tobytes('C') == x.tobytes()\n| True\n| >>> x.tobytes('F')\n| b'\\x00\\x00\\x02\\x00\\x01\\x00\\x03\\x00'\n|\n| tofile(...)\n| a.tofile(fid, sep=\"\", format=\"%s\")\n|\n| Write array to a file as text or binary (default).\n|\n| Data is always written in 'C' order, independent of the order of `a`.\n| The data produced by this method can be recovered using the function\n| fromfile().\n|\n| Parameters\n| ----------\n| fid : file or str or Path\n| An open file object, or a string containing a filename.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| sep : str\n| Separator between array items for text output.\n| If \"\" (empty), a binary file is written, equivalent to\n| ``file.write(a.tobytes())``.\n| format : str\n| Format string for text file output.\n| Each entry in the array is formatted to text by first converting\n| it to the closest Python type, and then using \"format\" % item.\n|\n| Notes\n| -----\n| This is a convenience function for quick storage of array data.\n| Information on endianness and precision is lost, so this method is not a\n| good choice for files intended to archive data or transport data between\n| machines with different endianness. Some of these problems can be overcome\n| by outputting the data as text files, at the expense of speed and file\n| size.\n|\n| When fid is a file object, array contents are directly written to the\n| file, bypassing the file object's ``write`` method. As a result, tofile\n| cannot be used with files objects supporting compression (e.g., GzipFile)\n| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).\n|\n| tostring(...)\n| a.tostring(order='C')\n|\n| A compatibility alias for `tobytes`, with exactly the same behavior.\n|\n| Despite its name, it returns `bytes` not `str`\\ s.\n|\n| .. deprecated:: 1.19.0\n|\n| trace(...)\n| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n|\n| Return the sum along diagonals of the array.\n|\n| Refer to `numpy.trace` for full documentation.\n|\n| See Also\n| --------\n| numpy.trace : equivalent function\n|\n| transpose(...)\n| a.transpose(*axes)\n|\n| Returns a view of the array with axes transposed.\n|\n| For a 1-D array this has no effect, as a transposed vector is simply the\n| same vector. To convert a 1-D array into a 2D column vector, an additional\n| dimension must be added. `np.atleast2d(a).T` achieves this, as does\n| `a[:, np.newaxis]`.\n| For a 2-D array, this is a standard matrix transpose.\n| For an n-D array, if axes are given, their order indicates how the\n| axes are permuted (see Examples). If axes are not provided and\n| ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then\n| ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.\n|\n| Parameters\n| ----------\n| axes : None, tuple of ints, or `n` ints\n|\n| * None or no argument: reverses the order of the axes.\n|\n| * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s\n| `i`-th axis becomes `a.transpose()`'s `j`-th axis.\n|\n| * `n` ints: same as an n-tuple of the same ints (this form is\n| intended simply as a \"convenience\" alternative to the tuple form)\n|\n| Returns\n| -------\n| out : ndarray\n| View of `a`, with axes suitably permuted.\n|\n| See Also\n| --------\n| transpose : Equivalent function\n| ndarray.T : Array property returning the array transposed.\n| ndarray.reshape : Give a new shape to an array without changing its data.\n|\n| Examples\n| --------\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> a\n| array([[1, 2],\n| [3, 4]])\n| >>> a.transpose()\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose((1, 0))\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose(1, 0)\n| array([[1, 3],\n| [2, 4]])\n|\n| view(...)\n| a.view([dtype][, type])\n|\n| New view of array with the same data.\n|\n| .. note::\n| Passing None for ``dtype`` is different from omitting the parameter,\n| since the former invokes ``dtype(None)`` which is an alias for\n| ``dtype('float')``.\n|\n| Parameters\n| ----------\n| dtype : data-type or ndarray sub-class, optional\n| Data-type descriptor of the returned view, e.g., float32 or int16.\n| Omitting it results in the view having the same data-type as `a`.\n| This argument can also be specified as an ndarray sub-class, which\n| then specifies the type of the returned object (this is equivalent to\n| setting the ``type`` parameter).\n| type : Python type, optional\n| Type of the returned view, e.g., ndarray or matrix. Again, omission\n| of the parameter results in type preservation.\n|\n| Notes\n| -----\n| ``a.view()`` is used two different ways:\n|\n| ``a.view(somedtype)`` or ``a.view(dtype=somedtype)`` constructs a view\n| of the array's memory with a different data-type. This can cause a\n| reinterpretation of the bytes of memory.\n|\n| ``a.view(ndarraysubclass)`` or ``a.view(type=ndarraysubclass)`` just\n| returns an instance of `ndarraysubclass` that looks at the same array\n| (same shape, dtype, etc.) This does not cause a reinterpretation of the\n| memory.\n|\n| For ``a.view(somedtype)``, if ``somedtype`` has a different number of\n| bytes per entry than the previous dtype (for example, converting a\n| regular array to a structured array), then the behavior of the view\n| cannot be predicted just from the superficial appearance of ``a`` (shown\n| by ``print(a)``). It also depends on exactly how ``a`` is stored in\n| memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus\n| defined as a slice or transpose, etc., the view may give different\n| results.\n|\n|\n| Examples\n| --------\n| >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])\n|\n| Viewing array data using a different type and dtype:\n|\n| >>> y = x.view(dtype=np.int16, type=np.matrix)\n| >>> y\n| matrix([[513]], dtype=int16)\n| >>> print(type(y))\n| \n|\n| Creating a view on a structured array so it can be used in calculations\n|\n| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])\n| >>> xv = x.view(dtype=np.int8).reshape(-1,2)\n| >>> xv\n| array([[1, 2],\n| [3, 4]], dtype=int8)\n| >>> xv.mean(0)\n| array([2., 3.])\n|\n| Making changes to the view changes the underlying array\n|\n| >>> xv[0,1] = 20\n| >>> x\n| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])\n|\n| Using a view to convert an array to a recarray:\n|\n| >>> z = x.view(np.recarray)\n| >>> z.a\n| array([1, 3], dtype=int8)\n|\n| Views share data:\n|\n| >>> x[0] = (9, 10)\n| >>> z[0]\n| (9, 10)\n|\n| Views that change the dtype size (bytes per entry) should normally be\n| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:\n|\n| >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)\n| >>> y = x[:, 0:2]\n| >>> y\n| array([[1, 2],\n| [4, 5]], dtype=int16)\n| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])\n| Traceback (most recent call last):\n| ...\n| ValueError: To change to a dtype of a different size, the array must be C-contiguous\n| >>> z = y.copy()\n| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])\n| array([[(1, 2)],\n| [(4, 5)]], dtype=[('width', '>> x = np.array([1,2,3,4])\n| >>> x.base is None\n| True\n|\n| Slicing creates a view, whose memory is shared with x:\n|\n| >>> y = x[2:]\n| >>> y.base is x\n| True\n|\n| ctypes\n| An object to simplify the interaction of the array with the ctypes\n| module.\n|\n| This attribute creates an object that makes it easier to use arrays\n| when calling shared libraries with the ctypes module. The returned\n| object has, among others, data, shape, and strides attributes (see\n| Notes below) which themselves return ctypes objects that can be used\n| as arguments to a shared library.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| c : Python object\n| Possessing attributes data, shape, strides, etc.\n|\n| See Also\n| --------\n| numpy.ctypeslib\n|\n| Notes\n| -----\n| Below are the public attributes of this object which were documented\n| in \"Guide to NumPy\" (we have omitted undocumented public attributes,\n| as well as documented private attributes):\n|\n| .. autoattribute:: numpy.core.internal.ctypes.data\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.shape\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.strides\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.dataas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.shapeas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.stridesas\n| :noindex:\n|\n| If the ctypes module is not available, then the ctypes attribute\n| of array objects still returns something useful, but ctypes objects\n| are not returned and errors may be raised instead. In particular,\n| the object will still have the ``asparameter`` attribute which will\n| return an integer equal to the data attribute.\n|\n| Examples\n| --------\n| >>> import ctypes\n| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)\n| >>> x\n| array([[0, 1],\n| [2, 3]], dtype=int32)\n| >>> x.ctypes.data\n| 31962608 # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32))\n| # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32)).contents\n| cuint(0)\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint64)).contents\n| culong(4294967296)\n| >>> x.ctypes.shape\n| # may vary\n| >>> x.ctypes.strides\n| # may vary\n|\n| data\n| Python buffer object pointing to the start of the array's data.\n|\n| dtype\n| Data-type of the array's elements.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| d : numpy dtype object\n|\n| See Also\n| --------\n| numpy.dtype\n|\n| Examples\n| --------\n| >>> x\n| array([[0, 1],\n| [2, 3]])\n| >>> x.dtype\n| dtype('int32')\n| >>> type(x.dtype)\n| \n|\n| flags\n| Information about the memory layout of the array.\n|\n| Attributes\n| ----------\n| CCONTIGUOUS (C)\n| The data is in a single, C-style contiguous segment.\n| FCONTIGUOUS (F)\n| The data is in a single, Fortran-style contiguous segment.\n| OWNDATA (O)\n| The array owns the memory it uses or borrows it from another object.\n| WRITEABLE (W)\n| The data area can be written to. Setting this to False locks\n| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE\n| from its base array at creation time, but a view of a writeable\n| array may be subsequently locked while the base array remains writeable.\n| (The opposite is not true, in that a view of a locked array may not\n| be made writeable. However, currently, locking a base object does not\n| lock any views that already reference it, so under that circumstance it\n| is possible to alter the contents of a locked array via a previously\n| created writeable view onto it.) Attempting to change a non-writeable\n| array raises a RuntimeError exception.\n| ALIGNED (A)\n| The data and all elements are aligned appropriately for the hardware.\n| WRITEBACKIFCOPY (X)\n| This array is a copy of some other array. The C-API function\n| PyArrayResolveWritebackIfCopy must be called before deallocating\n| to the base array will be updated with the contents of this array.\n| UPDATEIFCOPY (U)\n| (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.\n| When this array is\n| deallocated, the base array will be updated with the contents of\n| this array.\n| FNC\n| FCONTIGUOUS and not CCONTIGUOUS.\n| FORC\n| FCONTIGUOUS or CCONTIGUOUS (one-segment test).\n| BEHAVED (B)\n| ALIGNED and WRITEABLE.\n| CARRAY (CA)\n| BEHAVED and CCONTIGUOUS.\n| FARRAY (FA)\n| BEHAVED and FCONTIGUOUS and not CCONTIGUOUS.\n|\n| Notes\n| -----\n| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),\n| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag\n| names are only supported in dictionary access.\n|\n| Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be\n| changed by the user, via direct assignment to the attribute or dictionary\n| entry, or by calling `ndarray.setflags`.\n|\n| The array flags cannot be set arbitrarily:\n|\n| - UPDATEIFCOPY can only be set ``False``.\n| - WRITEBACKIFCOPY can only be set ``False``.\n| - ALIGNED can only be set ``True`` if the data is truly aligned.\n| - WRITEABLE can only be set ``True`` if the array owns its own memory\n| or the ultimate owner of the memory exposes a writeable buffer\n| interface or is a string.\n|\n| Arrays can be both C-style and Fortran-style contiguous simultaneously.\n| This is clear for 1-dimensional arrays, but can also be true for higher\n| dimensional arrays.\n|\n| Even for contiguous arrays a stride for a given dimension\n| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``\n| or the array has no elements.\n| It does *not* generally hold that ``self.strides[-1] == self.itemsize``\n| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for\n| Fortran-style contiguous arrays is true.\n|\n| flat\n| A 1-D iterator over the array.\n|\n| This is a `numpy.flatiter` instance, which acts similarly to, but is not\n| a subclass of, Python's built-in iterator object.\n|\n| See Also\n| --------\n| flatten : Return a copy of the array collapsed into one dimension.\n|\n| flatiter\n|\n| Examples\n| --------\n| >>> x = np.arange(1, 7).reshape(2, 3)\n| >>> x\n| array([[1, 2, 3],\n| [4, 5, 6]])\n| >>> x.flat[3]\n| 4\n| >>> x.T\n| array([[1, 4],\n| [2, 5],\n| [3, 6]])\n| >>> x.T.flat[3]\n| 5\n| >>> type(x.flat)\n| \n|\n| An assignment example:\n|\n| >>> x.flat = 3; x\n| array([[3, 3, 3],\n| [3, 3, 3]])\n| >>> x.flat[[1,4]] = 1; x\n| array([[3, 1, 3],\n| [3, 1, 3]])\n|\n| imag\n| The imaginary part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.imag\n| array([ 0. , 0.70710678])\n| >>> x.imag.dtype\n| dtype('float64')\n|\n| itemsize\n| Length of one array element in bytes.\n|\n| Examples\n| --------\n| >>> x = np.array([1,2,3], dtype=np.float64)\n| >>> x.itemsize\n| 8\n| >>> x = np.array([1,2,3], dtype=np.complex128)\n| >>> x.itemsize\n| 16\n|\n| nbytes\n| Total bytes consumed by the elements of the array.\n|\n| Notes\n| -----\n| Does not include memory consumed by non-element attributes of the\n| array object.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3,5,2), dtype=np.complex128)\n| >>> x.nbytes\n| 480\n| >>> np.prod(x.shape) * x.itemsize\n| 480\n|\n| ndim\n| Number of array dimensions.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> x.ndim\n| 1\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.ndim\n| 3\n|\n| real\n| The real part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.real\n| array([ 1. , 0.70710678])\n| >>> x.real.dtype\n| dtype('float64')\n|\n| See Also\n| --------\n| numpy.real : equivalent function\n|\n| shape\n| Tuple of array dimensions.\n|\n| The shape property is usually used to get the current shape of an array,\n| but may also be used to reshape the array in-place by assigning a tuple of\n| array dimensions to it. As with `numpy.reshape`, one of the new shape\n| dimensions can be -1, in which case its value is inferred from the size of\n| the array and the remaining dimensions. Reshaping an array in-place will\n| fail if a copy is required.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3, 4])\n| >>> x.shape\n| (4,)\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.shape\n| (2, 3, 4)\n| >>> y.shape = (3, 8)\n| >>> y\n| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.]])\n| >>> y.shape = (3, 6)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: total size of new array must be unchanged\n| >>> np.zeros((4,2))[::2].shape = (-1,)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| AttributeError: Incompatible shape for in-place modification. Use\n| `.reshape()` to make a copy with the desired shape.\n|\n| See Also\n| --------\n| numpy.reshape : similar function\n| ndarray.reshape : similar method\n|\n| size\n| Number of elements in the array.\n|\n| Equal to ``np.prod(a.shape)``, i.e., the product of the array's\n| dimensions.\n|\n| Notes\n| -----\n| `a.size` returns a standard arbitrary precision Python integer. This\n| may not be the case with other methods of obtaining the same value\n| (like the suggested ``np.prod(a.shape)``, which returns an instance\n| of ``np.int``), and may be relevant if the value is used further in\n| calculations that may overflow a fixed size integer type.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)\n| >>> x.size\n| 30\n| >>> np.prod(x.shape)\n| 30\n|\n| strides\n| Tuple of bytes to step in each dimension when traversing an array.\n|\n| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`\n| is::\n|\n| offset = sum(np.array(i) * a.strides)\n|\n| A more detailed explanation of strides can be found in the\n| \"ndarray.rst\" file in the NumPy reference guide.\n|\n| Notes\n| -----\n| Imagine an array of 32-bit integers (each 4 bytes)::\n|\n| x = np.array([[0, 1, 2, 3, 4],\n| [5, 6, 7, 8, 9]], dtype=np.int32)\n|\n| This array is stored in memory as 40 bytes, one after the other\n| (known as a contiguous block of memory). The strides of an array tell\n| us how many bytes we have to skip in memory to move to the next position\n| along a certain axis. For example, we have to skip 4 bytes (1 value) to\n| move to the next column, but 20 bytes (5 values) to get to the same\n| position in the next row. As such, the strides for the array `x` will be\n| ``(20, 4)``.\n|\n| See Also\n| --------\n| numpy.lib.stridetricks.asstrided\n|\n| Examples\n| --------\n| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))\n| >>> y\n| array([[[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]],\n| [[12, 13, 14, 15],\n| [16, 17, 18, 19],\n| [20, 21, 22, 23]]])\n| >>> y.strides\n| (48, 16, 4)\n| >>> y[1,1,1]\n| 17\n| >>> offset=sum(y.strides * np.array((1,1,1)))\n| >>> offset/y.itemsize\n| 17\n|\n| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)\n| >>> x.strides\n| (32, 4, 224, 1344)\n| >>> i = np.array([3,5,2,2])\n| >>> offset = sum(i * x.strides)\n| >>> x[3,5,2,2]\n| 813\n| >>> offset / x.itemsize\n| 813\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from ndarray:\n|\n| hash = None\n" }, { "name": "class memmap", "content": "| memmap(filename, dtype=, mode='r+', offset=0, shape=None, order='C')\n|\n| Create a memory-map to an array stored in a *binary* file on disk.\n|\n| Memory-mapped files are used for accessing small segments of large files\n| on disk, without reading the entire file into memory. NumPy's\n| memmap's are array-like objects. This differs from Python's ``mmap``\n| module, which uses file-like objects.\n|\n| This subclass of ndarray has some unpleasant interactions with\n| some operations, because it doesn't quite fit properly as a subclass.\n| An alternative to using this subclass is to create the ``mmap``\n| object yourself, then create an ndarray with ndarray.new directly,\n| passing the object created in its 'buffer=' parameter.\n|\n| This class may at some point be turned into a factory function\n| which returns a view into an mmap buffer.\n|\n| Flush the memmap instance to write the changes to the file. Currently there\n| is no API to close the underlying ``mmap``. It is tricky to ensure the\n| resource is actually closed, since it may be shared between different\n| memmap instances.\n|\n|\n| Parameters\n| ----------\n| filename : str, file-like object, or pathlib.Path instance\n| The file name or file object to be used as the array data buffer.\n| dtype : data-type, optional\n| The data-type used to interpret the file contents.\n| Default is `uint8`.\n| mode : {'r+', 'r', 'w+', 'c'}, optional\n| The file is opened in this mode:\n|\n| +------+-------------------------------------------------------------+\n| | 'r' | Open existing file for reading only. |\n| +------+-------------------------------------------------------------+\n| | 'r+' | Open existing file for reading and writing. |\n| +------+-------------------------------------------------------------+\n| | 'w+' | Create or overwrite existing file for reading and writing. |\n| +------+-------------------------------------------------------------+\n| | 'c' | Copy-on-write: assignments affect data in memory, but |\n| | | changes are not saved to disk. The file on disk is |\n| | | read-only. |\n| +------+-------------------------------------------------------------+\n|\n| Default is 'r+'.\n| offset : int, optional\n| In the file, array data starts at this offset. Since `offset` is\n| measured in bytes, it should normally be a multiple of the byte-size\n| of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of\n| file are valid; The file will be extended to accommodate the\n| additional data. By default, ``memmap`` will start at the beginning of\n| the file, even if ``filename`` is a file pointer ``fp`` and\n| ``fp.tell() != 0``.\n| shape : tuple, optional\n| The desired shape of the array. If ``mode == 'r'`` and the number\n| of remaining bytes after `offset` is not a multiple of the byte-size\n| of `dtype`, you must specify `shape`. By default, the returned array\n| will be 1-D with the number of elements determined by file size\n| and data-type.\n| order : {'C', 'F'}, optional\n| Specify the order of the ndarray memory layout:\n| :term:`row-major`, C-style or :term:`column-major`,\n| Fortran-style. This only has an effect if the shape is\n| greater than 1-D. The default order is 'C'.\n|\n| Attributes\n| ----------\n| filename : str or pathlib.Path instance\n| Path to the mapped file.\n| offset : int\n| Offset position in the file.\n| mode : str\n| File mode.\n|\n| Methods\n| -------\n| flush\n| Flush any changes in memory to file on disk.\n| When you delete a memmap object, flush is called first to write\n| changes to disk.\n|\n|\n| See also\n| --------\n| lib.format.openmemmap : Create or load a memory-mapped ``.npy`` file.\n|\n| Notes\n| -----\n| The memmap object can be used anywhere an ndarray is accepted.\n| Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns\n| ``True``.\n|\n| Memory-mapped files cannot be larger than 2GB on 32-bit systems.\n|\n| When a memmap causes a file to be created or extended beyond its\n| current size in the filesystem, the contents of the new part are\n| unspecified. On systems with POSIX filesystem semantics, the extended\n| part will be filled with zero bytes.\n|\n| Examples\n| --------\n| >>> data = np.arange(12, dtype='float32')\n| >>> data.resize((3,4))\n|\n| This example uses a temporary file so that doctest doesn't write\n| files to your directory. You would use a 'normal' filename.\n|\n| >>> from tempfile import mkdtemp\n| >>> import os.path as path\n| >>> filename = path.join(mkdtemp(), 'newfile.dat')\n|\n| Create a memmap with dtype and shape that matches our data:\n|\n| >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))\n| >>> fp\n| memmap([[0., 0., 0., 0.],\n| [0., 0., 0., 0.],\n| [0., 0., 0., 0.]], dtype=float32)\n|\n| Write data to memmap array:\n|\n| >>> fp[:] = data[:]\n| >>> fp\n| memmap([[ 0., 1., 2., 3.],\n| [ 4., 5., 6., 7.],\n| [ 8., 9., 10., 11.]], dtype=float32)\n|\n| >>> fp.filename == path.abspath(filename)\n| True\n|\n| Flushes memory changes to disk in order to read them back\n|\n| >>> fp.flush()\n|\n| Load the memmap and verify data was stored:\n|\n| >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))\n| >>> newfp\n| memmap([[ 0., 1., 2., 3.],\n| [ 4., 5., 6., 7.],\n| [ 8., 9., 10., 11.]], dtype=float32)\n|\n| Read-only memmap:\n|\n| >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))\n| >>> fpr.flags.writeable\n| False\n|\n| Copy-on-write memmap:\n|\n| >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))\n| >>> fpc.flags.writeable\n| True\n|\n| It's possible to assign to copy-on-write array, but values are only\n| written into the memory copy of the array, and not written to disk:\n|\n| >>> fpc\n| memmap([[ 0., 1., 2., 3.],\n| [ 4., 5., 6., 7.],\n| [ 8., 9., 10., 11.]], dtype=float32)\n| >>> fpc[0,:] = 0\n| >>> fpc\n| memmap([[ 0., 0., 0., 0.],\n| [ 4., 5., 6., 7.],\n| [ 8., 9., 10., 11.]], dtype=float32)\n|\n| File on disk is unchanged:\n|\n| >>> fpr\n| memmap([[ 0., 1., 2., 3.],\n| [ 4., 5., 6., 7.],\n| [ 8., 9., 10., 11.]], dtype=float32)\n|\n| Offset into a memmap:\n|\n| >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)\n| >>> fpo\n| memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32)\n|\n| Method resolution order:\n| memmap\n| ndarray\n| builtins.object\n|\n| Methods defined here:\n|\n| arrayfinalize(self, obj)\n| None.\n|\n| arraywrap(self, arr, context=None)\n| a.arraywrap(obj) -> Object of same type as ndarray object a.\n|\n| getitem(self, index)\n| Return self[key].\n|\n| flush(self)\n| Write any changes in the array to the file on disk.\n|\n| For further information, see `memmap`.\n|\n| Parameters\n| ----------\n| None\n|\n| See Also\n| --------\n| memmap\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(subtype, filename, dtype=, mode='r+', offset=0, shape=None, order='C')\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| arraypriority = -100.0\n|\n| ----------------------------------------------------------------------\n| Methods inherited from ndarray:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| a.array([dtype], /) -> reference if type unchanged, copy otherwise.\n|\n| Returns either a new reference to self if dtype is not given or a new array\n| of provided data type if dtype is different from the current dtype of the\n| array.\n|\n| arrayfunction(...)\n|\n| arrayprepare(...)\n| a.arrayprepare(obj) -> Object of same type as ndarray object obj.\n|\n| arrayufunc(...)\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| copy(...)\n| a.copy()\n|\n| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.\n|\n| Equivalent to ``a.copy(order='K')``.\n|\n| deepcopy(...)\n| a.deepcopy(memo, /) -> Deep copy of array.\n|\n| Used if :func:`copy.deepcopy` is called on an array.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| Default object formatter.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| iadd(self, value, /)\n| Return self+=value.\n|\n| iand(self, value, /)\n| Return self&=value.\n|\n| ifloordiv(self, value, /)\n| Return self//=value.\n|\n| ilshift(self, value, /)\n| Return self<<=value.\n|\n| imatmul(self, value, /)\n| Return self@=value.\n|\n| imod(self, value, /)\n| Return self%=value.\n|\n| imul(self, value, /)\n| Return self*=value.\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| ipow(self, value, /)\n| Return self=value.\n|\n| irshift(self, value, /)\n| Return self>>=value.\n|\n| isub(self, value, /)\n| Return self-=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| itruediv(self, value, /)\n| Return self/=value.\n|\n| ixor(self, value, /)\n| Return self^=value.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setitem(self, key, value, /)\n| Set self[key] to value.\n|\n| setstate(...)\n| a.setstate(state, /)\n|\n| For unpickling.\n|\n| The `state` argument must be a sequence that contains the following\n| elements:\n|\n| Parameters\n| ----------\n| version : int\n| optional pickle version. If omitted defaults to 0.\n| shape : tuple\n| dtype : data-type\n| isFortran : bool\n| rawdata : string or list\n| a binary string with the data (or a list if 'a' is an object array)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| a.all(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if all elements evaluate to True.\n|\n| Refer to `numpy.all` for full documentation.\n|\n| See Also\n| --------\n| numpy.all : equivalent function\n|\n| any(...)\n| a.any(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if any of the elements of `a` evaluate to True.\n|\n| Refer to `numpy.any` for full documentation.\n|\n| See Also\n| --------\n| numpy.any : equivalent function\n|\n| argmax(...)\n| a.argmax(axis=None, out=None)\n|\n| Return indices of the maximum values along the given axis.\n|\n| Refer to `numpy.argmax` for full documentation.\n|\n| See Also\n| --------\n| numpy.argmax : equivalent function\n|\n| argmin(...)\n| a.argmin(axis=None, out=None)\n|\n| Return indices of the minimum values along the given axis.\n|\n| Refer to `numpy.argmin` for detailed documentation.\n|\n| See Also\n| --------\n| numpy.argmin : equivalent function\n|\n| argpartition(...)\n| a.argpartition(kth, axis=-1, kind='introselect', order=None)\n|\n| Returns the indices that would partition this array.\n|\n| Refer to `numpy.argpartition` for full documentation.\n|\n| .. versionadded:: 1.8.0\n|\n| See Also\n| --------\n| numpy.argpartition : equivalent function\n|\n| argsort(...)\n| a.argsort(axis=-1, kind=None, order=None)\n|\n| Returns the indices that would sort this array.\n|\n| Refer to `numpy.argsort` for full documentation.\n|\n| See Also\n| --------\n| numpy.argsort : equivalent function\n|\n| astype(...)\n| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)\n|\n| Copy of the array, cast to a specified type.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| Typecode or data-type to which the array is cast.\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout order of the result.\n| 'C' means C order, 'F' means Fortran order, 'A'\n| means 'F' order if all the arrays are Fortran contiguous,\n| 'C' order otherwise, and 'K' means as close to the\n| order the array elements appear in memory as possible.\n| Default is 'K'.\n| casting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\n| Controls what kind of data casting may occur. Defaults to 'unsafe'\n| for backwards compatibility.\n|\n| * 'no' means the data types should not be cast at all.\n| * 'equiv' means only byte-order changes are allowed.\n| * 'safe' means only casts which can preserve values are allowed.\n| * 'samekind' means only safe casts or casts within a kind,\n| like float64 to float32, are allowed.\n| * 'unsafe' means any data conversions may be done.\n| subok : bool, optional\n| If True, then sub-classes will be passed-through (default), otherwise\n| the returned array will be forced to be a base-class array.\n| copy : bool, optional\n| By default, astype always returns a newly allocated array. If this\n| is set to false, and the `dtype`, `order`, and `subok`\n| requirements are satisfied, the input array is returned instead\n| of a copy.\n|\n| Returns\n| -------\n| arrt : ndarray\n| Unless `copy` is False and the other conditions for returning the input\n| array are satisfied (see description for `copy` input parameter), `arrt`\n| is a new array of the same shape as the input array, with dtype, order\n| given by `dtype`, `order`.\n|\n| Notes\n| -----\n| .. versionchanged:: 1.17.0\n| Casting between a simple data type and a structured one is possible only\n| for \"unsafe\" casting. Casting to multiple fields is allowed, but\n| casting from multiple fields is not.\n|\n| .. versionchanged:: 1.9.0\n| Casting from numeric to string types in 'safe' casting mode requires\n| that the string dtype length is long enough to store the max\n| integer/float value converted.\n|\n| Raises\n| ------\n| ComplexWarning\n| When casting from complex to float or int. To avoid this,\n| one should use ``a.real.astype(t)``.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 2.5])\n| >>> x\n| array([1. , 2. , 2.5])\n|\n| >>> x.astype(int)\n| array([1, 2, 2])\n|\n| byteswap(...)\n| a.byteswap(inplace=False)\n|\n| Swap the bytes of the array elements\n|\n| Toggle between low-endian and big-endian data representation by\n| returning a byteswapped array, optionally swapped in-place.\n| Arrays of byte-strings are not swapped. The real and imaginary\n| parts of a complex number are swapped individually.\n|\n| Parameters\n| ----------\n| inplace : bool, optional\n| If ``True``, swap bytes in-place, default is ``False``.\n|\n| Returns\n| -------\n| out : ndarray\n| The byteswapped array. If `inplace` is ``True``, this is\n| a view to self.\n|\n| Examples\n| --------\n| >>> A = np.array([1, 256, 8755], dtype=np.int16)\n| >>> list(map(hex, A))\n| ['0x1', '0x100', '0x2233']\n| >>> A.byteswap(inplace=True)\n| array([ 256, 1, 13090], dtype=int16)\n| >>> list(map(hex, A))\n| ['0x100', '0x1', '0x3322']\n|\n| Arrays of byte-strings are not swapped\n|\n| >>> A = np.array([b'ceg', b'fac'])\n| >>> A.byteswap()\n| array([b'ceg', b'fac'], dtype='|S3')\n|\n| ``A.newbyteorder().byteswap()`` produces an array with the same values\n| but different representation in memory\n|\n| >>> A = np.array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,\n| 0, 0], dtype=uint8)\n| >>> A.newbyteorder().byteswap(inplace=True)\n| array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,\n| 0, 3], dtype=uint8)\n|\n| choose(...)\n| a.choose(choices, out=None, mode='raise')\n|\n| Use an index array to construct a new array from a set of choices.\n|\n| Refer to `numpy.choose` for full documentation.\n|\n| See Also\n| --------\n| numpy.choose : equivalent function\n|\n| clip(...)\n| a.clip(min=None, max=None, out=None, kwargs)\n|\n| Return an array whose values are limited to ``[min, max]``.\n| One of max or min must be given.\n|\n| Refer to `numpy.clip` for full documentation.\n|\n| See Also\n| --------\n| numpy.clip : equivalent function\n|\n| compress(...)\n| a.compress(condition, axis=None, out=None)\n|\n| Return selected slices of this array along given axis.\n|\n| Refer to `numpy.compress` for full documentation.\n|\n| See Also\n| --------\n| numpy.compress : equivalent function\n|\n| conj(...)\n| a.conj()\n|\n| Complex-conjugate all elements.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| conjugate(...)\n| a.conjugate()\n|\n| Return the complex conjugate, element-wise.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| copy(...)\n| a.copy(order='C')\n|\n| Return a copy of the array.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout of the copy. 'C' means C-order,\n| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n| 'C' otherwise. 'K' means match the layout of `a` as closely\n| as possible. (Note that this function and :func:`numpy.copy` are very\n| similar but have different default values for their order=\n| arguments, and this function always passes sub-classes through.)\n|\n| See also\n| --------\n| numpy.copy : Similar function with different default behavior\n| numpy.copyto\n|\n| Notes\n| -----\n| This function is the preferred method for creating an array copy. The\n| function :func:`numpy.copy` is similar, but it defaults to using order 'K',\n| and will not pass sub-classes through by default.\n|\n| Examples\n| --------\n| >>> x = np.array([[1,2,3],[4,5,6]], order='F')\n|\n| >>> y = x.copy()\n|\n| >>> x.fill(0)\n|\n| >>> x\n| array([[0, 0, 0],\n| [0, 0, 0]])\n|\n| >>> y\n| array([[1, 2, 3],\n| [4, 5, 6]])\n|\n| >>> y.flags['CCONTIGUOUS']\n| True\n|\n| cumprod(...)\n| a.cumprod(axis=None, dtype=None, out=None)\n|\n| Return the cumulative product of the elements along the given axis.\n|\n| Refer to `numpy.cumprod` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumprod : equivalent function\n|\n| cumsum(...)\n| a.cumsum(axis=None, dtype=None, out=None)\n|\n| Return the cumulative sum of the elements along the given axis.\n|\n| Refer to `numpy.cumsum` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumsum : equivalent function\n|\n| diagonal(...)\n| a.diagonal(offset=0, axis1=0, axis2=1)\n|\n| Return specified diagonals. In NumPy 1.9 the returned array is a\n| read-only view instead of a copy as in previous NumPy versions. In\n| a future version the read-only restriction will be removed.\n|\n| Refer to :func:`numpy.diagonal` for full documentation.\n|\n| See Also\n| --------\n| numpy.diagonal : equivalent function\n|\n| dot(...)\n| a.dot(b, out=None)\n|\n| Dot product of two arrays.\n|\n| Refer to `numpy.dot` for full documentation.\n|\n| See Also\n| --------\n| numpy.dot : equivalent function\n|\n| Examples\n| --------\n| >>> a = np.eye(2)\n| >>> b = np.ones((2, 2)) * 2\n| >>> a.dot(b)\n| array([[2., 2.],\n| [2., 2.]])\n|\n| This array method can be conveniently chained:\n|\n| >>> a.dot(b).dot(b)\n| array([[8., 8.],\n| [8., 8.]])\n|\n| dump(...)\n| a.dump(file)\n|\n| Dump a pickle of the array to the specified file.\n| The array can be read back with pickle.load or numpy.load.\n|\n| Parameters\n| ----------\n| file : str or Path\n| A string naming the dump file.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| dumps(...)\n| a.dumps()\n|\n| Returns the pickle of the array as a string.\n| pickle.loads or numpy.loads will convert the string back to an array.\n|\n| Parameters\n| ----------\n| None\n|\n| fill(...)\n| a.fill(value)\n|\n| Fill the array with a scalar value.\n|\n| Parameters\n| ----------\n| value : scalar\n| All elements of `a` will be assigned this value.\n|\n| Examples\n| --------\n| >>> a = np.array([1, 2])\n| >>> a.fill(0)\n| >>> a\n| array([0, 0])\n| >>> a = np.empty(2)\n| >>> a.fill(1)\n| >>> a\n| array([1., 1.])\n|\n| flatten(...)\n| a.flatten(order='C')\n|\n| Return a copy of the array collapsed into one dimension.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| 'C' means to flatten in row-major (C-style) order.\n| 'F' means to flatten in column-major (Fortran-\n| style) order. 'A' means to flatten in column-major\n| order if `a` is Fortran *contiguous* in memory,\n| row-major order otherwise. 'K' means to flatten\n| `a` in the order the elements occur in memory.\n| The default is 'C'.\n|\n| Returns\n| -------\n| y : ndarray\n| A copy of the input array, flattened to one dimension.\n|\n| See Also\n| --------\n| ravel : Return a flattened array.\n| flat : A 1-D flat iterator over the array.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,2], [3,4]])\n| >>> a.flatten()\n| array([1, 2, 3, 4])\n| >>> a.flatten('F')\n| array([1, 3, 2, 4])\n|\n| getfield(...)\n| a.getfield(dtype, offset=0)\n|\n| Returns a field of the given array as a certain type.\n|\n| A field is a view of the array data with a given data-type. The values in\n| the view are determined by the given type and the offset into the current\n| array in bytes. The offset needs to be such that the view dtype fits in the\n| array dtype; for example an array of dtype complex128 has 16-byte elements.\n| If taking a view with a 32-bit integer (4 bytes), the offset needs to be\n| between 0 and 12 bytes.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| The data type of the view. The dtype size of the view can not be larger\n| than that of the array itself.\n| offset : int\n| Number of bytes to skip before beginning the element view.\n|\n| Examples\n| --------\n| >>> x = np.diag([1.+1.j]*2)\n| >>> x[1, 1] = 2 + 4.j\n| >>> x\n| array([[1.+1.j, 0.+0.j],\n| [0.+0.j, 2.+4.j]])\n| >>> x.getfield(np.float64)\n| array([[1., 0.],\n| [0., 2.]])\n|\n| By choosing an offset of 8 bytes we can select the complex part of the\n| array for our view:\n|\n| >>> x.getfield(np.float64, offset=8)\n| array([[1., 0.],\n| [0., 4.]])\n|\n| item(...)\n| a.item(*args)\n|\n| Copy an element of an array to a standard Python scalar and return it.\n|\n| Parameters\n| ----------\n| \\*args : Arguments (variable number and type)\n|\n| * none: in this case, the method only works for arrays\n| with one element (`a.size == 1`), which element is\n| copied into a standard Python scalar object and returned.\n|\n| * inttype: this argument is interpreted as a flat index into\n| the array, specifying which element to copy and return.\n|\n| * tuple of inttypes: functions as does a single inttype argument,\n| except that the argument is interpreted as an nd-index into the\n| array.\n|\n| Returns\n| -------\n| z : Standard Python scalar object\n| A copy of the specified element of the array as a suitable\n| Python scalar\n|\n| Notes\n| -----\n| When the data type of `a` is longdouble or clongdouble, item() returns\n| a scalar array object because there is no available Python scalar that\n| would not lose information. Void arrays return a buffer object for item(),\n| unless fields are defined, in which case a tuple is returned.\n|\n| `item` is very similar to a[args], except, instead of an array scalar,\n| a standard Python scalar is returned. This can be useful for speeding up\n| access to elements of the array and doing arithmetic on elements of the\n| array using Python's optimized math.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.item(3)\n| 1\n| >>> x.item(7)\n| 0\n| >>> x.item((0, 1))\n| 2\n| >>> x.item((2, 2))\n| 1\n|\n| itemset(...)\n| a.itemset(*args)\n|\n| Insert scalar into an array (scalar is cast to array's dtype, if possible)\n|\n| There must be at least 1 argument, and define the last argument\n| as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster\n| than ``a[args] = item``. The item should be a scalar value and `args`\n| must select a single item in the array `a`.\n|\n| Parameters\n| ----------\n| \\*args : Arguments\n| If one argument: a scalar, only used in case `a` is of size 1.\n| If two arguments: the last argument is the value to be set\n| and must be a scalar, the first argument specifies a single array\n| element location. It is either an int or a tuple.\n|\n| Notes\n| -----\n| Compared to indexing syntax, `itemset` provides some speed increase\n| for placing a scalar into a particular location in an `ndarray`,\n| if you must do this. However, generally this is discouraged:\n| among other problems, it complicates the appearance of the code.\n| Also, when using `itemset` (and `item`) inside a loop, be sure\n| to assign the methods to a local variable to avoid the attribute\n| look-up at each loop iteration.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.itemset(4, 0)\n| >>> x.itemset((2, 2), 9)\n| >>> x\n| array([[2, 2, 6],\n| [1, 0, 6],\n| [1, 0, 9]])\n|\n| max(...)\n| a.max(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the maximum along a given axis.\n|\n| Refer to `numpy.amax` for full documentation.\n|\n| See Also\n| --------\n| numpy.amax : equivalent function\n|\n| mean(...)\n| a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)\n|\n| Returns the average of the array elements along given axis.\n|\n| Refer to `numpy.mean` for full documentation.\n|\n| See Also\n| --------\n| numpy.mean : equivalent function\n|\n| min(...)\n| a.min(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the minimum along a given axis.\n|\n| Refer to `numpy.amin` for full documentation.\n|\n| See Also\n| --------\n| numpy.amin : equivalent function\n|\n| newbyteorder(...)\n| arr.newbyteorder(neworder='S', /)\n|\n| Return the array with the same data viewed with a different byte order.\n|\n| Equivalent to::\n|\n| arr.view(arr.dtype.newbytorder(neworder))\n|\n| Changes are also made in all fields and sub-arrays of the array data\n| type.\n|\n|\n|\n| Parameters\n| ----------\n| neworder : string, optional\n| Byte order to force; a value from the byte order specifications\n| below. `neworder` codes can be any of:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order, equivalent to `sys.byteorder`\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newarr : array\n| New array object with the dtype reflecting given change to the\n| byte order.\n|\n| nonzero(...)\n| a.nonzero()\n|\n| Return the indices of the elements that are non-zero.\n|\n| Refer to `numpy.nonzero` for full documentation.\n|\n| See Also\n| --------\n| numpy.nonzero : equivalent function\n|\n| partition(...)\n| a.partition(kth, axis=-1, kind='introselect', order=None)\n|\n| Rearranges the elements in the array in such a way that the value of the\n| element in kth position is in the position it would be in a sorted array.\n| All elements smaller than the kth element are moved before this element and\n| all equal or greater are moved behind it. The ordering of the elements in\n| the two partitions is undefined.\n|\n| .. versionadded:: 1.8.0\n|\n| Parameters\n| ----------\n| kth : int or sequence of ints\n| Element index to partition by. The kth element value will be in its\n| final sorted position and all smaller elements will be moved before it\n| and all equal or greater elements behind it.\n| The order of all elements in the partitions is undefined.\n| If provided with a sequence of kth it will partition all elements\n| indexed by kth of them into their sorted position at once.\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'introselect'}, optional\n| Selection algorithm. Default is 'introselect'.\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need to be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.partition : Return a parititioned copy of an array.\n| argpartition : Indirect partition.\n| sort : Full sort.\n|\n| Notes\n| -----\n| See ``np.partition`` for notes on the different algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([3, 4, 2, 1])\n| >>> a.partition(3)\n| >>> a\n| array([2, 1, 3, 4])\n|\n| >>> a.partition((1, 3))\n| >>> a\n| array([1, 2, 3, 4])\n|\n| prod(...)\n| a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)\n|\n| Return the product of the array elements over the given axis\n|\n| Refer to `numpy.prod` for full documentation.\n|\n| See Also\n| --------\n| numpy.prod : equivalent function\n|\n| ptp(...)\n| a.ptp(axis=None, out=None, keepdims=False)\n|\n| Peak to peak (maximum - minimum) value along a given axis.\n|\n| Refer to `numpy.ptp` for full documentation.\n|\n| See Also\n| --------\n| numpy.ptp : equivalent function\n|\n| put(...)\n| a.put(indices, values, mode='raise')\n|\n| Set ``a.flat[n] = values[n]`` for all `n` in indices.\n|\n| Refer to `numpy.put` for full documentation.\n|\n| See Also\n| --------\n| numpy.put : equivalent function\n|\n| ravel(...)\n| a.ravel([order])\n|\n| Return a flattened array.\n|\n| Refer to `numpy.ravel` for full documentation.\n|\n| See Also\n| --------\n| numpy.ravel : equivalent function\n|\n| ndarray.flat : a flat iterator on the array.\n|\n| repeat(...)\n| a.repeat(repeats, axis=None)\n|\n| Repeat elements of an array.\n|\n| Refer to `numpy.repeat` for full documentation.\n|\n| See Also\n| --------\n| numpy.repeat : equivalent function\n|\n| reshape(...)\n| a.reshape(shape, order='C')\n|\n| Returns an array containing the same data with a new shape.\n|\n| Refer to `numpy.reshape` for full documentation.\n|\n| See Also\n| --------\n| numpy.reshape : equivalent function\n|\n| Notes\n| -----\n| Unlike the free function `numpy.reshape`, this method on `ndarray` allows\n| the elements of the shape parameter to be passed in as separate arguments.\n| For example, ``a.reshape(10, 11)`` is equivalent to\n| ``a.reshape((10, 11))``.\n|\n| resize(...)\n| a.resize(newshape, refcheck=True)\n|\n| Change shape and size of array in-place.\n|\n| Parameters\n| ----------\n| newshape : tuple of ints, or `n` ints\n| Shape of resized array.\n| refcheck : bool, optional\n| If False, reference count will not be checked. Default is True.\n|\n| Returns\n| -------\n| None\n|\n| Raises\n| ------\n| ValueError\n| If `a` does not own its own data or references or views to it exist,\n| and the data memory must be changed.\n| PyPy only: will always raise if the data memory must be changed, since\n| there is no reliable way to determine if references or views to it\n| exist.\n|\n| SystemError\n| If the `order` keyword argument is specified. This behaviour is a\n| bug in NumPy.\n|\n| See Also\n| --------\n| resize : Return a new array with the specified shape.\n|\n| Notes\n| -----\n| This reallocates space for the data area if necessary.\n|\n| Only contiguous arrays (data elements consecutive in memory) can be\n| resized.\n|\n| The purpose of the reference count check is to make sure you\n| do not use this array as a buffer for another Python object and then\n| reallocate the memory. However, reference counts can increase in\n| other ways so if you are sure that you have not shared the memory\n| for this array with another Python object, then you may safely set\n| `refcheck` to False.\n|\n| Examples\n| --------\n| Shrinking an array: array is flattened (in the order that the data are\n| stored in memory), resized, and reshaped:\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='C')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [1]])\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='F')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [2]])\n|\n| Enlarging an array: as above, but missing entries are filled with zeros:\n|\n| >>> b = np.array([[0, 1], [2, 3]])\n| >>> b.resize(2, 3) # newshape parameter doesn't have to be a tuple\n| >>> b\n| array([[0, 1, 2],\n| [3, 0, 0]])\n|\n| Referencing an array prevents resizing...\n|\n| >>> c = a\n| >>> a.resize((1, 1))\n| Traceback (most recent call last):\n| ...\n| ValueError: cannot resize an array that references or is referenced ...\n|\n| Unless `refcheck` is False:\n|\n| >>> a.resize((1, 1), refcheck=False)\n| >>> a\n| array([[0]])\n| >>> c\n| array([[0]])\n|\n| round(...)\n| a.round(decimals=0, out=None)\n|\n| Return `a` with each element rounded to the given number of decimals.\n|\n| Refer to `numpy.around` for full documentation.\n|\n| See Also\n| --------\n| numpy.around : equivalent function\n|\n| searchsorted(...)\n| a.searchsorted(v, side='left', sorter=None)\n|\n| Find indices where elements of v should be inserted in a to maintain order.\n|\n| For full documentation, see `numpy.searchsorted`\n|\n| See Also\n| --------\n| numpy.searchsorted : equivalent function\n|\n| setfield(...)\n| a.setfield(val, dtype, offset=0)\n|\n| Put a value into a specified place in a field defined by a data-type.\n|\n| Place `val` into `a`'s field defined by `dtype` and beginning `offset`\n| bytes into the field.\n|\n| Parameters\n| ----------\n| val : object\n| Value to be placed in field.\n| dtype : dtype object\n| Data-type of the field in which to place `val`.\n| offset : int, optional\n| The number of bytes into the field at which to place `val`.\n|\n| Returns\n| -------\n| None\n|\n| See Also\n| --------\n| getfield\n|\n| Examples\n| --------\n| >>> x = np.eye(3)\n| >>> x.getfield(np.float64)\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n| >>> x.setfield(3, np.int32)\n| >>> x.getfield(np.int32)\n| array([[3, 3, 3],\n| [3, 3, 3],\n| [3, 3, 3]], dtype=int32)\n| >>> x\n| array([[1.0e+000, 1.5e-323, 1.5e-323],\n| [1.5e-323, 1.0e+000, 1.5e-323],\n| [1.5e-323, 1.5e-323, 1.0e+000]])\n| >>> x.setfield(np.eye(3), np.int32)\n| >>> x\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n|\n| setflags(...)\n| a.setflags(write=None, align=None, uic=None)\n|\n| Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),\n| respectively.\n|\n| These Boolean-valued flags affect how numpy interprets the memory\n| area used by `a` (see Notes below). The ALIGNED flag can only\n| be set to True if the data is actually aligned according to the type.\n| The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set\n| to True. The flag WRITEABLE can only be set to True if the array owns its\n| own memory, or the ultimate owner of the memory exposes a writeable buffer\n| interface, or is a string. (The exception for string is made so that\n| unpickling can be done without copying memory.)\n|\n| Parameters\n| ----------\n| write : bool, optional\n| Describes whether or not `a` can be written to.\n| align : bool, optional\n| Describes whether or not `a` is aligned properly for its type.\n| uic : bool, optional\n| Describes whether or not `a` is a copy of another \"base\" array.\n|\n| Notes\n| -----\n| Array flags provide information about how the memory area used\n| for the array is to be interpreted. There are 7 Boolean flags\n| in use, only four of which can be changed by the user:\n| WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.\n|\n| WRITEABLE (W) the data area can be written to;\n|\n| ALIGNED (A) the data and strides are aligned appropriately for the hardware\n| (as determined by the compiler);\n|\n| UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;\n|\n| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced\n| by .base). When the C-API function PyArrayResolveWritebackIfCopy is\n| called, the base array will be updated with the contents of this array.\n|\n| All flags can be accessed using the single (upper case) letter as well\n| as the full name.\n|\n| Examples\n| --------\n| >>> y = np.array([[3, 1, 7],\n| ... [2, 0, 0],\n| ... [8, 5, 9]])\n| >>> y\n| array([[3, 1, 7],\n| [2, 0, 0],\n| [8, 5, 9]])\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : True\n| ALIGNED : True\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(write=0, align=0)\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : False\n| ALIGNED : False\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(uic=1)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: cannot set WRITEBACKIFCOPY flag to True\n|\n| sort(...)\n| a.sort(axis=-1, kind=None, order=None)\n|\n| Sort an array in-place. Refer to `numpy.sort` for full documentation.\n|\n| Parameters\n| ----------\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'\n| and 'mergesort' use timsort under the covers and, in general, the\n| actual implementation will vary with datatype. The 'mergesort' option\n| is retained for backwards compatibility.\n|\n| .. versionchanged:: 1.15.0\n| The 'stable' option was added.\n|\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.sort : Return a sorted copy of an array.\n| numpy.argsort : Indirect sort.\n| numpy.lexsort : Indirect stable sort on multiple keys.\n| numpy.searchsorted : Find elements in sorted array.\n| numpy.partition: Partial sort.\n|\n| Notes\n| -----\n| See `numpy.sort` for notes on the different sorting algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,4], [3,1]])\n| >>> a.sort(axis=1)\n| >>> a\n| array([[1, 4],\n| [1, 3]])\n| >>> a.sort(axis=0)\n| >>> a\n| array([[1, 3],\n| [1, 4]])\n|\n| Use the `order` keyword to specify a field to use when sorting a\n| structured array:\n|\n| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])\n| >>> a.sort(order='y')\n| >>> a\n| array([(b'c', 1), (b'a', 2)],\n| dtype=[('x', 'S1'), ('y', '>> x = np.array([[0, 1], [2, 3]], dtype='>> x.tobytes()\n| b'\\x00\\x00\\x01\\x00\\x02\\x00\\x03\\x00'\n| >>> x.tobytes('C') == x.tobytes()\n| True\n| >>> x.tobytes('F')\n| b'\\x00\\x00\\x02\\x00\\x01\\x00\\x03\\x00'\n|\n| tofile(...)\n| a.tofile(fid, sep=\"\", format=\"%s\")\n|\n| Write array to a file as text or binary (default).\n|\n| Data is always written in 'C' order, independent of the order of `a`.\n| The data produced by this method can be recovered using the function\n| fromfile().\n|\n| Parameters\n| ----------\n| fid : file or str or Path\n| An open file object, or a string containing a filename.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| sep : str\n| Separator between array items for text output.\n| If \"\" (empty), a binary file is written, equivalent to\n| ``file.write(a.tobytes())``.\n| format : str\n| Format string for text file output.\n| Each entry in the array is formatted to text by first converting\n| it to the closest Python type, and then using \"format\" % item.\n|\n| Notes\n| -----\n| This is a convenience function for quick storage of array data.\n| Information on endianness and precision is lost, so this method is not a\n| good choice for files intended to archive data or transport data between\n| machines with different endianness. Some of these problems can be overcome\n| by outputting the data as text files, at the expense of speed and file\n| size.\n|\n| When fid is a file object, array contents are directly written to the\n| file, bypassing the file object's ``write`` method. As a result, tofile\n| cannot be used with files objects supporting compression (e.g., GzipFile)\n| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).\n|\n| tolist(...)\n| a.tolist()\n|\n| Return the array as an ``a.ndim``-levels deep nested list of Python scalars.\n|\n| Return a copy of the array data as a (nested) Python list.\n| Data items are converted to the nearest compatible builtin Python type, via\n| the `~numpy.ndarray.item` function.\n|\n| If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will\n| not be a list at all, but a simple Python scalar.\n|\n| Parameters\n| ----------\n| none\n|\n| Returns\n| -------\n| y : object, or list of object, or list of list of object, or ...\n| The possibly nested list of array elements.\n|\n| Notes\n| -----\n| The array may be recreated via ``a = np.array(a.tolist())``, although this\n| may sometimes lose precision.\n|\n| Examples\n| --------\n| For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,\n| except that ``tolist`` changes numpy scalars to Python scalars:\n|\n| >>> a = np.uint32([1, 2])\n| >>> alist = list(a)\n| >>> alist\n| [1, 2]\n| >>> type(alist[0])\n| \n| >>> atolist = a.tolist()\n| >>> atolist\n| [1, 2]\n| >>> type(atolist[0])\n| \n|\n| Additionally, for a 2D array, ``tolist`` applies recursively:\n|\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> list(a)\n| [array([1, 2]), array([3, 4])]\n| >>> a.tolist()\n| [[1, 2], [3, 4]]\n|\n| The base case for this recursion is a 0D array:\n|\n| >>> a = np.array(1)\n| >>> list(a)\n| Traceback (most recent call last):\n| ...\n| TypeError: iteration over a 0-d array\n| >>> a.tolist()\n| 1\n|\n| tostring(...)\n| a.tostring(order='C')\n|\n| A compatibility alias for `tobytes`, with exactly the same behavior.\n|\n| Despite its name, it returns `bytes` not `str`\\ s.\n|\n| .. deprecated:: 1.19.0\n|\n| trace(...)\n| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n|\n| Return the sum along diagonals of the array.\n|\n| Refer to `numpy.trace` for full documentation.\n|\n| See Also\n| --------\n| numpy.trace : equivalent function\n|\n| transpose(...)\n| a.transpose(*axes)\n|\n| Returns a view of the array with axes transposed.\n|\n| For a 1-D array this has no effect, as a transposed vector is simply the\n| same vector. To convert a 1-D array into a 2D column vector, an additional\n| dimension must be added. `np.atleast2d(a).T` achieves this, as does\n| `a[:, np.newaxis]`.\n| For a 2-D array, this is a standard matrix transpose.\n| For an n-D array, if axes are given, their order indicates how the\n| axes are permuted (see Examples). If axes are not provided and\n| ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then\n| ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.\n|\n| Parameters\n| ----------\n| axes : None, tuple of ints, or `n` ints\n|\n| * None or no argument: reverses the order of the axes.\n|\n| * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s\n| `i`-th axis becomes `a.transpose()`'s `j`-th axis.\n|\n| * `n` ints: same as an n-tuple of the same ints (this form is\n| intended simply as a \"convenience\" alternative to the tuple form)\n|\n| Returns\n| -------\n| out : ndarray\n| View of `a`, with axes suitably permuted.\n|\n| See Also\n| --------\n| transpose : Equivalent function\n| ndarray.T : Array property returning the array transposed.\n| ndarray.reshape : Give a new shape to an array without changing its data.\n|\n| Examples\n| --------\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> a\n| array([[1, 2],\n| [3, 4]])\n| >>> a.transpose()\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose((1, 0))\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose(1, 0)\n| array([[1, 3],\n| [2, 4]])\n|\n| var(...)\n| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)\n|\n| Returns the variance of the array elements, along given axis.\n|\n| Refer to `numpy.var` for full documentation.\n|\n| See Also\n| --------\n| numpy.var : equivalent function\n|\n| view(...)\n| a.view([dtype][, type])\n|\n| New view of array with the same data.\n|\n| .. note::\n| Passing None for ``dtype`` is different from omitting the parameter,\n| since the former invokes ``dtype(None)`` which is an alias for\n| ``dtype('float')``.\n|\n| Parameters\n| ----------\n| dtype : data-type or ndarray sub-class, optional\n| Data-type descriptor of the returned view, e.g., float32 or int16.\n| Omitting it results in the view having the same data-type as `a`.\n| This argument can also be specified as an ndarray sub-class, which\n| then specifies the type of the returned object (this is equivalent to\n| setting the ``type`` parameter).\n| type : Python type, optional\n| Type of the returned view, e.g., ndarray or matrix. Again, omission\n| of the parameter results in type preservation.\n|\n| Notes\n| -----\n| ``a.view()`` is used two different ways:\n|\n| ``a.view(somedtype)`` or ``a.view(dtype=somedtype)`` constructs a view\n| of the array's memory with a different data-type. This can cause a\n| reinterpretation of the bytes of memory.\n|\n| ``a.view(ndarraysubclass)`` or ``a.view(type=ndarraysubclass)`` just\n| returns an instance of `ndarraysubclass` that looks at the same array\n| (same shape, dtype, etc.) This does not cause a reinterpretation of the\n| memory.\n|\n| For ``a.view(somedtype)``, if ``somedtype`` has a different number of\n| bytes per entry than the previous dtype (for example, converting a\n| regular array to a structured array), then the behavior of the view\n| cannot be predicted just from the superficial appearance of ``a`` (shown\n| by ``print(a)``). It also depends on exactly how ``a`` is stored in\n| memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus\n| defined as a slice or transpose, etc., the view may give different\n| results.\n|\n|\n| Examples\n| --------\n| >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])\n|\n| Viewing array data using a different type and dtype:\n|\n| >>> y = x.view(dtype=np.int16, type=np.matrix)\n| >>> y\n| matrix([[513]], dtype=int16)\n| >>> print(type(y))\n| \n|\n| Creating a view on a structured array so it can be used in calculations\n|\n| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])\n| >>> xv = x.view(dtype=np.int8).reshape(-1,2)\n| >>> xv\n| array([[1, 2],\n| [3, 4]], dtype=int8)\n| >>> xv.mean(0)\n| array([2., 3.])\n|\n| Making changes to the view changes the underlying array\n|\n| >>> xv[0,1] = 20\n| >>> x\n| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])\n|\n| Using a view to convert an array to a recarray:\n|\n| >>> z = x.view(np.recarray)\n| >>> z.a\n| array([1, 3], dtype=int8)\n|\n| Views share data:\n|\n| >>> x[0] = (9, 10)\n| >>> z[0]\n| (9, 10)\n|\n| Views that change the dtype size (bytes per entry) should normally be\n| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:\n|\n| >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)\n| >>> y = x[:, 0:2]\n| >>> y\n| array([[1, 2],\n| [4, 5]], dtype=int16)\n| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])\n| Traceback (most recent call last):\n| ...\n| ValueError: To change to a dtype of a different size, the array must be C-contiguous\n| >>> z = y.copy()\n| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])\n| array([[(1, 2)],\n| [(4, 5)]], dtype=[('width', '>> x = np.array([[1.,2.],[3.,4.]])\n| >>> x\n| array([[ 1., 2.],\n| [ 3., 4.]])\n| >>> x.T\n| array([[ 1., 3.],\n| [ 2., 4.]])\n| >>> x = np.array([1.,2.,3.,4.])\n| >>> x\n| array([ 1., 2., 3., 4.])\n| >>> x.T\n| array([ 1., 2., 3., 4.])\n|\n| See Also\n| --------\n| transpose\n|\n| arrayinterface\n| Array protocol: Python side.\n|\n| arraystruct\n| Array protocol: C-struct side.\n|\n| base\n| Base object if memory is from some other object.\n|\n| Examples\n| --------\n| The base of an array that owns its memory is None:\n|\n| >>> x = np.array([1,2,3,4])\n| >>> x.base is None\n| True\n|\n| Slicing creates a view, whose memory is shared with x:\n|\n| >>> y = x[2:]\n| >>> y.base is x\n| True\n|\n| ctypes\n| An object to simplify the interaction of the array with the ctypes\n| module.\n|\n| This attribute creates an object that makes it easier to use arrays\n| when calling shared libraries with the ctypes module. The returned\n| object has, among others, data, shape, and strides attributes (see\n| Notes below) which themselves return ctypes objects that can be used\n| as arguments to a shared library.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| c : Python object\n| Possessing attributes data, shape, strides, etc.\n|\n| See Also\n| --------\n| numpy.ctypeslib\n|\n| Notes\n| -----\n| Below are the public attributes of this object which were documented\n| in \"Guide to NumPy\" (we have omitted undocumented public attributes,\n| as well as documented private attributes):\n|\n| .. autoattribute:: numpy.core.internal.ctypes.data\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.shape\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.strides\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.dataas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.shapeas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.stridesas\n| :noindex:\n|\n| If the ctypes module is not available, then the ctypes attribute\n| of array objects still returns something useful, but ctypes objects\n| are not returned and errors may be raised instead. In particular,\n| the object will still have the ``asparameter`` attribute which will\n| return an integer equal to the data attribute.\n|\n| Examples\n| --------\n| >>> import ctypes\n| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)\n| >>> x\n| array([[0, 1],\n| [2, 3]], dtype=int32)\n| >>> x.ctypes.data\n| 31962608 # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32))\n| # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32)).contents\n| cuint(0)\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint64)).contents\n| culong(4294967296)\n| >>> x.ctypes.shape\n| # may vary\n| >>> x.ctypes.strides\n| # may vary\n|\n| data\n| Python buffer object pointing to the start of the array's data.\n|\n| dtype\n| Data-type of the array's elements.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| d : numpy dtype object\n|\n| See Also\n| --------\n| numpy.dtype\n|\n| Examples\n| --------\n| >>> x\n| array([[0, 1],\n| [2, 3]])\n| >>> x.dtype\n| dtype('int32')\n| >>> type(x.dtype)\n| \n|\n| flags\n| Information about the memory layout of the array.\n|\n| Attributes\n| ----------\n| CCONTIGUOUS (C)\n| The data is in a single, C-style contiguous segment.\n| FCONTIGUOUS (F)\n| The data is in a single, Fortran-style contiguous segment.\n| OWNDATA (O)\n| The array owns the memory it uses or borrows it from another object.\n| WRITEABLE (W)\n| The data area can be written to. Setting this to False locks\n| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE\n| from its base array at creation time, but a view of a writeable\n| array may be subsequently locked while the base array remains writeable.\n| (The opposite is not true, in that a view of a locked array may not\n| be made writeable. However, currently, locking a base object does not\n| lock any views that already reference it, so under that circumstance it\n| is possible to alter the contents of a locked array via a previously\n| created writeable view onto it.) Attempting to change a non-writeable\n| array raises a RuntimeError exception.\n| ALIGNED (A)\n| The data and all elements are aligned appropriately for the hardware.\n| WRITEBACKIFCOPY (X)\n| This array is a copy of some other array. The C-API function\n| PyArrayResolveWritebackIfCopy must be called before deallocating\n| to the base array will be updated with the contents of this array.\n| UPDATEIFCOPY (U)\n| (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.\n| When this array is\n| deallocated, the base array will be updated with the contents of\n| this array.\n| FNC\n| FCONTIGUOUS and not CCONTIGUOUS.\n| FORC\n| FCONTIGUOUS or CCONTIGUOUS (one-segment test).\n| BEHAVED (B)\n| ALIGNED and WRITEABLE.\n| CARRAY (CA)\n| BEHAVED and CCONTIGUOUS.\n| FARRAY (FA)\n| BEHAVED and FCONTIGUOUS and not CCONTIGUOUS.\n|\n| Notes\n| -----\n| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),\n| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag\n| names are only supported in dictionary access.\n|\n| Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be\n| changed by the user, via direct assignment to the attribute or dictionary\n| entry, or by calling `ndarray.setflags`.\n|\n| The array flags cannot be set arbitrarily:\n|\n| - UPDATEIFCOPY can only be set ``False``.\n| - WRITEBACKIFCOPY can only be set ``False``.\n| - ALIGNED can only be set ``True`` if the data is truly aligned.\n| - WRITEABLE can only be set ``True`` if the array owns its own memory\n| or the ultimate owner of the memory exposes a writeable buffer\n| interface or is a string.\n|\n| Arrays can be both C-style and Fortran-style contiguous simultaneously.\n| This is clear for 1-dimensional arrays, but can also be true for higher\n| dimensional arrays.\n|\n| Even for contiguous arrays a stride for a given dimension\n| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``\n| or the array has no elements.\n| It does *not* generally hold that ``self.strides[-1] == self.itemsize``\n| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for\n| Fortran-style contiguous arrays is true.\n|\n| flat\n| A 1-D iterator over the array.\n|\n| This is a `numpy.flatiter` instance, which acts similarly to, but is not\n| a subclass of, Python's built-in iterator object.\n|\n| See Also\n| --------\n| flatten : Return a copy of the array collapsed into one dimension.\n|\n| flatiter\n|\n| Examples\n| --------\n| >>> x = np.arange(1, 7).reshape(2, 3)\n| >>> x\n| array([[1, 2, 3],\n| [4, 5, 6]])\n| >>> x.flat[3]\n| 4\n| >>> x.T\n| array([[1, 4],\n| [2, 5],\n| [3, 6]])\n| >>> x.T.flat[3]\n| 5\n| >>> type(x.flat)\n| \n|\n| An assignment example:\n|\n| >>> x.flat = 3; x\n| array([[3, 3, 3],\n| [3, 3, 3]])\n| >>> x.flat[[1,4]] = 1; x\n| array([[3, 1, 3],\n| [3, 1, 3]])\n|\n| imag\n| The imaginary part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.imag\n| array([ 0. , 0.70710678])\n| >>> x.imag.dtype\n| dtype('float64')\n|\n| itemsize\n| Length of one array element in bytes.\n|\n| Examples\n| --------\n| >>> x = np.array([1,2,3], dtype=np.float64)\n| >>> x.itemsize\n| 8\n| >>> x = np.array([1,2,3], dtype=np.complex128)\n| >>> x.itemsize\n| 16\n|\n| nbytes\n| Total bytes consumed by the elements of the array.\n|\n| Notes\n| -----\n| Does not include memory consumed by non-element attributes of the\n| array object.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3,5,2), dtype=np.complex128)\n| >>> x.nbytes\n| 480\n| >>> np.prod(x.shape) * x.itemsize\n| 480\n|\n| ndim\n| Number of array dimensions.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> x.ndim\n| 1\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.ndim\n| 3\n|\n| real\n| The real part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.real\n| array([ 1. , 0.70710678])\n| >>> x.real.dtype\n| dtype('float64')\n|\n| See Also\n| --------\n| numpy.real : equivalent function\n|\n| shape\n| Tuple of array dimensions.\n|\n| The shape property is usually used to get the current shape of an array,\n| but may also be used to reshape the array in-place by assigning a tuple of\n| array dimensions to it. As with `numpy.reshape`, one of the new shape\n| dimensions can be -1, in which case its value is inferred from the size of\n| the array and the remaining dimensions. Reshaping an array in-place will\n| fail if a copy is required.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3, 4])\n| >>> x.shape\n| (4,)\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.shape\n| (2, 3, 4)\n| >>> y.shape = (3, 8)\n| >>> y\n| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.]])\n| >>> y.shape = (3, 6)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: total size of new array must be unchanged\n| >>> np.zeros((4,2))[::2].shape = (-1,)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| AttributeError: Incompatible shape for in-place modification. Use\n| `.reshape()` to make a copy with the desired shape.\n|\n| See Also\n| --------\n| numpy.reshape : similar function\n| ndarray.reshape : similar method\n|\n| size\n| Number of elements in the array.\n|\n| Equal to ``np.prod(a.shape)``, i.e., the product of the array's\n| dimensions.\n|\n| Notes\n| -----\n| `a.size` returns a standard arbitrary precision Python integer. This\n| may not be the case with other methods of obtaining the same value\n| (like the suggested ``np.prod(a.shape)``, which returns an instance\n| of ``np.int``), and may be relevant if the value is used further in\n| calculations that may overflow a fixed size integer type.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)\n| >>> x.size\n| 30\n| >>> np.prod(x.shape)\n| 30\n|\n| strides\n| Tuple of bytes to step in each dimension when traversing an array.\n|\n| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`\n| is::\n|\n| offset = sum(np.array(i) * a.strides)\n|\n| A more detailed explanation of strides can be found in the\n| \"ndarray.rst\" file in the NumPy reference guide.\n|\n| Notes\n| -----\n| Imagine an array of 32-bit integers (each 4 bytes)::\n|\n| x = np.array([[0, 1, 2, 3, 4],\n| [5, 6, 7, 8, 9]], dtype=np.int32)\n|\n| This array is stored in memory as 40 bytes, one after the other\n| (known as a contiguous block of memory). The strides of an array tell\n| us how many bytes we have to skip in memory to move to the next position\n| along a certain axis. For example, we have to skip 4 bytes (1 value) to\n| move to the next column, but 20 bytes (5 values) to get to the same\n| position in the next row. As such, the strides for the array `x` will be\n| ``(20, 4)``.\n|\n| See Also\n| --------\n| numpy.lib.stridetricks.asstrided\n|\n| Examples\n| --------\n| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))\n| >>> y\n| array([[[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]],\n| [[12, 13, 14, 15],\n| [16, 17, 18, 19],\n| [20, 21, 22, 23]]])\n| >>> y.strides\n| (48, 16, 4)\n| >>> y[1,1,1]\n| 17\n| >>> offset=sum(y.strides * np.array((1,1,1)))\n| >>> offset/y.itemsize\n| 17\n|\n| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)\n| >>> x.strides\n| (32, 4, 224, 1344)\n| >>> i = np.array([3,5,2,2])\n| >>> offset = sum(i * x.strides)\n| >>> x[3,5,2,2]\n| 813\n| >>> offset / x.itemsize\n| 813\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from ndarray:\n|\n| hash = None\n" }, { "name": "class ndarray", "content": "| ndarray(shape, dtype=float, buffer=None, offset=0,\n| strides=None, order=None)\n|\n| An array object represents a multidimensional, homogeneous array\n| of fixed-size items. An associated data-type object describes the\n| format of each element in the array (its byte-order, how many bytes it\n| occupies in memory, whether it is an integer, a floating point number,\n| or something else, etc.)\n|\n| Arrays should be constructed using `array`, `zeros` or `empty` (refer\n| to the See Also section below). The parameters given here refer to\n| a low-level method (`ndarray(...)`) for instantiating an array.\n|\n| For more information, refer to the `numpy` module and examine the\n| methods and attributes of an array.\n|\n| Parameters\n| ----------\n| (for the new method; see Notes below)\n|\n| shape : tuple of ints\n| Shape of created array.\n| dtype : data-type, optional\n| Any object that can be interpreted as a numpy data type.\n| buffer : object exposing buffer interface, optional\n| Used to fill the array with data.\n| offset : int, optional\n| Offset of array data in buffer.\n| strides : tuple of ints, optional\n| Strides of data in memory.\n| order : {'C', 'F'}, optional\n| Row-major (C-style) or column-major (Fortran-style) order.\n|\n| Attributes\n| ----------\n| T : ndarray\n| Transpose of the array.\n| data : buffer\n| The array's elements, in memory.\n| dtype : dtype object\n| Describes the format of the elements in the array.\n| flags : dict\n| Dictionary containing information related to memory use, e.g.,\n| 'CCONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.\n| flat : numpy.flatiter object\n| Flattened version of the array as an iterator. The iterator\n| allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for\n| assignment examples; TODO).\n| imag : ndarray\n| Imaginary part of the array.\n| real : ndarray\n| Real part of the array.\n| size : int\n| Number of elements in the array.\n| itemsize : int\n| The memory use of each array element in bytes.\n| nbytes : int\n| The total number of bytes required to store the array data,\n| i.e., ``itemsize * size``.\n| ndim : int\n| The array's number of dimensions.\n| shape : tuple of ints\n| Shape of the array.\n| strides : tuple of ints\n| The step-size required to move from one element to the next in\n| memory. For example, a contiguous ``(3, 4)`` array of type\n| ``int16`` in C-order has strides ``(8, 2)``. This implies that\n| to move from element to element in memory requires jumps of 2 bytes.\n| To move from row-to-row, one needs to jump 8 bytes at a time\n| (``2 * 4``).\n| ctypes : ctypes object\n| Class containing properties of the array needed for interaction\n| with ctypes.\n| base : ndarray\n| If the array is a view into another array, that array is its `base`\n| (unless that array is also a view). The `base` array is where the\n| array data is actually stored.\n|\n| See Also\n| --------\n| array : Construct an array.\n| zeros : Create an array, each element of which is zero.\n| empty : Create an array, but leave its allocated memory unchanged (i.e.,\n| it contains \"garbage\").\n| dtype : Create a data-type.\n| numpy.typing.NDArray : A :term:`generic ` version\n| of ndarray.\n|\n| Notes\n| -----\n| There are two modes of creating an array using ``new``:\n|\n| 1. If `buffer` is None, then only `shape`, `dtype`, and `order`\n| are used.\n| 2. If `buffer` is an object exposing the buffer interface, then\n| all keywords are interpreted.\n|\n| No ``init`` method is needed because the array is fully initialized\n| after the ``new`` method.\n|\n| Examples\n| --------\n| These examples illustrate the low-level `ndarray` constructor. Refer\n| to the `See Also` section above for easier ways of constructing an\n| ndarray.\n|\n| First mode, `buffer` is None:\n|\n| >>> np.ndarray(shape=(2,2), dtype=float, order='F')\n| array([[0.0e+000, 0.0e+000], # random\n| [ nan, 2.5e-323]])\n|\n| Second mode:\n|\n| >>> np.ndarray((2,), buffer=np.array([1,2,3]),\n| ... offset=np.int().itemsize,\n| ... dtype=int) # offset = 1*itemsize, i.e. skip first element\n| array([2, 3])\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| a.array([dtype], /) -> reference if type unchanged, copy otherwise.\n|\n| Returns either a new reference to self if dtype is not given or a new array\n| of provided data type if dtype is different from the current dtype of the\n| array.\n|\n| arrayfunction(...)\n|\n| arrayprepare(...)\n| a.arrayprepare(obj) -> Object of same type as ndarray object obj.\n|\n| arrayufunc(...)\n|\n| arraywrap(...)\n| a.arraywrap(obj) -> Object of same type as ndarray object a.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| copy(...)\n| a.copy()\n|\n| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.\n|\n| Equivalent to ``a.copy(order='K')``.\n|\n| deepcopy(...)\n| a.deepcopy(memo, /) -> Deep copy of array.\n|\n| Used if :func:`copy.deepcopy` is called on an array.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| Default object formatter.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| iadd(self, value, /)\n| Return self+=value.\n|\n| iand(self, value, /)\n| Return self&=value.\n|\n| ifloordiv(self, value, /)\n| Return self//=value.\n|\n| ilshift(self, value, /)\n| Return self<<=value.\n|\n| imatmul(self, value, /)\n| Return self@=value.\n|\n| imod(self, value, /)\n| Return self%=value.\n|\n| imul(self, value, /)\n| Return self*=value.\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| ipow(self, value, /)\n| Return self=value.\n|\n| irshift(self, value, /)\n| Return self>>=value.\n|\n| isub(self, value, /)\n| Return self-=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| itruediv(self, value, /)\n| Return self/=value.\n|\n| ixor(self, value, /)\n| Return self^=value.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setitem(self, key, value, /)\n| Set self[key] to value.\n|\n| setstate(...)\n| a.setstate(state, /)\n|\n| For unpickling.\n|\n| The `state` argument must be a sequence that contains the following\n| elements:\n|\n| Parameters\n| ----------\n| version : int\n| optional pickle version. If omitted defaults to 0.\n| shape : tuple\n| dtype : data-type\n| isFortran : bool\n| rawdata : string or list\n| a binary string with the data (or a list if 'a' is an object array)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| a.all(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if all elements evaluate to True.\n|\n| Refer to `numpy.all` for full documentation.\n|\n| See Also\n| --------\n| numpy.all : equivalent function\n|\n| any(...)\n| a.any(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if any of the elements of `a` evaluate to True.\n|\n| Refer to `numpy.any` for full documentation.\n|\n| See Also\n| --------\n| numpy.any : equivalent function\n|\n| argmax(...)\n| a.argmax(axis=None, out=None)\n|\n| Return indices of the maximum values along the given axis.\n|\n| Refer to `numpy.argmax` for full documentation.\n|\n| See Also\n| --------\n| numpy.argmax : equivalent function\n|\n| argmin(...)\n| a.argmin(axis=None, out=None)\n|\n| Return indices of the minimum values along the given axis.\n|\n| Refer to `numpy.argmin` for detailed documentation.\n|\n| See Also\n| --------\n| numpy.argmin : equivalent function\n|\n| argpartition(...)\n| a.argpartition(kth, axis=-1, kind='introselect', order=None)\n|\n| Returns the indices that would partition this array.\n|\n| Refer to `numpy.argpartition` for full documentation.\n|\n| .. versionadded:: 1.8.0\n|\n| See Also\n| --------\n| numpy.argpartition : equivalent function\n|\n| argsort(...)\n| a.argsort(axis=-1, kind=None, order=None)\n|\n| Returns the indices that would sort this array.\n|\n| Refer to `numpy.argsort` for full documentation.\n|\n| See Also\n| --------\n| numpy.argsort : equivalent function\n|\n| astype(...)\n| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)\n|\n| Copy of the array, cast to a specified type.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| Typecode or data-type to which the array is cast.\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout order of the result.\n| 'C' means C order, 'F' means Fortran order, 'A'\n| means 'F' order if all the arrays are Fortran contiguous,\n| 'C' order otherwise, and 'K' means as close to the\n| order the array elements appear in memory as possible.\n| Default is 'K'.\n| casting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\n| Controls what kind of data casting may occur. Defaults to 'unsafe'\n| for backwards compatibility.\n|\n| * 'no' means the data types should not be cast at all.\n| * 'equiv' means only byte-order changes are allowed.\n| * 'safe' means only casts which can preserve values are allowed.\n| * 'samekind' means only safe casts or casts within a kind,\n| like float64 to float32, are allowed.\n| * 'unsafe' means any data conversions may be done.\n| subok : bool, optional\n| If True, then sub-classes will be passed-through (default), otherwise\n| the returned array will be forced to be a base-class array.\n| copy : bool, optional\n| By default, astype always returns a newly allocated array. If this\n| is set to false, and the `dtype`, `order`, and `subok`\n| requirements are satisfied, the input array is returned instead\n| of a copy.\n|\n| Returns\n| -------\n| arrt : ndarray\n| Unless `copy` is False and the other conditions for returning the input\n| array are satisfied (see description for `copy` input parameter), `arrt`\n| is a new array of the same shape as the input array, with dtype, order\n| given by `dtype`, `order`.\n|\n| Notes\n| -----\n| .. versionchanged:: 1.17.0\n| Casting between a simple data type and a structured one is possible only\n| for \"unsafe\" casting. Casting to multiple fields is allowed, but\n| casting from multiple fields is not.\n|\n| .. versionchanged:: 1.9.0\n| Casting from numeric to string types in 'safe' casting mode requires\n| that the string dtype length is long enough to store the max\n| integer/float value converted.\n|\n| Raises\n| ------\n| ComplexWarning\n| When casting from complex to float or int. To avoid this,\n| one should use ``a.real.astype(t)``.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 2.5])\n| >>> x\n| array([1. , 2. , 2.5])\n|\n| >>> x.astype(int)\n| array([1, 2, 2])\n|\n| byteswap(...)\n| a.byteswap(inplace=False)\n|\n| Swap the bytes of the array elements\n|\n| Toggle between low-endian and big-endian data representation by\n| returning a byteswapped array, optionally swapped in-place.\n| Arrays of byte-strings are not swapped. The real and imaginary\n| parts of a complex number are swapped individually.\n|\n| Parameters\n| ----------\n| inplace : bool, optional\n| If ``True``, swap bytes in-place, default is ``False``.\n|\n| Returns\n| -------\n| out : ndarray\n| The byteswapped array. If `inplace` is ``True``, this is\n| a view to self.\n|\n| Examples\n| --------\n| >>> A = np.array([1, 256, 8755], dtype=np.int16)\n| >>> list(map(hex, A))\n| ['0x1', '0x100', '0x2233']\n| >>> A.byteswap(inplace=True)\n| array([ 256, 1, 13090], dtype=int16)\n| >>> list(map(hex, A))\n| ['0x100', '0x1', '0x3322']\n|\n| Arrays of byte-strings are not swapped\n|\n| >>> A = np.array([b'ceg', b'fac'])\n| >>> A.byteswap()\n| array([b'ceg', b'fac'], dtype='|S3')\n|\n| ``A.newbyteorder().byteswap()`` produces an array with the same values\n| but different representation in memory\n|\n| >>> A = np.array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,\n| 0, 0], dtype=uint8)\n| >>> A.newbyteorder().byteswap(inplace=True)\n| array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,\n| 0, 3], dtype=uint8)\n|\n| choose(...)\n| a.choose(choices, out=None, mode='raise')\n|\n| Use an index array to construct a new array from a set of choices.\n|\n| Refer to `numpy.choose` for full documentation.\n|\n| See Also\n| --------\n| numpy.choose : equivalent function\n|\n| clip(...)\n| a.clip(min=None, max=None, out=None, kwargs)\n|\n| Return an array whose values are limited to ``[min, max]``.\n| One of max or min must be given.\n|\n| Refer to `numpy.clip` for full documentation.\n|\n| See Also\n| --------\n| numpy.clip : equivalent function\n|\n| compress(...)\n| a.compress(condition, axis=None, out=None)\n|\n| Return selected slices of this array along given axis.\n|\n| Refer to `numpy.compress` for full documentation.\n|\n| See Also\n| --------\n| numpy.compress : equivalent function\n|\n| conj(...)\n| a.conj()\n|\n| Complex-conjugate all elements.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| conjugate(...)\n| a.conjugate()\n|\n| Return the complex conjugate, element-wise.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| copy(...)\n| a.copy(order='C')\n|\n| Return a copy of the array.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout of the copy. 'C' means C-order,\n| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n| 'C' otherwise. 'K' means match the layout of `a` as closely\n| as possible. (Note that this function and :func:`numpy.copy` are very\n| similar but have different default values for their order=\n| arguments, and this function always passes sub-classes through.)\n|\n| See also\n| --------\n| numpy.copy : Similar function with different default behavior\n| numpy.copyto\n|\n| Notes\n| -----\n| This function is the preferred method for creating an array copy. The\n| function :func:`numpy.copy` is similar, but it defaults to using order 'K',\n| and will not pass sub-classes through by default.\n|\n| Examples\n| --------\n| >>> x = np.array([[1,2,3],[4,5,6]], order='F')\n|\n| >>> y = x.copy()\n|\n| >>> x.fill(0)\n|\n| >>> x\n| array([[0, 0, 0],\n| [0, 0, 0]])\n|\n| >>> y\n| array([[1, 2, 3],\n| [4, 5, 6]])\n|\n| >>> y.flags['CCONTIGUOUS']\n| True\n|\n| cumprod(...)\n| a.cumprod(axis=None, dtype=None, out=None)\n|\n| Return the cumulative product of the elements along the given axis.\n|\n| Refer to `numpy.cumprod` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumprod : equivalent function\n|\n| cumsum(...)\n| a.cumsum(axis=None, dtype=None, out=None)\n|\n| Return the cumulative sum of the elements along the given axis.\n|\n| Refer to `numpy.cumsum` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumsum : equivalent function\n|\n| diagonal(...)\n| a.diagonal(offset=0, axis1=0, axis2=1)\n|\n| Return specified diagonals. In NumPy 1.9 the returned array is a\n| read-only view instead of a copy as in previous NumPy versions. In\n| a future version the read-only restriction will be removed.\n|\n| Refer to :func:`numpy.diagonal` for full documentation.\n|\n| See Also\n| --------\n| numpy.diagonal : equivalent function\n|\n| dot(...)\n| a.dot(b, out=None)\n|\n| Dot product of two arrays.\n|\n| Refer to `numpy.dot` for full documentation.\n|\n| See Also\n| --------\n| numpy.dot : equivalent function\n|\n| Examples\n| --------\n| >>> a = np.eye(2)\n| >>> b = np.ones((2, 2)) * 2\n| >>> a.dot(b)\n| array([[2., 2.],\n| [2., 2.]])\n|\n| This array method can be conveniently chained:\n|\n| >>> a.dot(b).dot(b)\n| array([[8., 8.],\n| [8., 8.]])\n|\n| dump(...)\n| a.dump(file)\n|\n| Dump a pickle of the array to the specified file.\n| The array can be read back with pickle.load or numpy.load.\n|\n| Parameters\n| ----------\n| file : str or Path\n| A string naming the dump file.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| dumps(...)\n| a.dumps()\n|\n| Returns the pickle of the array as a string.\n| pickle.loads or numpy.loads will convert the string back to an array.\n|\n| Parameters\n| ----------\n| None\n|\n| fill(...)\n| a.fill(value)\n|\n| Fill the array with a scalar value.\n|\n| Parameters\n| ----------\n| value : scalar\n| All elements of `a` will be assigned this value.\n|\n| Examples\n| --------\n| >>> a = np.array([1, 2])\n| >>> a.fill(0)\n| >>> a\n| array([0, 0])\n| >>> a = np.empty(2)\n| >>> a.fill(1)\n| >>> a\n| array([1., 1.])\n|\n| flatten(...)\n| a.flatten(order='C')\n|\n| Return a copy of the array collapsed into one dimension.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| 'C' means to flatten in row-major (C-style) order.\n| 'F' means to flatten in column-major (Fortran-\n| style) order. 'A' means to flatten in column-major\n| order if `a` is Fortran *contiguous* in memory,\n| row-major order otherwise. 'K' means to flatten\n| `a` in the order the elements occur in memory.\n| The default is 'C'.\n|\n| Returns\n| -------\n| y : ndarray\n| A copy of the input array, flattened to one dimension.\n|\n| See Also\n| --------\n| ravel : Return a flattened array.\n| flat : A 1-D flat iterator over the array.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,2], [3,4]])\n| >>> a.flatten()\n| array([1, 2, 3, 4])\n| >>> a.flatten('F')\n| array([1, 3, 2, 4])\n|\n| getfield(...)\n| a.getfield(dtype, offset=0)\n|\n| Returns a field of the given array as a certain type.\n|\n| A field is a view of the array data with a given data-type. The values in\n| the view are determined by the given type and the offset into the current\n| array in bytes. The offset needs to be such that the view dtype fits in the\n| array dtype; for example an array of dtype complex128 has 16-byte elements.\n| If taking a view with a 32-bit integer (4 bytes), the offset needs to be\n| between 0 and 12 bytes.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| The data type of the view. The dtype size of the view can not be larger\n| than that of the array itself.\n| offset : int\n| Number of bytes to skip before beginning the element view.\n|\n| Examples\n| --------\n| >>> x = np.diag([1.+1.j]*2)\n| >>> x[1, 1] = 2 + 4.j\n| >>> x\n| array([[1.+1.j, 0.+0.j],\n| [0.+0.j, 2.+4.j]])\n| >>> x.getfield(np.float64)\n| array([[1., 0.],\n| [0., 2.]])\n|\n| By choosing an offset of 8 bytes we can select the complex part of the\n| array for our view:\n|\n| >>> x.getfield(np.float64, offset=8)\n| array([[1., 0.],\n| [0., 4.]])\n|\n| item(...)\n| a.item(*args)\n|\n| Copy an element of an array to a standard Python scalar and return it.\n|\n| Parameters\n| ----------\n| \\*args : Arguments (variable number and type)\n|\n| * none: in this case, the method only works for arrays\n| with one element (`a.size == 1`), which element is\n| copied into a standard Python scalar object and returned.\n|\n| * inttype: this argument is interpreted as a flat index into\n| the array, specifying which element to copy and return.\n|\n| * tuple of inttypes: functions as does a single inttype argument,\n| except that the argument is interpreted as an nd-index into the\n| array.\n|\n| Returns\n| -------\n| z : Standard Python scalar object\n| A copy of the specified element of the array as a suitable\n| Python scalar\n|\n| Notes\n| -----\n| When the data type of `a` is longdouble or clongdouble, item() returns\n| a scalar array object because there is no available Python scalar that\n| would not lose information. Void arrays return a buffer object for item(),\n| unless fields are defined, in which case a tuple is returned.\n|\n| `item` is very similar to a[args], except, instead of an array scalar,\n| a standard Python scalar is returned. This can be useful for speeding up\n| access to elements of the array and doing arithmetic on elements of the\n| array using Python's optimized math.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.item(3)\n| 1\n| >>> x.item(7)\n| 0\n| >>> x.item((0, 1))\n| 2\n| >>> x.item((2, 2))\n| 1\n|\n| itemset(...)\n| a.itemset(*args)\n|\n| Insert scalar into an array (scalar is cast to array's dtype, if possible)\n|\n| There must be at least 1 argument, and define the last argument\n| as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster\n| than ``a[args] = item``. The item should be a scalar value and `args`\n| must select a single item in the array `a`.\n|\n| Parameters\n| ----------\n| \\*args : Arguments\n| If one argument: a scalar, only used in case `a` is of size 1.\n| If two arguments: the last argument is the value to be set\n| and must be a scalar, the first argument specifies a single array\n| element location. It is either an int or a tuple.\n|\n| Notes\n| -----\n| Compared to indexing syntax, `itemset` provides some speed increase\n| for placing a scalar into a particular location in an `ndarray`,\n| if you must do this. However, generally this is discouraged:\n| among other problems, it complicates the appearance of the code.\n| Also, when using `itemset` (and `item`) inside a loop, be sure\n| to assign the methods to a local variable to avoid the attribute\n| look-up at each loop iteration.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.itemset(4, 0)\n| >>> x.itemset((2, 2), 9)\n| >>> x\n| array([[2, 2, 6],\n| [1, 0, 6],\n| [1, 0, 9]])\n|\n| max(...)\n| a.max(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the maximum along a given axis.\n|\n| Refer to `numpy.amax` for full documentation.\n|\n| See Also\n| --------\n| numpy.amax : equivalent function\n|\n| mean(...)\n| a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)\n|\n| Returns the average of the array elements along given axis.\n|\n| Refer to `numpy.mean` for full documentation.\n|\n| See Also\n| --------\n| numpy.mean : equivalent function\n|\n| min(...)\n| a.min(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the minimum along a given axis.\n|\n| Refer to `numpy.amin` for full documentation.\n|\n| See Also\n| --------\n| numpy.amin : equivalent function\n|\n| newbyteorder(...)\n| arr.newbyteorder(neworder='S', /)\n|\n| Return the array with the same data viewed with a different byte order.\n|\n| Equivalent to::\n|\n| arr.view(arr.dtype.newbytorder(neworder))\n|\n| Changes are also made in all fields and sub-arrays of the array data\n| type.\n|\n|\n|\n| Parameters\n| ----------\n| neworder : string, optional\n| Byte order to force; a value from the byte order specifications\n| below. `neworder` codes can be any of:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order, equivalent to `sys.byteorder`\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newarr : array\n| New array object with the dtype reflecting given change to the\n| byte order.\n|\n| nonzero(...)\n| a.nonzero()\n|\n| Return the indices of the elements that are non-zero.\n|\n| Refer to `numpy.nonzero` for full documentation.\n|\n| See Also\n| --------\n| numpy.nonzero : equivalent function\n|\n| partition(...)\n| a.partition(kth, axis=-1, kind='introselect', order=None)\n|\n| Rearranges the elements in the array in such a way that the value of the\n| element in kth position is in the position it would be in a sorted array.\n| All elements smaller than the kth element are moved before this element and\n| all equal or greater are moved behind it. The ordering of the elements in\n| the two partitions is undefined.\n|\n| .. versionadded:: 1.8.0\n|\n| Parameters\n| ----------\n| kth : int or sequence of ints\n| Element index to partition by. The kth element value will be in its\n| final sorted position and all smaller elements will be moved before it\n| and all equal or greater elements behind it.\n| The order of all elements in the partitions is undefined.\n| If provided with a sequence of kth it will partition all elements\n| indexed by kth of them into their sorted position at once.\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'introselect'}, optional\n| Selection algorithm. Default is 'introselect'.\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need to be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.partition : Return a parititioned copy of an array.\n| argpartition : Indirect partition.\n| sort : Full sort.\n|\n| Notes\n| -----\n| See ``np.partition`` for notes on the different algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([3, 4, 2, 1])\n| >>> a.partition(3)\n| >>> a\n| array([2, 1, 3, 4])\n|\n| >>> a.partition((1, 3))\n| >>> a\n| array([1, 2, 3, 4])\n|\n| prod(...)\n| a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)\n|\n| Return the product of the array elements over the given axis\n|\n| Refer to `numpy.prod` for full documentation.\n|\n| See Also\n| --------\n| numpy.prod : equivalent function\n|\n| ptp(...)\n| a.ptp(axis=None, out=None, keepdims=False)\n|\n| Peak to peak (maximum - minimum) value along a given axis.\n|\n| Refer to `numpy.ptp` for full documentation.\n|\n| See Also\n| --------\n| numpy.ptp : equivalent function\n|\n| put(...)\n| a.put(indices, values, mode='raise')\n|\n| Set ``a.flat[n] = values[n]`` for all `n` in indices.\n|\n| Refer to `numpy.put` for full documentation.\n|\n| See Also\n| --------\n| numpy.put : equivalent function\n|\n| ravel(...)\n| a.ravel([order])\n|\n| Return a flattened array.\n|\n| Refer to `numpy.ravel` for full documentation.\n|\n| See Also\n| --------\n| numpy.ravel : equivalent function\n|\n| ndarray.flat : a flat iterator on the array.\n|\n| repeat(...)\n| a.repeat(repeats, axis=None)\n|\n| Repeat elements of an array.\n|\n| Refer to `numpy.repeat` for full documentation.\n|\n| See Also\n| --------\n| numpy.repeat : equivalent function\n|\n| reshape(...)\n| a.reshape(shape, order='C')\n|\n| Returns an array containing the same data with a new shape.\n|\n| Refer to `numpy.reshape` for full documentation.\n|\n| See Also\n| --------\n| numpy.reshape : equivalent function\n|\n| Notes\n| -----\n| Unlike the free function `numpy.reshape`, this method on `ndarray` allows\n| the elements of the shape parameter to be passed in as separate arguments.\n| For example, ``a.reshape(10, 11)`` is equivalent to\n| ``a.reshape((10, 11))``.\n|\n| resize(...)\n| a.resize(newshape, refcheck=True)\n|\n| Change shape and size of array in-place.\n|\n| Parameters\n| ----------\n| newshape : tuple of ints, or `n` ints\n| Shape of resized array.\n| refcheck : bool, optional\n| If False, reference count will not be checked. Default is True.\n|\n| Returns\n| -------\n| None\n|\n| Raises\n| ------\n| ValueError\n| If `a` does not own its own data or references or views to it exist,\n| and the data memory must be changed.\n| PyPy only: will always raise if the data memory must be changed, since\n| there is no reliable way to determine if references or views to it\n| exist.\n|\n| SystemError\n| If the `order` keyword argument is specified. This behaviour is a\n| bug in NumPy.\n|\n| See Also\n| --------\n| resize : Return a new array with the specified shape.\n|\n| Notes\n| -----\n| This reallocates space for the data area if necessary.\n|\n| Only contiguous arrays (data elements consecutive in memory) can be\n| resized.\n|\n| The purpose of the reference count check is to make sure you\n| do not use this array as a buffer for another Python object and then\n| reallocate the memory. However, reference counts can increase in\n| other ways so if you are sure that you have not shared the memory\n| for this array with another Python object, then you may safely set\n| `refcheck` to False.\n|\n| Examples\n| --------\n| Shrinking an array: array is flattened (in the order that the data are\n| stored in memory), resized, and reshaped:\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='C')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [1]])\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='F')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [2]])\n|\n| Enlarging an array: as above, but missing entries are filled with zeros:\n|\n| >>> b = np.array([[0, 1], [2, 3]])\n| >>> b.resize(2, 3) # newshape parameter doesn't have to be a tuple\n| >>> b\n| array([[0, 1, 2],\n| [3, 0, 0]])\n|\n| Referencing an array prevents resizing...\n|\n| >>> c = a\n| >>> a.resize((1, 1))\n| Traceback (most recent call last):\n| ...\n| ValueError: cannot resize an array that references or is referenced ...\n|\n| Unless `refcheck` is False:\n|\n| >>> a.resize((1, 1), refcheck=False)\n| >>> a\n| array([[0]])\n| >>> c\n| array([[0]])\n|\n| round(...)\n| a.round(decimals=0, out=None)\n|\n| Return `a` with each element rounded to the given number of decimals.\n|\n| Refer to `numpy.around` for full documentation.\n|\n| See Also\n| --------\n| numpy.around : equivalent function\n|\n| searchsorted(...)\n| a.searchsorted(v, side='left', sorter=None)\n|\n| Find indices where elements of v should be inserted in a to maintain order.\n|\n| For full documentation, see `numpy.searchsorted`\n|\n| See Also\n| --------\n| numpy.searchsorted : equivalent function\n|\n| setfield(...)\n| a.setfield(val, dtype, offset=0)\n|\n| Put a value into a specified place in a field defined by a data-type.\n|\n| Place `val` into `a`'s field defined by `dtype` and beginning `offset`\n| bytes into the field.\n|\n| Parameters\n| ----------\n| val : object\n| Value to be placed in field.\n| dtype : dtype object\n| Data-type of the field in which to place `val`.\n| offset : int, optional\n| The number of bytes into the field at which to place `val`.\n|\n| Returns\n| -------\n| None\n|\n| See Also\n| --------\n| getfield\n|\n| Examples\n| --------\n| >>> x = np.eye(3)\n| >>> x.getfield(np.float64)\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n| >>> x.setfield(3, np.int32)\n| >>> x.getfield(np.int32)\n| array([[3, 3, 3],\n| [3, 3, 3],\n| [3, 3, 3]], dtype=int32)\n| >>> x\n| array([[1.0e+000, 1.5e-323, 1.5e-323],\n| [1.5e-323, 1.0e+000, 1.5e-323],\n| [1.5e-323, 1.5e-323, 1.0e+000]])\n| >>> x.setfield(np.eye(3), np.int32)\n| >>> x\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n|\n| setflags(...)\n| a.setflags(write=None, align=None, uic=None)\n|\n| Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),\n| respectively.\n|\n| These Boolean-valued flags affect how numpy interprets the memory\n| area used by `a` (see Notes below). The ALIGNED flag can only\n| be set to True if the data is actually aligned according to the type.\n| The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set\n| to True. The flag WRITEABLE can only be set to True if the array owns its\n| own memory, or the ultimate owner of the memory exposes a writeable buffer\n| interface, or is a string. (The exception for string is made so that\n| unpickling can be done without copying memory.)\n|\n| Parameters\n| ----------\n| write : bool, optional\n| Describes whether or not `a` can be written to.\n| align : bool, optional\n| Describes whether or not `a` is aligned properly for its type.\n| uic : bool, optional\n| Describes whether or not `a` is a copy of another \"base\" array.\n|\n| Notes\n| -----\n| Array flags provide information about how the memory area used\n| for the array is to be interpreted. There are 7 Boolean flags\n| in use, only four of which can be changed by the user:\n| WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.\n|\n| WRITEABLE (W) the data area can be written to;\n|\n| ALIGNED (A) the data and strides are aligned appropriately for the hardware\n| (as determined by the compiler);\n|\n| UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;\n|\n| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced\n| by .base). When the C-API function PyArrayResolveWritebackIfCopy is\n| called, the base array will be updated with the contents of this array.\n|\n| All flags can be accessed using the single (upper case) letter as well\n| as the full name.\n|\n| Examples\n| --------\n| >>> y = np.array([[3, 1, 7],\n| ... [2, 0, 0],\n| ... [8, 5, 9]])\n| >>> y\n| array([[3, 1, 7],\n| [2, 0, 0],\n| [8, 5, 9]])\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : True\n| ALIGNED : True\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(write=0, align=0)\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : False\n| ALIGNED : False\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(uic=1)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: cannot set WRITEBACKIFCOPY flag to True\n|\n| sort(...)\n| a.sort(axis=-1, kind=None, order=None)\n|\n| Sort an array in-place. Refer to `numpy.sort` for full documentation.\n|\n| Parameters\n| ----------\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'\n| and 'mergesort' use timsort under the covers and, in general, the\n| actual implementation will vary with datatype. The 'mergesort' option\n| is retained for backwards compatibility.\n|\n| .. versionchanged:: 1.15.0\n| The 'stable' option was added.\n|\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.sort : Return a sorted copy of an array.\n| numpy.argsort : Indirect sort.\n| numpy.lexsort : Indirect stable sort on multiple keys.\n| numpy.searchsorted : Find elements in sorted array.\n| numpy.partition: Partial sort.\n|\n| Notes\n| -----\n| See `numpy.sort` for notes on the different sorting algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,4], [3,1]])\n| >>> a.sort(axis=1)\n| >>> a\n| array([[1, 4],\n| [1, 3]])\n| >>> a.sort(axis=0)\n| >>> a\n| array([[1, 3],\n| [1, 4]])\n|\n| Use the `order` keyword to specify a field to use when sorting a\n| structured array:\n|\n| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])\n| >>> a.sort(order='y')\n| >>> a\n| array([(b'c', 1), (b'a', 2)],\n| dtype=[('x', 'S1'), ('y', '>> x = np.array([[0, 1], [2, 3]], dtype='>> x.tobytes()\n| b'\\x00\\x00\\x01\\x00\\x02\\x00\\x03\\x00'\n| >>> x.tobytes('C') == x.tobytes()\n| True\n| >>> x.tobytes('F')\n| b'\\x00\\x00\\x02\\x00\\x01\\x00\\x03\\x00'\n|\n| tofile(...)\n| a.tofile(fid, sep=\"\", format=\"%s\")\n|\n| Write array to a file as text or binary (default).\n|\n| Data is always written in 'C' order, independent of the order of `a`.\n| The data produced by this method can be recovered using the function\n| fromfile().\n|\n| Parameters\n| ----------\n| fid : file or str or Path\n| An open file object, or a string containing a filename.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| sep : str\n| Separator between array items for text output.\n| If \"\" (empty), a binary file is written, equivalent to\n| ``file.write(a.tobytes())``.\n| format : str\n| Format string for text file output.\n| Each entry in the array is formatted to text by first converting\n| it to the closest Python type, and then using \"format\" % item.\n|\n| Notes\n| -----\n| This is a convenience function for quick storage of array data.\n| Information on endianness and precision is lost, so this method is not a\n| good choice for files intended to archive data or transport data between\n| machines with different endianness. Some of these problems can be overcome\n| by outputting the data as text files, at the expense of speed and file\n| size.\n|\n| When fid is a file object, array contents are directly written to the\n| file, bypassing the file object's ``write`` method. As a result, tofile\n| cannot be used with files objects supporting compression (e.g., GzipFile)\n| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).\n|\n| tolist(...)\n| a.tolist()\n|\n| Return the array as an ``a.ndim``-levels deep nested list of Python scalars.\n|\n| Return a copy of the array data as a (nested) Python list.\n| Data items are converted to the nearest compatible builtin Python type, via\n| the `~numpy.ndarray.item` function.\n|\n| If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will\n| not be a list at all, but a simple Python scalar.\n|\n| Parameters\n| ----------\n| none\n|\n| Returns\n| -------\n| y : object, or list of object, or list of list of object, or ...\n| The possibly nested list of array elements.\n|\n| Notes\n| -----\n| The array may be recreated via ``a = np.array(a.tolist())``, although this\n| may sometimes lose precision.\n|\n| Examples\n| --------\n| For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,\n| except that ``tolist`` changes numpy scalars to Python scalars:\n|\n| >>> a = np.uint32([1, 2])\n| >>> alist = list(a)\n| >>> alist\n| [1, 2]\n| >>> type(alist[0])\n| \n| >>> atolist = a.tolist()\n| >>> atolist\n| [1, 2]\n| >>> type(atolist[0])\n| \n|\n| Additionally, for a 2D array, ``tolist`` applies recursively:\n|\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> list(a)\n| [array([1, 2]), array([3, 4])]\n| >>> a.tolist()\n| [[1, 2], [3, 4]]\n|\n| The base case for this recursion is a 0D array:\n|\n| >>> a = np.array(1)\n| >>> list(a)\n| Traceback (most recent call last):\n| ...\n| TypeError: iteration over a 0-d array\n| >>> a.tolist()\n| 1\n|\n| tostring(...)\n| a.tostring(order='C')\n|\n| A compatibility alias for `tobytes`, with exactly the same behavior.\n|\n| Despite its name, it returns `bytes` not `str`\\ s.\n|\n| .. deprecated:: 1.19.0\n|\n| trace(...)\n| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n|\n| Return the sum along diagonals of the array.\n|\n| Refer to `numpy.trace` for full documentation.\n|\n| See Also\n| --------\n| numpy.trace : equivalent function\n|\n| transpose(...)\n| a.transpose(*axes)\n|\n| Returns a view of the array with axes transposed.\n|\n| For a 1-D array this has no effect, as a transposed vector is simply the\n| same vector. To convert a 1-D array into a 2D column vector, an additional\n| dimension must be added. `np.atleast2d(a).T` achieves this, as does\n| `a[:, np.newaxis]`.\n| For a 2-D array, this is a standard matrix transpose.\n| For an n-D array, if axes are given, their order indicates how the\n| axes are permuted (see Examples). If axes are not provided and\n| ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then\n| ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.\n|\n| Parameters\n| ----------\n| axes : None, tuple of ints, or `n` ints\n|\n| * None or no argument: reverses the order of the axes.\n|\n| * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s\n| `i`-th axis becomes `a.transpose()`'s `j`-th axis.\n|\n| * `n` ints: same as an n-tuple of the same ints (this form is\n| intended simply as a \"convenience\" alternative to the tuple form)\n|\n| Returns\n| -------\n| out : ndarray\n| View of `a`, with axes suitably permuted.\n|\n| See Also\n| --------\n| transpose : Equivalent function\n| ndarray.T : Array property returning the array transposed.\n| ndarray.reshape : Give a new shape to an array without changing its data.\n|\n| Examples\n| --------\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> a\n| array([[1, 2],\n| [3, 4]])\n| >>> a.transpose()\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose((1, 0))\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose(1, 0)\n| array([[1, 3],\n| [2, 4]])\n|\n| var(...)\n| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)\n|\n| Returns the variance of the array elements, along given axis.\n|\n| Refer to `numpy.var` for full documentation.\n|\n| See Also\n| --------\n| numpy.var : equivalent function\n|\n| view(...)\n| a.view([dtype][, type])\n|\n| New view of array with the same data.\n|\n| .. note::\n| Passing None for ``dtype`` is different from omitting the parameter,\n| since the former invokes ``dtype(None)`` which is an alias for\n| ``dtype('float')``.\n|\n| Parameters\n| ----------\n| dtype : data-type or ndarray sub-class, optional\n| Data-type descriptor of the returned view, e.g., float32 or int16.\n| Omitting it results in the view having the same data-type as `a`.\n| This argument can also be specified as an ndarray sub-class, which\n| then specifies the type of the returned object (this is equivalent to\n| setting the ``type`` parameter).\n| type : Python type, optional\n| Type of the returned view, e.g., ndarray or matrix. Again, omission\n| of the parameter results in type preservation.\n|\n| Notes\n| -----\n| ``a.view()`` is used two different ways:\n|\n| ``a.view(somedtype)`` or ``a.view(dtype=somedtype)`` constructs a view\n| of the array's memory with a different data-type. This can cause a\n| reinterpretation of the bytes of memory.\n|\n| ``a.view(ndarraysubclass)`` or ``a.view(type=ndarraysubclass)`` just\n| returns an instance of `ndarraysubclass` that looks at the same array\n| (same shape, dtype, etc.) This does not cause a reinterpretation of the\n| memory.\n|\n| For ``a.view(somedtype)``, if ``somedtype`` has a different number of\n| bytes per entry than the previous dtype (for example, converting a\n| regular array to a structured array), then the behavior of the view\n| cannot be predicted just from the superficial appearance of ``a`` (shown\n| by ``print(a)``). It also depends on exactly how ``a`` is stored in\n| memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus\n| defined as a slice or transpose, etc., the view may give different\n| results.\n|\n|\n| Examples\n| --------\n| >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])\n|\n| Viewing array data using a different type and dtype:\n|\n| >>> y = x.view(dtype=np.int16, type=np.matrix)\n| >>> y\n| matrix([[513]], dtype=int16)\n| >>> print(type(y))\n| \n|\n| Creating a view on a structured array so it can be used in calculations\n|\n| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])\n| >>> xv = x.view(dtype=np.int8).reshape(-1,2)\n| >>> xv\n| array([[1, 2],\n| [3, 4]], dtype=int8)\n| >>> xv.mean(0)\n| array([2., 3.])\n|\n| Making changes to the view changes the underlying array\n|\n| >>> xv[0,1] = 20\n| >>> x\n| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])\n|\n| Using a view to convert an array to a recarray:\n|\n| >>> z = x.view(np.recarray)\n| >>> z.a\n| array([1, 3], dtype=int8)\n|\n| Views share data:\n|\n| >>> x[0] = (9, 10)\n| >>> z[0]\n| (9, 10)\n|\n| Views that change the dtype size (bytes per entry) should normally be\n| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:\n|\n| >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)\n| >>> y = x[:, 0:2]\n| >>> y\n| array([[1, 2],\n| [4, 5]], dtype=int16)\n| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])\n| Traceback (most recent call last):\n| ...\n| ValueError: To change to a dtype of a different size, the array must be C-contiguous\n| >>> z = y.copy()\n| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])\n| array([[(1, 2)],\n| [(4, 5)]], dtype=[('width', '>> x = np.array([[1.,2.],[3.,4.]])\n| >>> x\n| array([[ 1., 2.],\n| [ 3., 4.]])\n| >>> x.T\n| array([[ 1., 3.],\n| [ 2., 4.]])\n| >>> x = np.array([1.,2.,3.,4.])\n| >>> x\n| array([ 1., 2., 3., 4.])\n| >>> x.T\n| array([ 1., 2., 3., 4.])\n|\n| See Also\n| --------\n| transpose\n|\n| arrayfinalize\n| None.\n|\n| arrayinterface\n| Array protocol: Python side.\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: C-struct side.\n|\n| base\n| Base object if memory is from some other object.\n|\n| Examples\n| --------\n| The base of an array that owns its memory is None:\n|\n| >>> x = np.array([1,2,3,4])\n| >>> x.base is None\n| True\n|\n| Slicing creates a view, whose memory is shared with x:\n|\n| >>> y = x[2:]\n| >>> y.base is x\n| True\n|\n| ctypes\n| An object to simplify the interaction of the array with the ctypes\n| module.\n|\n| This attribute creates an object that makes it easier to use arrays\n| when calling shared libraries with the ctypes module. The returned\n| object has, among others, data, shape, and strides attributes (see\n| Notes below) which themselves return ctypes objects that can be used\n| as arguments to a shared library.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| c : Python object\n| Possessing attributes data, shape, strides, etc.\n|\n| See Also\n| --------\n| numpy.ctypeslib\n|\n| Notes\n| -----\n| Below are the public attributes of this object which were documented\n| in \"Guide to NumPy\" (we have omitted undocumented public attributes,\n| as well as documented private attributes):\n|\n| .. autoattribute:: numpy.core.internal.ctypes.data\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.shape\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.strides\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.dataas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.shapeas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.stridesas\n| :noindex:\n|\n| If the ctypes module is not available, then the ctypes attribute\n| of array objects still returns something useful, but ctypes objects\n| are not returned and errors may be raised instead. In particular,\n| the object will still have the ``asparameter`` attribute which will\n| return an integer equal to the data attribute.\n|\n| Examples\n| --------\n| >>> import ctypes\n| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)\n| >>> x\n| array([[0, 1],\n| [2, 3]], dtype=int32)\n| >>> x.ctypes.data\n| 31962608 # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32))\n| # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32)).contents\n| cuint(0)\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint64)).contents\n| culong(4294967296)\n| >>> x.ctypes.shape\n| # may vary\n| >>> x.ctypes.strides\n| # may vary\n|\n| data\n| Python buffer object pointing to the start of the array's data.\n|\n| dtype\n| Data-type of the array's elements.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| d : numpy dtype object\n|\n| See Also\n| --------\n| numpy.dtype\n|\n| Examples\n| --------\n| >>> x\n| array([[0, 1],\n| [2, 3]])\n| >>> x.dtype\n| dtype('int32')\n| >>> type(x.dtype)\n| \n|\n| flags\n| Information about the memory layout of the array.\n|\n| Attributes\n| ----------\n| CCONTIGUOUS (C)\n| The data is in a single, C-style contiguous segment.\n| FCONTIGUOUS (F)\n| The data is in a single, Fortran-style contiguous segment.\n| OWNDATA (O)\n| The array owns the memory it uses or borrows it from another object.\n| WRITEABLE (W)\n| The data area can be written to. Setting this to False locks\n| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE\n| from its base array at creation time, but a view of a writeable\n| array may be subsequently locked while the base array remains writeable.\n| (The opposite is not true, in that a view of a locked array may not\n| be made writeable. However, currently, locking a base object does not\n| lock any views that already reference it, so under that circumstance it\n| is possible to alter the contents of a locked array via a previously\n| created writeable view onto it.) Attempting to change a non-writeable\n| array raises a RuntimeError exception.\n| ALIGNED (A)\n| The data and all elements are aligned appropriately for the hardware.\n| WRITEBACKIFCOPY (X)\n| This array is a copy of some other array. The C-API function\n| PyArrayResolveWritebackIfCopy must be called before deallocating\n| to the base array will be updated with the contents of this array.\n| UPDATEIFCOPY (U)\n| (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.\n| When this array is\n| deallocated, the base array will be updated with the contents of\n| this array.\n| FNC\n| FCONTIGUOUS and not CCONTIGUOUS.\n| FORC\n| FCONTIGUOUS or CCONTIGUOUS (one-segment test).\n| BEHAVED (B)\n| ALIGNED and WRITEABLE.\n| CARRAY (CA)\n| BEHAVED and CCONTIGUOUS.\n| FARRAY (FA)\n| BEHAVED and FCONTIGUOUS and not CCONTIGUOUS.\n|\n| Notes\n| -----\n| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),\n| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag\n| names are only supported in dictionary access.\n|\n| Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be\n| changed by the user, via direct assignment to the attribute or dictionary\n| entry, or by calling `ndarray.setflags`.\n|\n| The array flags cannot be set arbitrarily:\n|\n| - UPDATEIFCOPY can only be set ``False``.\n| - WRITEBACKIFCOPY can only be set ``False``.\n| - ALIGNED can only be set ``True`` if the data is truly aligned.\n| - WRITEABLE can only be set ``True`` if the array owns its own memory\n| or the ultimate owner of the memory exposes a writeable buffer\n| interface or is a string.\n|\n| Arrays can be both C-style and Fortran-style contiguous simultaneously.\n| This is clear for 1-dimensional arrays, but can also be true for higher\n| dimensional arrays.\n|\n| Even for contiguous arrays a stride for a given dimension\n| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``\n| or the array has no elements.\n| It does *not* generally hold that ``self.strides[-1] == self.itemsize``\n| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for\n| Fortran-style contiguous arrays is true.\n|\n| flat\n| A 1-D iterator over the array.\n|\n| This is a `numpy.flatiter` instance, which acts similarly to, but is not\n| a subclass of, Python's built-in iterator object.\n|\n| See Also\n| --------\n| flatten : Return a copy of the array collapsed into one dimension.\n|\n| flatiter\n|\n| Examples\n| --------\n| >>> x = np.arange(1, 7).reshape(2, 3)\n| >>> x\n| array([[1, 2, 3],\n| [4, 5, 6]])\n| >>> x.flat[3]\n| 4\n| >>> x.T\n| array([[1, 4],\n| [2, 5],\n| [3, 6]])\n| >>> x.T.flat[3]\n| 5\n| >>> type(x.flat)\n| \n|\n| An assignment example:\n|\n| >>> x.flat = 3; x\n| array([[3, 3, 3],\n| [3, 3, 3]])\n| >>> x.flat[[1,4]] = 1; x\n| array([[3, 1, 3],\n| [3, 1, 3]])\n|\n| imag\n| The imaginary part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.imag\n| array([ 0. , 0.70710678])\n| >>> x.imag.dtype\n| dtype('float64')\n|\n| itemsize\n| Length of one array element in bytes.\n|\n| Examples\n| --------\n| >>> x = np.array([1,2,3], dtype=np.float64)\n| >>> x.itemsize\n| 8\n| >>> x = np.array([1,2,3], dtype=np.complex128)\n| >>> x.itemsize\n| 16\n|\n| nbytes\n| Total bytes consumed by the elements of the array.\n|\n| Notes\n| -----\n| Does not include memory consumed by non-element attributes of the\n| array object.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3,5,2), dtype=np.complex128)\n| >>> x.nbytes\n| 480\n| >>> np.prod(x.shape) * x.itemsize\n| 480\n|\n| ndim\n| Number of array dimensions.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> x.ndim\n| 1\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.ndim\n| 3\n|\n| real\n| The real part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.real\n| array([ 1. , 0.70710678])\n| >>> x.real.dtype\n| dtype('float64')\n|\n| See Also\n| --------\n| numpy.real : equivalent function\n|\n| shape\n| Tuple of array dimensions.\n|\n| The shape property is usually used to get the current shape of an array,\n| but may also be used to reshape the array in-place by assigning a tuple of\n| array dimensions to it. As with `numpy.reshape`, one of the new shape\n| dimensions can be -1, in which case its value is inferred from the size of\n| the array and the remaining dimensions. Reshaping an array in-place will\n| fail if a copy is required.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3, 4])\n| >>> x.shape\n| (4,)\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.shape\n| (2, 3, 4)\n| >>> y.shape = (3, 8)\n| >>> y\n| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.]])\n| >>> y.shape = (3, 6)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: total size of new array must be unchanged\n| >>> np.zeros((4,2))[::2].shape = (-1,)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| AttributeError: Incompatible shape for in-place modification. Use\n| `.reshape()` to make a copy with the desired shape.\n|\n| See Also\n| --------\n| numpy.reshape : similar function\n| ndarray.reshape : similar method\n|\n| size\n| Number of elements in the array.\n|\n| Equal to ``np.prod(a.shape)``, i.e., the product of the array's\n| dimensions.\n|\n| Notes\n| -----\n| `a.size` returns a standard arbitrary precision Python integer. This\n| may not be the case with other methods of obtaining the same value\n| (like the suggested ``np.prod(a.shape)``, which returns an instance\n| of ``np.int``), and may be relevant if the value is used further in\n| calculations that may overflow a fixed size integer type.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)\n| >>> x.size\n| 30\n| >>> np.prod(x.shape)\n| 30\n|\n| strides\n| Tuple of bytes to step in each dimension when traversing an array.\n|\n| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`\n| is::\n|\n| offset = sum(np.array(i) * a.strides)\n|\n| A more detailed explanation of strides can be found in the\n| \"ndarray.rst\" file in the NumPy reference guide.\n|\n| Notes\n| -----\n| Imagine an array of 32-bit integers (each 4 bytes)::\n|\n| x = np.array([[0, 1, 2, 3, 4],\n| [5, 6, 7, 8, 9]], dtype=np.int32)\n|\n| This array is stored in memory as 40 bytes, one after the other\n| (known as a contiguous block of memory). The strides of an array tell\n| us how many bytes we have to skip in memory to move to the next position\n| along a certain axis. For example, we have to skip 4 bytes (1 value) to\n| move to the next column, but 20 bytes (5 values) to get to the same\n| position in the next row. As such, the strides for the array `x` will be\n| ``(20, 4)``.\n|\n| See Also\n| --------\n| numpy.lib.stridetricks.asstrided\n|\n| Examples\n| --------\n| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))\n| >>> y\n| array([[[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]],\n| [[12, 13, 14, 15],\n| [16, 17, 18, 19],\n| [20, 21, 22, 23]]])\n| >>> y.strides\n| (48, 16, 4)\n| >>> y[1,1,1]\n| 17\n| >>> offset=sum(y.strides * np.array((1,1,1)))\n| >>> offset/y.itemsize\n| 17\n|\n| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)\n| >>> x.strides\n| (32, 4, 224, 1344)\n| >>> i = np.array([3,5,2,2])\n| >>> offset = sum(i * x.strides)\n| >>> x[3,5,2,2]\n| 813\n| >>> offset / x.itemsize\n| 813\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| hash = None\n" }, { "name": "class ndenumerate", "content": "| ndenumerate(arr)\n|\n| Multidimensional index iterator.\n|\n| Return an iterator yielding pairs of array coordinates and values.\n|\n| Parameters\n| ----------\n| arr : ndarray\n| Input array.\n|\n| See Also\n| --------\n| ndindex, flatiter\n|\n| Examples\n| --------\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> for index, x in np.ndenumerate(a):\n| ... print(index, x)\n| (0, 0) 1\n| (0, 1) 2\n| (1, 0) 3\n| (1, 1) 4\n|\n| Methods defined here:\n|\n| init(self, arr)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| iter(self)\n|\n| next(self)\n| Standard iterator method, returns the index tuple and array value.\n|\n| Returns\n| -------\n| coords : tuple of ints\n| The indices of the current iteration.\n| val : scalar\n| The array element of the current iteration.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class ndindex", "content": "| ndindex(*shape)\n|\n| An N-dimensional iterator object to index arrays.\n|\n| Given the shape of an array, an `ndindex` instance iterates over\n| the N-dimensional index of the array. At each iteration a tuple\n| of indices is returned, the last dimension is iterated over first.\n|\n| Parameters\n| ----------\n| shape : ints, or a single tuple of ints\n| The size of each dimension of the array can be passed as\n| individual parameters or as the elements of a tuple.\n|\n| See Also\n| --------\n| ndenumerate, flatiter\n|\n| Examples\n| --------\n| # dimensions as individual arguments\n| >>> for index in np.ndindex(3, 2, 1):\n| ... print(index)\n| (0, 0, 0)\n| (0, 1, 0)\n| (1, 0, 0)\n| (1, 1, 0)\n| (2, 0, 0)\n| (2, 1, 0)\n|\n| # same dimensions - but in a tuple (3, 2, 1)\n| >>> for index in np.ndindex((3, 2, 1)):\n| ... print(index)\n| (0, 0, 0)\n| (0, 1, 0)\n| (1, 0, 0)\n| (1, 1, 0)\n| (2, 0, 0)\n| (2, 1, 0)\n|\n| Methods defined here:\n|\n| init(self, *shape)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| iter(self)\n|\n| next(self)\n| Standard iterator method, updates the index and returns the index\n| tuple.\n|\n| Returns\n| -------\n| val : tuple of ints\n| Returns a tuple containing the indices of the current\n| iteration.\n|\n| ndincr(self)\n| Increment the multi-dimensional index by one.\n|\n| This method is for backward compatibility only: do not use.\n|\n| .. deprecated:: 1.20.0\n| This method has been advised against since numpy 1.8.0, but only\n| started emitting DeprecationWarning as of this version.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class nditer", "content": "| nditer(op, flags=None, opflags=None, opdtypes=None, order='K', casting='safe', opaxes=None, itershape=None, buffersize=0)\n|\n| Efficient multi-dimensional iterator object to iterate over arrays.\n| To get started using this object, see the\n| :ref:`introductory guide to array iteration `.\n|\n| Parameters\n| ----------\n| op : ndarray or sequence of arraylike\n| The array(s) to iterate over.\n|\n| flags : sequence of str, optional\n| Flags to control the behavior of the iterator.\n|\n| * ``buffered`` enables buffering when required.\n| * ``cindex`` causes a C-order index to be tracked.\n| * ``findex`` causes a Fortran-order index to be tracked.\n| * ``multiindex`` causes a multi-index, or a tuple of indices\n| with one per iteration dimension, to be tracked.\n| * ``commondtype`` causes all the operands to be converted to\n| a common data type, with copying or buffering as necessary.\n| * ``copyifoverlap`` causes the iterator to determine if read\n| operands have overlap with write operands, and make temporary\n| copies as necessary to avoid overlap. False positives (needless\n| copying) are possible in some cases.\n| * ``delaybufalloc`` delays allocation of the buffers until\n| a reset() call is made. Allows ``allocate`` operands to\n| be initialized before their values are copied into the buffers.\n| * ``externalloop`` causes the ``values`` given to be\n| one-dimensional arrays with multiple values instead of\n| zero-dimensional arrays.\n| * ``growinner`` allows the ``value`` array sizes to be made\n| larger than the buffer size when both ``buffered`` and\n| ``externalloop`` is used.\n| * ``ranged`` allows the iterator to be restricted to a sub-range\n| of the iterindex values.\n| * ``refsok`` enables iteration of reference types, such as\n| object arrays.\n| * ``reduceok`` enables iteration of ``readwrite`` operands\n| which are broadcasted, also known as reduction operands.\n| * ``zerosizeok`` allows `itersize` to be zero.\n| opflags : list of list of str, optional\n| This is a list of flags for each operand. At minimum, one of\n| ``readonly``, ``readwrite``, or ``writeonly`` must be specified.\n|\n| * ``readonly`` indicates the operand will only be read from.\n| * ``readwrite`` indicates the operand will be read from and written to.\n| * ``writeonly`` indicates the operand will only be written to.\n| * ``nobroadcast`` prevents the operand from being broadcasted.\n| * ``contig`` forces the operand data to be contiguous.\n| * ``aligned`` forces the operand data to be aligned.\n| * ``nbo`` forces the operand data to be in native byte order.\n| * ``copy`` allows a temporary read-only copy if required.\n| * ``updateifcopy`` allows a temporary read-write copy if required.\n| * ``allocate`` causes the array to be allocated if it is None\n| in the ``op`` parameter.\n| * ``nosubtype`` prevents an ``allocate`` operand from using a subtype.\n| * ``arraymask`` indicates that this operand is the mask to use\n| for selecting elements when writing to operands with the\n| 'writemasked' flag set. The iterator does not enforce this,\n| but when writing from a buffer back to the array, it only\n| copies those elements indicated by this mask.\n| * ``writemasked`` indicates that only elements where the chosen\n| ``arraymask`` operand is True will be written to.\n| * ``overlapassumeelementwise`` can be used to mark operands that are\n| accessed only in the iterator order, to allow less conservative\n| copying when ``copyifoverlap`` is present.\n| opdtypes : dtype or tuple of dtype(s), optional\n| The required data type(s) of the operands. If copying or buffering\n| is enabled, the data will be converted to/from their original types.\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the iteration order. 'C' means C order, 'F' means\n| Fortran order, 'A' means 'F' order if all the arrays are Fortran\n| contiguous, 'C' order otherwise, and 'K' means as close to the\n| order the array elements appear in memory as possible. This also\n| affects the element memory order of ``allocate`` operands, as they\n| are allocated to be compatible with iteration order.\n| Default is 'K'.\n| casting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\n| Controls what kind of data casting may occur when making a copy\n| or buffering. Setting this to 'unsafe' is not recommended,\n| as it can adversely affect accumulations.\n|\n| * 'no' means the data types should not be cast at all.\n| * 'equiv' means only byte-order changes are allowed.\n| * 'safe' means only casts which can preserve values are allowed.\n| * 'samekind' means only safe casts or casts within a kind,\n| like float64 to float32, are allowed.\n| * 'unsafe' means any data conversions may be done.\n| opaxes : list of list of ints, optional\n| If provided, is a list of ints or None for each operands.\n| The list of axes for an operand is a mapping from the dimensions\n| of the iterator to the dimensions of the operand. A value of\n| -1 can be placed for entries, causing that dimension to be\n| treated as `newaxis`.\n| itershape : tuple of ints, optional\n| The desired shape of the iterator. This allows ``allocate`` operands\n| with a dimension mapped by opaxes not corresponding to a dimension\n| of a different operand to get a value not equal to 1 for that\n| dimension.\n| buffersize : int, optional\n| When buffering is enabled, controls the size of the temporary\n| buffers. Set to 0 for the default value.\n|\n| Attributes\n| ----------\n| dtypes : tuple of dtype(s)\n| The data types of the values provided in `value`. This may be\n| different from the operand data types if buffering is enabled.\n| Valid only before the iterator is closed.\n| finished : bool\n| Whether the iteration over the operands is finished or not.\n| hasdelayedbufalloc : bool\n| If True, the iterator was created with the ``delaybufalloc`` flag,\n| and no reset() function was called on it yet.\n| hasindex : bool\n| If True, the iterator was created with either the ``cindex`` or\n| the ``findex`` flag, and the property `index` can be used to\n| retrieve it.\n| hasmultiindex : bool\n| If True, the iterator was created with the ``multiindex`` flag,\n| and the property `multiindex` can be used to retrieve it.\n| index\n| When the ``cindex`` or ``findex`` flag was used, this property\n| provides access to the index. Raises a ValueError if accessed\n| and ``hasindex`` is False.\n| iterationneedsapi : bool\n| Whether iteration requires access to the Python API, for example\n| if one of the operands is an object array.\n| iterindex : int\n| An index which matches the order of iteration.\n| itersize : int\n| Size of the iterator.\n| itviews\n| Structured view(s) of `operands` in memory, matching the reordered\n| and optimized iterator access pattern. Valid only before the iterator\n| is closed.\n| multiindex\n| When the ``multiindex`` flag was used, this property\n| provides access to the index. Raises a ValueError if accessed\n| accessed and ``hasmultiindex`` is False.\n| ndim : int\n| The dimensions of the iterator.\n| nop : int\n| The number of iterator operands.\n| operands : tuple of operand(s)\n| The array(s) to be iterated over. Valid only before the iterator is\n| closed.\n| shape : tuple of ints\n| Shape tuple, the shape of the iterator.\n| value\n| Value of ``operands`` at current iteration. Normally, this is a\n| tuple of array scalars, but if the flag ``externalloop`` is used,\n| it is a tuple of one dimensional arrays.\n|\n| Notes\n| -----\n| `nditer` supersedes `flatiter`. The iterator implementation behind\n| `nditer` is also exposed by the NumPy C API.\n|\n| The Python exposure supplies two iteration interfaces, one which follows\n| the Python iterator protocol, and another which mirrors the C-style\n| do-while pattern. The native Python approach is better in most cases, but\n| if you need the coordinates or index of an iterator, use the C-style pattern.\n|\n| Examples\n| --------\n| Here is how we might write an ``iteradd`` function, using the\n| Python iterator protocol:\n|\n| >>> def iteraddpy(x, y, out=None):\n| ... addop = np.add\n| ... it = np.nditer([x, y, out], [],\n| ... [['readonly'], ['readonly'], ['writeonly','allocate']])\n| ... with it:\n| ... for (a, b, c) in it:\n| ... addop(a, b, out=c)\n| ... return it.operands[2]\n|\n| Here is the same function, but following the C-style pattern:\n|\n| >>> def iteradd(x, y, out=None):\n| ... addop = np.add\n| ... it = np.nditer([x, y, out], [],\n| ... [['readonly'], ['readonly'], ['writeonly','allocate']])\n| ... with it:\n| ... while not it.finished:\n| ... addop(it[0], it[1], out=it[2])\n| ... it.iternext()\n| ... return it.operands[2]\n|\n| Here is an example outer product function:\n|\n| >>> def outerit(x, y, out=None):\n| ... mulop = np.multiply\n| ... it = np.nditer([x, y, out], ['externalloop'],\n| ... [['readonly'], ['readonly'], ['writeonly', 'allocate']],\n| ... opaxes=[list(range(x.ndim)) + [-1] * y.ndim,\n| ... [-1] * x.ndim + list(range(y.ndim)),\n| ... None])\n| ... with it:\n| ... for (a, b, c) in it:\n| ... mulop(a, b, out=c)\n| ... return it.operands[2]\n|\n| >>> a = np.arange(2)+1\n| >>> b = np.arange(3)+1\n| >>> outerit(a,b)\n| array([[1, 2, 3],\n| [2, 4, 6]])\n|\n| Here is an example function which operates like a \"lambda\" ufunc:\n|\n| >>> def luf(lamdaexpr, *args, kwargs):\n| ... '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)'''\n| ... nargs = len(args)\n| ... op = (kwargs.get('out',None),) + args\n| ... it = np.nditer(op, ['buffered','externalloop'],\n| ... [['writeonly','allocate','nobroadcast']] +\n| ... [['readonly','nbo','aligned']]*nargs,\n| ... order=kwargs.get('order','K'),\n| ... casting=kwargs.get('casting','safe'),\n| ... buffersize=kwargs.get('buffersize',0))\n| ... while not it.finished:\n| ... it[0] = lamdaexpr(*it[1:])\n| ... it.iternext()\n| ... return it.operands[0]\n|\n| >>> a = np.arange(5)\n| >>> b = np.ones(5)\n| >>> luf(lambda i,j:i*i + j/2, a, b)\n| array([ 0.5, 1.5, 4.5, 9.5, 16.5])\n|\n| If operand flags `\"writeonly\"` or `\"readwrite\"` are used the\n| operands may be views into the original data with the\n| `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a\n| context manager or the `nditer.close` method must be called before\n| using the result. The temporary data will be written back to the\n| original data when the `exit` function is called but not before:\n|\n| >>> a = np.arange(6, dtype='i4')[::-2]\n| >>> with np.nditer(a, [],\n| ... [['writeonly', 'updateifcopy']],\n| ... casting='unsafe',\n| ... opdtypes=[np.dtype('f4')]) as i:\n| ... x = i.operands[0]\n| ... x[:] = [-1, -2, -3]\n| ... # a still unchanged here\n| >>> a, x\n| (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32))\n|\n| It is important to note that once the iterator is exited, dangling\n| references (like `x` in the example) may or may not share data with\n| the original data `a`. If writeback semantics were active, i.e. if\n| `x.base.flags.writebackifcopy` is `True`, then exiting the iterator\n| will sever the connection between `x` and `a`, writing to `x` will\n| no longer write to `a`. If writeback semantics are not active, then\n| `x.data` will still point at some part of `a.data`, and writing to\n| one will affect the other.\n|\n| Context management and the `close` method appeared in version 1.15.0.\n|\n| Methods defined here:\n|\n| copy(...)\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| enter(...)\n|\n| exit(...)\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| init(self, /, *args, kwargs)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| len(self, /)\n| Return len(self).\n|\n| next(self, /)\n| Implement next(self).\n|\n| setitem(self, key, value, /)\n| Set self[key] to value.\n|\n| close(...)\n| close()\n|\n| Resolve all writeback semantics in writeable operands.\n|\n| .. versionadded:: 1.15.0\n|\n| See Also\n| --------\n|\n| :ref:`nditer-context-manager`\n|\n| copy(...)\n| copy()\n|\n| Get a copy of the iterator in its current state.\n|\n| Examples\n| --------\n| >>> x = np.arange(10)\n| >>> y = x + 1\n| >>> it = np.nditer([x, y])\n| >>> next(it)\n| (array(0), array(1))\n| >>> it2 = it.copy()\n| >>> next(it2)\n| (array(1), array(2))\n|\n| debugprint(...)\n| debugprint()\n|\n| Print the current state of the `nditer` instance and debug info to stdout.\n|\n| enableexternalloop(...)\n| enableexternalloop()\n|\n| When the \"externalloop\" was not used during construction, but\n| is desired, this modifies the iterator to behave as if the flag\n| was specified.\n|\n| iternext(...)\n| iternext()\n|\n| Check whether iterations are left, and perform a single internal iteration\n| without returning the result. Used in the C-style pattern do-while\n| pattern. For an example, see `nditer`.\n|\n| Returns\n| -------\n| iternext : bool\n| Whether or not there are iterations left.\n|\n| removeaxis(...)\n| removeaxis(i)\n|\n| Removes axis `i` from the iterator. Requires that the flag \"multiindex\"\n| be enabled.\n|\n| removemultiindex(...)\n| removemultiindex()\n|\n| When the \"multiindex\" flag was specified, this removes it, allowing\n| the internal iteration structure to be optimized further.\n|\n| reset(...)\n| reset()\n|\n| Reset the iterator to its initial state.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dtypes\n|\n| finished\n|\n| hasdelayedbufalloc\n|\n| hasindex\n|\n| hasmultiindex\n|\n| index\n|\n| iterationneedsapi\n|\n| iterindex\n|\n| iterrange\n|\n| itersize\n|\n| itviews\n|\n| multiindex\n|\n| ndim\n|\n| nop\n|\n| operands\n| operands[`Slice`]\n|\n| The array(s) to be iterated over. Valid only before the iterator is closed.\n|\n| shape\n|\n| value\n" }, { "name": "class number", "content": "| Abstract base class of all numeric scalar types.\n|\n| Method resolution order:\n| number\n| generic\n| builtins.object\n|\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n\nobject0 = class object(generic)\n| Any Python object.\n|\n| :Character code: ``'O'``\n|\n| Method resolution order:\n| object\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| add(self, value, /)\n| Return self+value.\n|\n| call(self, /, *args, kwargs)\n| Call self as a function.\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| iadd(self, value, /)\n| Implement self+=value.\n|\n| imul(self, value, /)\n| Implement self*=value.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class object_", "content": "| Any Python object.\n|\n| :Character code: ``'O'``\n|\n| Method resolution order:\n| object\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| add(self, value, /)\n| Return self+value.\n|\n| call(self, /, *args, kwargs)\n| Call self as a function.\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| delattr(self, name, /)\n| Implement delattr(self, name).\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getattribute(self, name, /)\n| Return getattr(self, name).\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| iadd(self, value, /)\n| Implement self+=value.\n|\n| imul(self, value, /)\n| Implement self*=value.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class poly1d", "content": "| poly1d(corr, r=False, variable=None)\n|\n| A one-dimensional polynomial class.\n|\n| .. note::\n| This forms part of the old polynomial API. Since version 1.4, the\n| new polynomial API defined in `numpy.polynomial` is preferred.\n| A summary of the differences can be found in the\n| :doc:`transition guide `.\n|\n| A convenience class, used to encapsulate \"natural\" operations on\n| polynomials so that said operations may take on their customary\n| form in code (see Examples).\n|\n| Parameters\n| ----------\n| corr : arraylike\n| The polynomial's coefficients, in decreasing powers, or if\n| the value of the second parameter is True, the polynomial's\n| roots (values where the polynomial evaluates to 0). For example,\n| ``poly1d([1, 2, 3])`` returns an object that represents\n| :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns\n| one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.\n| r : bool, optional\n| If True, `corr` specifies the polynomial's roots; the default\n| is False.\n| variable : str, optional\n| Changes the variable used when printing `p` from `x` to `variable`\n| (see Examples).\n|\n| Examples\n| --------\n| Construct the polynomial :math:`x^2 + 2x + 3`:\n|\n| >>> p = np.poly1d([1, 2, 3])\n| >>> print(np.poly1d(p))\n| 2\n| 1 x + 2 x + 3\n|\n| Evaluate the polynomial at :math:`x = 0.5`:\n|\n| >>> p(0.5)\n| 4.25\n|\n| Find the roots:\n|\n| >>> p.r\n| array([-1.+1.41421356j, -1.-1.41421356j])\n| >>> p(p.r)\n| array([ -4.44089210e-16+0.j, -4.44089210e-16+0.j]) # may vary\n|\n| These numbers in the previous line represent (0, 0) to machine precision\n|\n| Show the coefficients:\n|\n| >>> p.c\n| array([1, 2, 3])\n|\n| Display the order (the leading zero-coefficients are removed):\n|\n| >>> p.order\n| 2\n|\n| Show the coefficient of the k-th power in the polynomial\n| (which is equivalent to ``p.c[-(i+1)]``):\n|\n| >>> p[1]\n| 2\n|\n| Polynomials can be added, subtracted, multiplied, and divided\n| (returns quotient and remainder):\n|\n| >>> p * p\n| poly1d([ 1, 4, 10, 12, 9])\n|\n| >>> (p3 + 4) / p\n| (poly1d([ 1., 4., 10., 12., 9.]), poly1d([4.]))\n|\n| ``asarray(p)`` gives the coefficient array, so polynomials can be\n| used in all functions that accept arrays:\n|\n| >>> p2 # square of polynomial\n| poly1d([ 1, 4, 10, 12, 9])\n|\n| >>> np.square(p) # square of individual coefficients\n| array([1, 4, 9])\n|\n| The variable used in the string representation of `p` can be modified,\n| using the `variable` parameter:\n|\n| >>> p = np.poly1d([1,2,3], variable='z')\n| >>> print(p)\n| 2\n| 1 z + 2 z + 3\n|\n| Construct a polynomial from its roots:\n|\n| >>> np.poly1d([1, 2], True)\n| poly1d([ 1., -3., 2.])\n|\n| This is the same polynomial as obtained by:\n|\n| >>> np.poly1d([1, -1]) * np.poly1d([1, -2])\n| poly1d([ 1, -3, 2])\n|\n| Methods defined here:\n|\n| add(self, other)\n|\n| array(self, t=None)\n|\n| call(self, val)\n| Call self as a function.\n|\n| div(self, other)\n|\n| eq(self, other)\n| Return self==value.\n|\n| getitem(self, val)\n|\n| init(self, corr, r=False, variable=None)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| iter(self)\n|\n| len(self)\n|\n| mul(self, other)\n|\n| ne(self, other)\n| Return self!=value.\n|\n| neg(self)\n|\n| pos(self)\n|\n| pow(self, val)\n|\n| radd(self, other)\n|\n| rdiv(self, other)\n|\n| repr(self)\n| Return repr(self).\n|\n| rmul(self, other)\n|\n| rsub(self, other)\n|\n| rtruediv = rdiv(self, other)\n|\n| setitem(self, key, val)\n|\n| str(self)\n| Return str(self).\n|\n| sub(self, other)\n|\n| truediv = div(self, other)\n|\n| deriv(self, m=1)\n| Return a derivative of this polynomial.\n|\n| Refer to `polyder` for full documentation.\n|\n| See Also\n| --------\n| polyder : equivalent function\n|\n| integ(self, m=1, k=0)\n| Return an antiderivative (indefinite integral) of this polynomial.\n|\n| Refer to `polyint` for full documentation.\n|\n| See Also\n| --------\n| polyint : equivalent function\n|\n| ----------------------------------------------------------------------\n| Readonly properties defined here:\n|\n| o\n| The order or degree of the polynomial\n|\n| order\n| The order or degree of the polynomial\n|\n| r\n| The roots of the polynomial, where self(x) == 0\n|\n| roots\n| The roots of the polynomial, where self(x) == 0\n|\n| variable\n| The name of the polynomial variable\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| c\n| The polynomial coefficients\n|\n| coef\n| The polynomial coefficients\n|\n| coefficients\n| The polynomial coefficients\n|\n| coeffs\n| The polynomial coefficients\n|\n| ----------------------------------------------------------------------\n| Data and other attributes defined here:\n|\n| hash = None\n" }, { "name": "class recarray", "content": "| recarray(shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C')\n|\n| Construct an ndarray that allows field access using attributes.\n|\n| Arrays may have a data-types containing fields, analogous\n| to columns in a spread sheet. An example is ``[(x, int), (y, float)]``,\n| where each entry in the array is a pair of ``(int, float)``. Normally,\n| these attributes are accessed using dictionary lookups such as ``arr['x']``\n| and ``arr['y']``. Record arrays allow the fields to be accessed as members\n| of the array, using ``arr.x`` and ``arr.y``.\n|\n| Parameters\n| ----------\n| shape : tuple\n| Shape of output array.\n| dtype : data-type, optional\n| The desired data-type. By default, the data-type is determined\n| from `formats`, `names`, `titles`, `aligned` and `byteorder`.\n| formats : list of data-types, optional\n| A list containing the data-types for the different columns, e.g.\n| ``['i4', 'f8', 'i4']``. `formats` does *not* support the new\n| convention of using types directly, i.e. ``(int, float, int)``.\n| Note that `formats` must be a list, not a tuple.\n| Given that `formats` is somewhat limited, we recommend specifying\n| `dtype` instead.\n| names : tuple of str, optional\n| The name of each column, e.g. ``('x', 'y', 'z')``.\n| buf : buffer, optional\n| By default, a new array is created of the given shape and data-type.\n| If `buf` is specified and is an object exposing the buffer interface,\n| the array will use the memory from the existing buffer. In this case,\n| the `offset` and `strides` keywords are available.\n|\n| Other Parameters\n| ----------------\n| titles : tuple of str, optional\n| Aliases for column names. For example, if `names` were\n| ``('x', 'y', 'z')`` and `titles` is\n| ``('xcoordinate', 'ycoordinate', 'zcoordinate')``, then\n| ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.xcoordinate``.\n| byteorder : {'<', '>', '='}, optional\n| Byte-order for all fields.\n| aligned : bool, optional\n| Align the fields in memory as the C-compiler would.\n| strides : tuple of ints, optional\n| Buffer (`buf`) is interpreted according to these strides (strides\n| define how many bytes each array element, row, column, etc.\n| occupy in memory).\n| offset : int, optional\n| Start reading buffer (`buf`) from this offset onwards.\n| order : {'C', 'F'}, optional\n| Row-major (C-style) or column-major (Fortran-style) order.\n|\n| Returns\n| -------\n| rec : recarray\n| Empty array of the given shape and type.\n|\n| See Also\n| --------\n| core.records.fromrecords : Construct a record array from data.\n| record : fundamental data-type for `recarray`.\n| formatparser : determine a data-type from formats, names, titles.\n|\n| Notes\n| -----\n| This constructor can be compared to ``empty``: it creates a new record\n| array but does not fill it with data. To create a record array from data,\n| use one of the following methods:\n|\n| 1. Create a standard ndarray and convert it to a record array,\n| using ``arr.view(np.recarray)``\n| 2. Use the `buf` keyword.\n| 3. Use `np.rec.fromrecords`.\n|\n| Examples\n| --------\n| Create an array with two fields, ``x`` and ``y``:\n|\n| >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '>> x\n| array([(1., 2), (3., 4)], dtype=[('x', '>> x['x']\n| array([1., 3.])\n|\n| View the array as a record array:\n|\n| >>> x = x.view(np.recarray)\n|\n| >>> x.x\n| array([1., 3.])\n|\n| >>> x.y\n| array([2, 4])\n|\n| Create a new, empty record array:\n|\n| >>> np.recarray((2,),\n| ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP\n| rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),\n| (3471280, 1.2134086255804012e-316, 0)],\n| dtype=[('x', ' reference if type unchanged, copy otherwise.\n|\n| Returns either a new reference to self if dtype is not given or a new array\n| of provided data type if dtype is different from the current dtype of the\n| array.\n|\n| arrayfunction(...)\n|\n| arrayprepare(...)\n| a.arrayprepare(obj) -> Object of same type as ndarray object obj.\n|\n| arrayufunc(...)\n|\n| arraywrap(...)\n| a.arraywrap(obj) -> Object of same type as ndarray object a.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| contains(self, key, /)\n| Return key in self.\n|\n| copy(...)\n| a.copy()\n|\n| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.\n|\n| Equivalent to ``a.copy(order='K')``.\n|\n| deepcopy(...)\n| a.deepcopy(memo, /) -> Deep copy of array.\n|\n| Used if :func:`copy.deepcopy` is called on an array.\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| Default object formatter.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| iadd(self, value, /)\n| Return self+=value.\n|\n| iand(self, value, /)\n| Return self&=value.\n|\n| ifloordiv(self, value, /)\n| Return self//=value.\n|\n| ilshift(self, value, /)\n| Return self<<=value.\n|\n| imatmul(self, value, /)\n| Return self@=value.\n|\n| imod(self, value, /)\n| Return self%=value.\n|\n| imul(self, value, /)\n| Return self*=value.\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| ior(self, value, /)\n| Return self|=value.\n|\n| ipow(self, value, /)\n| Return self=value.\n|\n| irshift(self, value, /)\n| Return self>>=value.\n|\n| isub(self, value, /)\n| Return self-=value.\n|\n| iter(self, /)\n| Implement iter(self).\n|\n| itruediv(self, value, /)\n| Return self/=value.\n|\n| ixor(self, value, /)\n| Return self^=value.\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setitem(self, key, value, /)\n| Set self[key] to value.\n|\n| setstate(...)\n| a.setstate(state, /)\n|\n| For unpickling.\n|\n| The `state` argument must be a sequence that contains the following\n| elements:\n|\n| Parameters\n| ----------\n| version : int\n| optional pickle version. If omitted defaults to 0.\n| shape : tuple\n| dtype : data-type\n| isFortran : bool\n| rawdata : string or list\n| a binary string with the data (or a list if 'a' is an object array)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| a.all(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if all elements evaluate to True.\n|\n| Refer to `numpy.all` for full documentation.\n|\n| See Also\n| --------\n| numpy.all : equivalent function\n|\n| any(...)\n| a.any(axis=None, out=None, keepdims=False, *, where=True)\n|\n| Returns True if any of the elements of `a` evaluate to True.\n|\n| Refer to `numpy.any` for full documentation.\n|\n| See Also\n| --------\n| numpy.any : equivalent function\n|\n| argmax(...)\n| a.argmax(axis=None, out=None)\n|\n| Return indices of the maximum values along the given axis.\n|\n| Refer to `numpy.argmax` for full documentation.\n|\n| See Also\n| --------\n| numpy.argmax : equivalent function\n|\n| argmin(...)\n| a.argmin(axis=None, out=None)\n|\n| Return indices of the minimum values along the given axis.\n|\n| Refer to `numpy.argmin` for detailed documentation.\n|\n| See Also\n| --------\n| numpy.argmin : equivalent function\n|\n| argpartition(...)\n| a.argpartition(kth, axis=-1, kind='introselect', order=None)\n|\n| Returns the indices that would partition this array.\n|\n| Refer to `numpy.argpartition` for full documentation.\n|\n| .. versionadded:: 1.8.0\n|\n| See Also\n| --------\n| numpy.argpartition : equivalent function\n|\n| argsort(...)\n| a.argsort(axis=-1, kind=None, order=None)\n|\n| Returns the indices that would sort this array.\n|\n| Refer to `numpy.argsort` for full documentation.\n|\n| See Also\n| --------\n| numpy.argsort : equivalent function\n|\n| astype(...)\n| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)\n|\n| Copy of the array, cast to a specified type.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| Typecode or data-type to which the array is cast.\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout order of the result.\n| 'C' means C order, 'F' means Fortran order, 'A'\n| means 'F' order if all the arrays are Fortran contiguous,\n| 'C' order otherwise, and 'K' means as close to the\n| order the array elements appear in memory as possible.\n| Default is 'K'.\n| casting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\n| Controls what kind of data casting may occur. Defaults to 'unsafe'\n| for backwards compatibility.\n|\n| * 'no' means the data types should not be cast at all.\n| * 'equiv' means only byte-order changes are allowed.\n| * 'safe' means only casts which can preserve values are allowed.\n| * 'samekind' means only safe casts or casts within a kind,\n| like float64 to float32, are allowed.\n| * 'unsafe' means any data conversions may be done.\n| subok : bool, optional\n| If True, then sub-classes will be passed-through (default), otherwise\n| the returned array will be forced to be a base-class array.\n| copy : bool, optional\n| By default, astype always returns a newly allocated array. If this\n| is set to false, and the `dtype`, `order`, and `subok`\n| requirements are satisfied, the input array is returned instead\n| of a copy.\n|\n| Returns\n| -------\n| arrt : ndarray\n| Unless `copy` is False and the other conditions for returning the input\n| array are satisfied (see description for `copy` input parameter), `arrt`\n| is a new array of the same shape as the input array, with dtype, order\n| given by `dtype`, `order`.\n|\n| Notes\n| -----\n| .. versionchanged:: 1.17.0\n| Casting between a simple data type and a structured one is possible only\n| for \"unsafe\" casting. Casting to multiple fields is allowed, but\n| casting from multiple fields is not.\n|\n| .. versionchanged:: 1.9.0\n| Casting from numeric to string types in 'safe' casting mode requires\n| that the string dtype length is long enough to store the max\n| integer/float value converted.\n|\n| Raises\n| ------\n| ComplexWarning\n| When casting from complex to float or int. To avoid this,\n| one should use ``a.real.astype(t)``.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 2.5])\n| >>> x\n| array([1. , 2. , 2.5])\n|\n| >>> x.astype(int)\n| array([1, 2, 2])\n|\n| byteswap(...)\n| a.byteswap(inplace=False)\n|\n| Swap the bytes of the array elements\n|\n| Toggle between low-endian and big-endian data representation by\n| returning a byteswapped array, optionally swapped in-place.\n| Arrays of byte-strings are not swapped. The real and imaginary\n| parts of a complex number are swapped individually.\n|\n| Parameters\n| ----------\n| inplace : bool, optional\n| If ``True``, swap bytes in-place, default is ``False``.\n|\n| Returns\n| -------\n| out : ndarray\n| The byteswapped array. If `inplace` is ``True``, this is\n| a view to self.\n|\n| Examples\n| --------\n| >>> A = np.array([1, 256, 8755], dtype=np.int16)\n| >>> list(map(hex, A))\n| ['0x1', '0x100', '0x2233']\n| >>> A.byteswap(inplace=True)\n| array([ 256, 1, 13090], dtype=int16)\n| >>> list(map(hex, A))\n| ['0x100', '0x1', '0x3322']\n|\n| Arrays of byte-strings are not swapped\n|\n| >>> A = np.array([b'ceg', b'fac'])\n| >>> A.byteswap()\n| array([b'ceg', b'fac'], dtype='|S3')\n|\n| ``A.newbyteorder().byteswap()`` produces an array with the same values\n| but different representation in memory\n|\n| >>> A = np.array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,\n| 0, 0], dtype=uint8)\n| >>> A.newbyteorder().byteswap(inplace=True)\n| array([1, 2, 3])\n| >>> A.view(np.uint8)\n| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,\n| 0, 3], dtype=uint8)\n|\n| choose(...)\n| a.choose(choices, out=None, mode='raise')\n|\n| Use an index array to construct a new array from a set of choices.\n|\n| Refer to `numpy.choose` for full documentation.\n|\n| See Also\n| --------\n| numpy.choose : equivalent function\n|\n| clip(...)\n| a.clip(min=None, max=None, out=None, kwargs)\n|\n| Return an array whose values are limited to ``[min, max]``.\n| One of max or min must be given.\n|\n| Refer to `numpy.clip` for full documentation.\n|\n| See Also\n| --------\n| numpy.clip : equivalent function\n|\n| compress(...)\n| a.compress(condition, axis=None, out=None)\n|\n| Return selected slices of this array along given axis.\n|\n| Refer to `numpy.compress` for full documentation.\n|\n| See Also\n| --------\n| numpy.compress : equivalent function\n|\n| conj(...)\n| a.conj()\n|\n| Complex-conjugate all elements.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| conjugate(...)\n| a.conjugate()\n|\n| Return the complex conjugate, element-wise.\n|\n| Refer to `numpy.conjugate` for full documentation.\n|\n| See Also\n| --------\n| numpy.conjugate : equivalent function\n|\n| copy(...)\n| a.copy(order='C')\n|\n| Return a copy of the array.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| Controls the memory layout of the copy. 'C' means C-order,\n| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n| 'C' otherwise. 'K' means match the layout of `a` as closely\n| as possible. (Note that this function and :func:`numpy.copy` are very\n| similar but have different default values for their order=\n| arguments, and this function always passes sub-classes through.)\n|\n| See also\n| --------\n| numpy.copy : Similar function with different default behavior\n| numpy.copyto\n|\n| Notes\n| -----\n| This function is the preferred method for creating an array copy. The\n| function :func:`numpy.copy` is similar, but it defaults to using order 'K',\n| and will not pass sub-classes through by default.\n|\n| Examples\n| --------\n| >>> x = np.array([[1,2,3],[4,5,6]], order='F')\n|\n| >>> y = x.copy()\n|\n| >>> x.fill(0)\n|\n| >>> x\n| array([[0, 0, 0],\n| [0, 0, 0]])\n|\n| >>> y\n| array([[1, 2, 3],\n| [4, 5, 6]])\n|\n| >>> y.flags['CCONTIGUOUS']\n| True\n|\n| cumprod(...)\n| a.cumprod(axis=None, dtype=None, out=None)\n|\n| Return the cumulative product of the elements along the given axis.\n|\n| Refer to `numpy.cumprod` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumprod : equivalent function\n|\n| cumsum(...)\n| a.cumsum(axis=None, dtype=None, out=None)\n|\n| Return the cumulative sum of the elements along the given axis.\n|\n| Refer to `numpy.cumsum` for full documentation.\n|\n| See Also\n| --------\n| numpy.cumsum : equivalent function\n|\n| diagonal(...)\n| a.diagonal(offset=0, axis1=0, axis2=1)\n|\n| Return specified diagonals. In NumPy 1.9 the returned array is a\n| read-only view instead of a copy as in previous NumPy versions. In\n| a future version the read-only restriction will be removed.\n|\n| Refer to :func:`numpy.diagonal` for full documentation.\n|\n| See Also\n| --------\n| numpy.diagonal : equivalent function\n|\n| dot(...)\n| a.dot(b, out=None)\n|\n| Dot product of two arrays.\n|\n| Refer to `numpy.dot` for full documentation.\n|\n| See Also\n| --------\n| numpy.dot : equivalent function\n|\n| Examples\n| --------\n| >>> a = np.eye(2)\n| >>> b = np.ones((2, 2)) * 2\n| >>> a.dot(b)\n| array([[2., 2.],\n| [2., 2.]])\n|\n| This array method can be conveniently chained:\n|\n| >>> a.dot(b).dot(b)\n| array([[8., 8.],\n| [8., 8.]])\n|\n| dump(...)\n| a.dump(file)\n|\n| Dump a pickle of the array to the specified file.\n| The array can be read back with pickle.load or numpy.load.\n|\n| Parameters\n| ----------\n| file : str or Path\n| A string naming the dump file.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| dumps(...)\n| a.dumps()\n|\n| Returns the pickle of the array as a string.\n| pickle.loads or numpy.loads will convert the string back to an array.\n|\n| Parameters\n| ----------\n| None\n|\n| fill(...)\n| a.fill(value)\n|\n| Fill the array with a scalar value.\n|\n| Parameters\n| ----------\n| value : scalar\n| All elements of `a` will be assigned this value.\n|\n| Examples\n| --------\n| >>> a = np.array([1, 2])\n| >>> a.fill(0)\n| >>> a\n| array([0, 0])\n| >>> a = np.empty(2)\n| >>> a.fill(1)\n| >>> a\n| array([1., 1.])\n|\n| flatten(...)\n| a.flatten(order='C')\n|\n| Return a copy of the array collapsed into one dimension.\n|\n| Parameters\n| ----------\n| order : {'C', 'F', 'A', 'K'}, optional\n| 'C' means to flatten in row-major (C-style) order.\n| 'F' means to flatten in column-major (Fortran-\n| style) order. 'A' means to flatten in column-major\n| order if `a` is Fortran *contiguous* in memory,\n| row-major order otherwise. 'K' means to flatten\n| `a` in the order the elements occur in memory.\n| The default is 'C'.\n|\n| Returns\n| -------\n| y : ndarray\n| A copy of the input array, flattened to one dimension.\n|\n| See Also\n| --------\n| ravel : Return a flattened array.\n| flat : A 1-D flat iterator over the array.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,2], [3,4]])\n| >>> a.flatten()\n| array([1, 2, 3, 4])\n| >>> a.flatten('F')\n| array([1, 3, 2, 4])\n|\n| getfield(...)\n| a.getfield(dtype, offset=0)\n|\n| Returns a field of the given array as a certain type.\n|\n| A field is a view of the array data with a given data-type. The values in\n| the view are determined by the given type and the offset into the current\n| array in bytes. The offset needs to be such that the view dtype fits in the\n| array dtype; for example an array of dtype complex128 has 16-byte elements.\n| If taking a view with a 32-bit integer (4 bytes), the offset needs to be\n| between 0 and 12 bytes.\n|\n| Parameters\n| ----------\n| dtype : str or dtype\n| The data type of the view. The dtype size of the view can not be larger\n| than that of the array itself.\n| offset : int\n| Number of bytes to skip before beginning the element view.\n|\n| Examples\n| --------\n| >>> x = np.diag([1.+1.j]*2)\n| >>> x[1, 1] = 2 + 4.j\n| >>> x\n| array([[1.+1.j, 0.+0.j],\n| [0.+0.j, 2.+4.j]])\n| >>> x.getfield(np.float64)\n| array([[1., 0.],\n| [0., 2.]])\n|\n| By choosing an offset of 8 bytes we can select the complex part of the\n| array for our view:\n|\n| >>> x.getfield(np.float64, offset=8)\n| array([[1., 0.],\n| [0., 4.]])\n|\n| item(...)\n| a.item(*args)\n|\n| Copy an element of an array to a standard Python scalar and return it.\n|\n| Parameters\n| ----------\n| \\*args : Arguments (variable number and type)\n|\n| * none: in this case, the method only works for arrays\n| with one element (`a.size == 1`), which element is\n| copied into a standard Python scalar object and returned.\n|\n| * inttype: this argument is interpreted as a flat index into\n| the array, specifying which element to copy and return.\n|\n| * tuple of inttypes: functions as does a single inttype argument,\n| except that the argument is interpreted as an nd-index into the\n| array.\n|\n| Returns\n| -------\n| z : Standard Python scalar object\n| A copy of the specified element of the array as a suitable\n| Python scalar\n|\n| Notes\n| -----\n| When the data type of `a` is longdouble or clongdouble, item() returns\n| a scalar array object because there is no available Python scalar that\n| would not lose information. Void arrays return a buffer object for item(),\n| unless fields are defined, in which case a tuple is returned.\n|\n| `item` is very similar to a[args], except, instead of an array scalar,\n| a standard Python scalar is returned. This can be useful for speeding up\n| access to elements of the array and doing arithmetic on elements of the\n| array using Python's optimized math.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.item(3)\n| 1\n| >>> x.item(7)\n| 0\n| >>> x.item((0, 1))\n| 2\n| >>> x.item((2, 2))\n| 1\n|\n| itemset(...)\n| a.itemset(*args)\n|\n| Insert scalar into an array (scalar is cast to array's dtype, if possible)\n|\n| There must be at least 1 argument, and define the last argument\n| as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster\n| than ``a[args] = item``. The item should be a scalar value and `args`\n| must select a single item in the array `a`.\n|\n| Parameters\n| ----------\n| \\*args : Arguments\n| If one argument: a scalar, only used in case `a` is of size 1.\n| If two arguments: the last argument is the value to be set\n| and must be a scalar, the first argument specifies a single array\n| element location. It is either an int or a tuple.\n|\n| Notes\n| -----\n| Compared to indexing syntax, `itemset` provides some speed increase\n| for placing a scalar into a particular location in an `ndarray`,\n| if you must do this. However, generally this is discouraged:\n| among other problems, it complicates the appearance of the code.\n| Also, when using `itemset` (and `item`) inside a loop, be sure\n| to assign the methods to a local variable to avoid the attribute\n| look-up at each loop iteration.\n|\n| Examples\n| --------\n| >>> np.random.seed(123)\n| >>> x = np.random.randint(9, size=(3, 3))\n| >>> x\n| array([[2, 2, 6],\n| [1, 3, 6],\n| [1, 0, 1]])\n| >>> x.itemset(4, 0)\n| >>> x.itemset((2, 2), 9)\n| >>> x\n| array([[2, 2, 6],\n| [1, 0, 6],\n| [1, 0, 9]])\n|\n| max(...)\n| a.max(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the maximum along a given axis.\n|\n| Refer to `numpy.amax` for full documentation.\n|\n| See Also\n| --------\n| numpy.amax : equivalent function\n|\n| mean(...)\n| a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)\n|\n| Returns the average of the array elements along given axis.\n|\n| Refer to `numpy.mean` for full documentation.\n|\n| See Also\n| --------\n| numpy.mean : equivalent function\n|\n| min(...)\n| a.min(axis=None, out=None, keepdims=False, initial=, where=True)\n|\n| Return the minimum along a given axis.\n|\n| Refer to `numpy.amin` for full documentation.\n|\n| See Also\n| --------\n| numpy.amin : equivalent function\n|\n| newbyteorder(...)\n| arr.newbyteorder(neworder='S', /)\n|\n| Return the array with the same data viewed with a different byte order.\n|\n| Equivalent to::\n|\n| arr.view(arr.dtype.newbytorder(neworder))\n|\n| Changes are also made in all fields and sub-arrays of the array data\n| type.\n|\n|\n|\n| Parameters\n| ----------\n| neworder : string, optional\n| Byte order to force; a value from the byte order specifications\n| below. `neworder` codes can be any of:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order, equivalent to `sys.byteorder`\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newarr : array\n| New array object with the dtype reflecting given change to the\n| byte order.\n|\n| nonzero(...)\n| a.nonzero()\n|\n| Return the indices of the elements that are non-zero.\n|\n| Refer to `numpy.nonzero` for full documentation.\n|\n| See Also\n| --------\n| numpy.nonzero : equivalent function\n|\n| partition(...)\n| a.partition(kth, axis=-1, kind='introselect', order=None)\n|\n| Rearranges the elements in the array in such a way that the value of the\n| element in kth position is in the position it would be in a sorted array.\n| All elements smaller than the kth element are moved before this element and\n| all equal or greater are moved behind it. The ordering of the elements in\n| the two partitions is undefined.\n|\n| .. versionadded:: 1.8.0\n|\n| Parameters\n| ----------\n| kth : int or sequence of ints\n| Element index to partition by. The kth element value will be in its\n| final sorted position and all smaller elements will be moved before it\n| and all equal or greater elements behind it.\n| The order of all elements in the partitions is undefined.\n| If provided with a sequence of kth it will partition all elements\n| indexed by kth of them into their sorted position at once.\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'introselect'}, optional\n| Selection algorithm. Default is 'introselect'.\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need to be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.partition : Return a parititioned copy of an array.\n| argpartition : Indirect partition.\n| sort : Full sort.\n|\n| Notes\n| -----\n| See ``np.partition`` for notes on the different algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([3, 4, 2, 1])\n| >>> a.partition(3)\n| >>> a\n| array([2, 1, 3, 4])\n|\n| >>> a.partition((1, 3))\n| >>> a\n| array([1, 2, 3, 4])\n|\n| prod(...)\n| a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)\n|\n| Return the product of the array elements over the given axis\n|\n| Refer to `numpy.prod` for full documentation.\n|\n| See Also\n| --------\n| numpy.prod : equivalent function\n|\n| ptp(...)\n| a.ptp(axis=None, out=None, keepdims=False)\n|\n| Peak to peak (maximum - minimum) value along a given axis.\n|\n| Refer to `numpy.ptp` for full documentation.\n|\n| See Also\n| --------\n| numpy.ptp : equivalent function\n|\n| put(...)\n| a.put(indices, values, mode='raise')\n|\n| Set ``a.flat[n] = values[n]`` for all `n` in indices.\n|\n| Refer to `numpy.put` for full documentation.\n|\n| See Also\n| --------\n| numpy.put : equivalent function\n|\n| ravel(...)\n| a.ravel([order])\n|\n| Return a flattened array.\n|\n| Refer to `numpy.ravel` for full documentation.\n|\n| See Also\n| --------\n| numpy.ravel : equivalent function\n|\n| ndarray.flat : a flat iterator on the array.\n|\n| repeat(...)\n| a.repeat(repeats, axis=None)\n|\n| Repeat elements of an array.\n|\n| Refer to `numpy.repeat` for full documentation.\n|\n| See Also\n| --------\n| numpy.repeat : equivalent function\n|\n| reshape(...)\n| a.reshape(shape, order='C')\n|\n| Returns an array containing the same data with a new shape.\n|\n| Refer to `numpy.reshape` for full documentation.\n|\n| See Also\n| --------\n| numpy.reshape : equivalent function\n|\n| Notes\n| -----\n| Unlike the free function `numpy.reshape`, this method on `ndarray` allows\n| the elements of the shape parameter to be passed in as separate arguments.\n| For example, ``a.reshape(10, 11)`` is equivalent to\n| ``a.reshape((10, 11))``.\n|\n| resize(...)\n| a.resize(newshape, refcheck=True)\n|\n| Change shape and size of array in-place.\n|\n| Parameters\n| ----------\n| newshape : tuple of ints, or `n` ints\n| Shape of resized array.\n| refcheck : bool, optional\n| If False, reference count will not be checked. Default is True.\n|\n| Returns\n| -------\n| None\n|\n| Raises\n| ------\n| ValueError\n| If `a` does not own its own data or references or views to it exist,\n| and the data memory must be changed.\n| PyPy only: will always raise if the data memory must be changed, since\n| there is no reliable way to determine if references or views to it\n| exist.\n|\n| SystemError\n| If the `order` keyword argument is specified. This behaviour is a\n| bug in NumPy.\n|\n| See Also\n| --------\n| resize : Return a new array with the specified shape.\n|\n| Notes\n| -----\n| This reallocates space for the data area if necessary.\n|\n| Only contiguous arrays (data elements consecutive in memory) can be\n| resized.\n|\n| The purpose of the reference count check is to make sure you\n| do not use this array as a buffer for another Python object and then\n| reallocate the memory. However, reference counts can increase in\n| other ways so if you are sure that you have not shared the memory\n| for this array with another Python object, then you may safely set\n| `refcheck` to False.\n|\n| Examples\n| --------\n| Shrinking an array: array is flattened (in the order that the data are\n| stored in memory), resized, and reshaped:\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='C')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [1]])\n|\n| >>> a = np.array([[0, 1], [2, 3]], order='F')\n| >>> a.resize((2, 1))\n| >>> a\n| array([[0],\n| [2]])\n|\n| Enlarging an array: as above, but missing entries are filled with zeros:\n|\n| >>> b = np.array([[0, 1], [2, 3]])\n| >>> b.resize(2, 3) # newshape parameter doesn't have to be a tuple\n| >>> b\n| array([[0, 1, 2],\n| [3, 0, 0]])\n|\n| Referencing an array prevents resizing...\n|\n| >>> c = a\n| >>> a.resize((1, 1))\n| Traceback (most recent call last):\n| ...\n| ValueError: cannot resize an array that references or is referenced ...\n|\n| Unless `refcheck` is False:\n|\n| >>> a.resize((1, 1), refcheck=False)\n| >>> a\n| array([[0]])\n| >>> c\n| array([[0]])\n|\n| round(...)\n| a.round(decimals=0, out=None)\n|\n| Return `a` with each element rounded to the given number of decimals.\n|\n| Refer to `numpy.around` for full documentation.\n|\n| See Also\n| --------\n| numpy.around : equivalent function\n|\n| searchsorted(...)\n| a.searchsorted(v, side='left', sorter=None)\n|\n| Find indices where elements of v should be inserted in a to maintain order.\n|\n| For full documentation, see `numpy.searchsorted`\n|\n| See Also\n| --------\n| numpy.searchsorted : equivalent function\n|\n| setfield(...)\n| a.setfield(val, dtype, offset=0)\n|\n| Put a value into a specified place in a field defined by a data-type.\n|\n| Place `val` into `a`'s field defined by `dtype` and beginning `offset`\n| bytes into the field.\n|\n| Parameters\n| ----------\n| val : object\n| Value to be placed in field.\n| dtype : dtype object\n| Data-type of the field in which to place `val`.\n| offset : int, optional\n| The number of bytes into the field at which to place `val`.\n|\n| Returns\n| -------\n| None\n|\n| See Also\n| --------\n| getfield\n|\n| Examples\n| --------\n| >>> x = np.eye(3)\n| >>> x.getfield(np.float64)\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n| >>> x.setfield(3, np.int32)\n| >>> x.getfield(np.int32)\n| array([[3, 3, 3],\n| [3, 3, 3],\n| [3, 3, 3]], dtype=int32)\n| >>> x\n| array([[1.0e+000, 1.5e-323, 1.5e-323],\n| [1.5e-323, 1.0e+000, 1.5e-323],\n| [1.5e-323, 1.5e-323, 1.0e+000]])\n| >>> x.setfield(np.eye(3), np.int32)\n| >>> x\n| array([[1., 0., 0.],\n| [0., 1., 0.],\n| [0., 0., 1.]])\n|\n| setflags(...)\n| a.setflags(write=None, align=None, uic=None)\n|\n| Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),\n| respectively.\n|\n| These Boolean-valued flags affect how numpy interprets the memory\n| area used by `a` (see Notes below). The ALIGNED flag can only\n| be set to True if the data is actually aligned according to the type.\n| The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set\n| to True. The flag WRITEABLE can only be set to True if the array owns its\n| own memory, or the ultimate owner of the memory exposes a writeable buffer\n| interface, or is a string. (The exception for string is made so that\n| unpickling can be done without copying memory.)\n|\n| Parameters\n| ----------\n| write : bool, optional\n| Describes whether or not `a` can be written to.\n| align : bool, optional\n| Describes whether or not `a` is aligned properly for its type.\n| uic : bool, optional\n| Describes whether or not `a` is a copy of another \"base\" array.\n|\n| Notes\n| -----\n| Array flags provide information about how the memory area used\n| for the array is to be interpreted. There are 7 Boolean flags\n| in use, only four of which can be changed by the user:\n| WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.\n|\n| WRITEABLE (W) the data area can be written to;\n|\n| ALIGNED (A) the data and strides are aligned appropriately for the hardware\n| (as determined by the compiler);\n|\n| UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;\n|\n| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced\n| by .base). When the C-API function PyArrayResolveWritebackIfCopy is\n| called, the base array will be updated with the contents of this array.\n|\n| All flags can be accessed using the single (upper case) letter as well\n| as the full name.\n|\n| Examples\n| --------\n| >>> y = np.array([[3, 1, 7],\n| ... [2, 0, 0],\n| ... [8, 5, 9]])\n| >>> y\n| array([[3, 1, 7],\n| [2, 0, 0],\n| [8, 5, 9]])\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : True\n| ALIGNED : True\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(write=0, align=0)\n| >>> y.flags\n| CCONTIGUOUS : True\n| FCONTIGUOUS : False\n| OWNDATA : True\n| WRITEABLE : False\n| ALIGNED : False\n| WRITEBACKIFCOPY : False\n| UPDATEIFCOPY : False\n| >>> y.setflags(uic=1)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: cannot set WRITEBACKIFCOPY flag to True\n|\n| sort(...)\n| a.sort(axis=-1, kind=None, order=None)\n|\n| Sort an array in-place. Refer to `numpy.sort` for full documentation.\n|\n| Parameters\n| ----------\n| axis : int, optional\n| Axis along which to sort. Default is -1, which means sort along the\n| last axis.\n| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'\n| and 'mergesort' use timsort under the covers and, in general, the\n| actual implementation will vary with datatype. The 'mergesort' option\n| is retained for backwards compatibility.\n|\n| .. versionchanged:: 1.15.0\n| The 'stable' option was added.\n|\n| order : str or list of str, optional\n| When `a` is an array with fields defined, this argument specifies\n| which fields to compare first, second, etc. A single field can\n| be specified as a string, and not all fields need be specified,\n| but unspecified fields will still be used, in the order in which\n| they come up in the dtype, to break ties.\n|\n| See Also\n| --------\n| numpy.sort : Return a sorted copy of an array.\n| numpy.argsort : Indirect sort.\n| numpy.lexsort : Indirect stable sort on multiple keys.\n| numpy.searchsorted : Find elements in sorted array.\n| numpy.partition: Partial sort.\n|\n| Notes\n| -----\n| See `numpy.sort` for notes on the different sorting algorithms.\n|\n| Examples\n| --------\n| >>> a = np.array([[1,4], [3,1]])\n| >>> a.sort(axis=1)\n| >>> a\n| array([[1, 4],\n| [1, 3]])\n| >>> a.sort(axis=0)\n| >>> a\n| array([[1, 3],\n| [1, 4]])\n|\n| Use the `order` keyword to specify a field to use when sorting a\n| structured array:\n|\n| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])\n| >>> a.sort(order='y')\n| >>> a\n| array([(b'c', 1), (b'a', 2)],\n| dtype=[('x', 'S1'), ('y', '>> x = np.array([[0, 1], [2, 3]], dtype='>> x.tobytes()\n| b'\\x00\\x00\\x01\\x00\\x02\\x00\\x03\\x00'\n| >>> x.tobytes('C') == x.tobytes()\n| True\n| >>> x.tobytes('F')\n| b'\\x00\\x00\\x02\\x00\\x01\\x00\\x03\\x00'\n|\n| tofile(...)\n| a.tofile(fid, sep=\"\", format=\"%s\")\n|\n| Write array to a file as text or binary (default).\n|\n| Data is always written in 'C' order, independent of the order of `a`.\n| The data produced by this method can be recovered using the function\n| fromfile().\n|\n| Parameters\n| ----------\n| fid : file or str or Path\n| An open file object, or a string containing a filename.\n|\n| .. versionchanged:: 1.17.0\n| `pathlib.Path` objects are now accepted.\n|\n| sep : str\n| Separator between array items for text output.\n| If \"\" (empty), a binary file is written, equivalent to\n| ``file.write(a.tobytes())``.\n| format : str\n| Format string for text file output.\n| Each entry in the array is formatted to text by first converting\n| it to the closest Python type, and then using \"format\" % item.\n|\n| Notes\n| -----\n| This is a convenience function for quick storage of array data.\n| Information on endianness and precision is lost, so this method is not a\n| good choice for files intended to archive data or transport data between\n| machines with different endianness. Some of these problems can be overcome\n| by outputting the data as text files, at the expense of speed and file\n| size.\n|\n| When fid is a file object, array contents are directly written to the\n| file, bypassing the file object's ``write`` method. As a result, tofile\n| cannot be used with files objects supporting compression (e.g., GzipFile)\n| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).\n|\n| tolist(...)\n| a.tolist()\n|\n| Return the array as an ``a.ndim``-levels deep nested list of Python scalars.\n|\n| Return a copy of the array data as a (nested) Python list.\n| Data items are converted to the nearest compatible builtin Python type, via\n| the `~numpy.ndarray.item` function.\n|\n| If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will\n| not be a list at all, but a simple Python scalar.\n|\n| Parameters\n| ----------\n| none\n|\n| Returns\n| -------\n| y : object, or list of object, or list of list of object, or ...\n| The possibly nested list of array elements.\n|\n| Notes\n| -----\n| The array may be recreated via ``a = np.array(a.tolist())``, although this\n| may sometimes lose precision.\n|\n| Examples\n| --------\n| For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,\n| except that ``tolist`` changes numpy scalars to Python scalars:\n|\n| >>> a = np.uint32([1, 2])\n| >>> alist = list(a)\n| >>> alist\n| [1, 2]\n| >>> type(alist[0])\n| \n| >>> atolist = a.tolist()\n| >>> atolist\n| [1, 2]\n| >>> type(atolist[0])\n| \n|\n| Additionally, for a 2D array, ``tolist`` applies recursively:\n|\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> list(a)\n| [array([1, 2]), array([3, 4])]\n| >>> a.tolist()\n| [[1, 2], [3, 4]]\n|\n| The base case for this recursion is a 0D array:\n|\n| >>> a = np.array(1)\n| >>> list(a)\n| Traceback (most recent call last):\n| ...\n| TypeError: iteration over a 0-d array\n| >>> a.tolist()\n| 1\n|\n| tostring(...)\n| a.tostring(order='C')\n|\n| A compatibility alias for `tobytes`, with exactly the same behavior.\n|\n| Despite its name, it returns `bytes` not `str`\\ s.\n|\n| .. deprecated:: 1.19.0\n|\n| trace(...)\n| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)\n|\n| Return the sum along diagonals of the array.\n|\n| Refer to `numpy.trace` for full documentation.\n|\n| See Also\n| --------\n| numpy.trace : equivalent function\n|\n| transpose(...)\n| a.transpose(*axes)\n|\n| Returns a view of the array with axes transposed.\n|\n| For a 1-D array this has no effect, as a transposed vector is simply the\n| same vector. To convert a 1-D array into a 2D column vector, an additional\n| dimension must be added. `np.atleast2d(a).T` achieves this, as does\n| `a[:, np.newaxis]`.\n| For a 2-D array, this is a standard matrix transpose.\n| For an n-D array, if axes are given, their order indicates how the\n| axes are permuted (see Examples). If axes are not provided and\n| ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then\n| ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.\n|\n| Parameters\n| ----------\n| axes : None, tuple of ints, or `n` ints\n|\n| * None or no argument: reverses the order of the axes.\n|\n| * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s\n| `i`-th axis becomes `a.transpose()`'s `j`-th axis.\n|\n| * `n` ints: same as an n-tuple of the same ints (this form is\n| intended simply as a \"convenience\" alternative to the tuple form)\n|\n| Returns\n| -------\n| out : ndarray\n| View of `a`, with axes suitably permuted.\n|\n| See Also\n| --------\n| transpose : Equivalent function\n| ndarray.T : Array property returning the array transposed.\n| ndarray.reshape : Give a new shape to an array without changing its data.\n|\n| Examples\n| --------\n| >>> a = np.array([[1, 2], [3, 4]])\n| >>> a\n| array([[1, 2],\n| [3, 4]])\n| >>> a.transpose()\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose((1, 0))\n| array([[1, 3],\n| [2, 4]])\n| >>> a.transpose(1, 0)\n| array([[1, 3],\n| [2, 4]])\n|\n| var(...)\n| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)\n|\n| Returns the variance of the array elements, along given axis.\n|\n| Refer to `numpy.var` for full documentation.\n|\n| See Also\n| --------\n| numpy.var : equivalent function\n|\n| view(...)\n| a.view([dtype][, type])\n|\n| New view of array with the same data.\n|\n| .. note::\n| Passing None for ``dtype`` is different from omitting the parameter,\n| since the former invokes ``dtype(None)`` which is an alias for\n| ``dtype('float')``.\n|\n| Parameters\n| ----------\n| dtype : data-type or ndarray sub-class, optional\n| Data-type descriptor of the returned view, e.g., float32 or int16.\n| Omitting it results in the view having the same data-type as `a`.\n| This argument can also be specified as an ndarray sub-class, which\n| then specifies the type of the returned object (this is equivalent to\n| setting the ``type`` parameter).\n| type : Python type, optional\n| Type of the returned view, e.g., ndarray or matrix. Again, omission\n| of the parameter results in type preservation.\n|\n| Notes\n| -----\n| ``a.view()`` is used two different ways:\n|\n| ``a.view(somedtype)`` or ``a.view(dtype=somedtype)`` constructs a view\n| of the array's memory with a different data-type. This can cause a\n| reinterpretation of the bytes of memory.\n|\n| ``a.view(ndarraysubclass)`` or ``a.view(type=ndarraysubclass)`` just\n| returns an instance of `ndarraysubclass` that looks at the same array\n| (same shape, dtype, etc.) This does not cause a reinterpretation of the\n| memory.\n|\n| For ``a.view(somedtype)``, if ``somedtype`` has a different number of\n| bytes per entry than the previous dtype (for example, converting a\n| regular array to a structured array), then the behavior of the view\n| cannot be predicted just from the superficial appearance of ``a`` (shown\n| by ``print(a)``). It also depends on exactly how ``a`` is stored in\n| memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus\n| defined as a slice or transpose, etc., the view may give different\n| results.\n|\n|\n| Examples\n| --------\n| >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])\n|\n| Viewing array data using a different type and dtype:\n|\n| >>> y = x.view(dtype=np.int16, type=np.matrix)\n| >>> y\n| matrix([[513]], dtype=int16)\n| >>> print(type(y))\n| \n|\n| Creating a view on a structured array so it can be used in calculations\n|\n| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])\n| >>> xv = x.view(dtype=np.int8).reshape(-1,2)\n| >>> xv\n| array([[1, 2],\n| [3, 4]], dtype=int8)\n| >>> xv.mean(0)\n| array([2., 3.])\n|\n| Making changes to the view changes the underlying array\n|\n| >>> xv[0,1] = 20\n| >>> x\n| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])\n|\n| Using a view to convert an array to a recarray:\n|\n| >>> z = x.view(np.recarray)\n| >>> z.a\n| array([1, 3], dtype=int8)\n|\n| Views share data:\n|\n| >>> x[0] = (9, 10)\n| >>> z[0]\n| (9, 10)\n|\n| Views that change the dtype size (bytes per entry) should normally be\n| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:\n|\n| >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)\n| >>> y = x[:, 0:2]\n| >>> y\n| array([[1, 2],\n| [4, 5]], dtype=int16)\n| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])\n| Traceback (most recent call last):\n| ...\n| ValueError: To change to a dtype of a different size, the array must be C-contiguous\n| >>> z = y.copy()\n| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])\n| array([[(1, 2)],\n| [(4, 5)]], dtype=[('width', '>> x = np.array([[1.,2.],[3.,4.]])\n| >>> x\n| array([[ 1., 2.],\n| [ 3., 4.]])\n| >>> x.T\n| array([[ 1., 3.],\n| [ 2., 4.]])\n| >>> x = np.array([1.,2.,3.,4.])\n| >>> x\n| array([ 1., 2., 3., 4.])\n| >>> x.T\n| array([ 1., 2., 3., 4.])\n|\n| See Also\n| --------\n| transpose\n|\n| arrayinterface\n| Array protocol: Python side.\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: C-struct side.\n|\n| base\n| Base object if memory is from some other object.\n|\n| Examples\n| --------\n| The base of an array that owns its memory is None:\n|\n| >>> x = np.array([1,2,3,4])\n| >>> x.base is None\n| True\n|\n| Slicing creates a view, whose memory is shared with x:\n|\n| >>> y = x[2:]\n| >>> y.base is x\n| True\n|\n| ctypes\n| An object to simplify the interaction of the array with the ctypes\n| module.\n|\n| This attribute creates an object that makes it easier to use arrays\n| when calling shared libraries with the ctypes module. The returned\n| object has, among others, data, shape, and strides attributes (see\n| Notes below) which themselves return ctypes objects that can be used\n| as arguments to a shared library.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| c : Python object\n| Possessing attributes data, shape, strides, etc.\n|\n| See Also\n| --------\n| numpy.ctypeslib\n|\n| Notes\n| -----\n| Below are the public attributes of this object which were documented\n| in \"Guide to NumPy\" (we have omitted undocumented public attributes,\n| as well as documented private attributes):\n|\n| .. autoattribute:: numpy.core.internal.ctypes.data\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.shape\n| :noindex:\n|\n| .. autoattribute:: numpy.core.internal.ctypes.strides\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.dataas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.shapeas\n| :noindex:\n|\n| .. automethod:: numpy.core.internal.ctypes.stridesas\n| :noindex:\n|\n| If the ctypes module is not available, then the ctypes attribute\n| of array objects still returns something useful, but ctypes objects\n| are not returned and errors may be raised instead. In particular,\n| the object will still have the ``asparameter`` attribute which will\n| return an integer equal to the data attribute.\n|\n| Examples\n| --------\n| >>> import ctypes\n| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)\n| >>> x\n| array([[0, 1],\n| [2, 3]], dtype=int32)\n| >>> x.ctypes.data\n| 31962608 # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32))\n| # may vary\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint32)).contents\n| cuint(0)\n| >>> x.ctypes.dataas(ctypes.POINTER(ctypes.cuint64)).contents\n| culong(4294967296)\n| >>> x.ctypes.shape\n| # may vary\n| >>> x.ctypes.strides\n| # may vary\n|\n| data\n| Python buffer object pointing to the start of the array's data.\n|\n| dtype\n| Data-type of the array's elements.\n|\n| Parameters\n| ----------\n| None\n|\n| Returns\n| -------\n| d : numpy dtype object\n|\n| See Also\n| --------\n| numpy.dtype\n|\n| Examples\n| --------\n| >>> x\n| array([[0, 1],\n| [2, 3]])\n| >>> x.dtype\n| dtype('int32')\n| >>> type(x.dtype)\n| \n|\n| flags\n| Information about the memory layout of the array.\n|\n| Attributes\n| ----------\n| CCONTIGUOUS (C)\n| The data is in a single, C-style contiguous segment.\n| FCONTIGUOUS (F)\n| The data is in a single, Fortran-style contiguous segment.\n| OWNDATA (O)\n| The array owns the memory it uses or borrows it from another object.\n| WRITEABLE (W)\n| The data area can be written to. Setting this to False locks\n| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE\n| from its base array at creation time, but a view of a writeable\n| array may be subsequently locked while the base array remains writeable.\n| (The opposite is not true, in that a view of a locked array may not\n| be made writeable. However, currently, locking a base object does not\n| lock any views that already reference it, so under that circumstance it\n| is possible to alter the contents of a locked array via a previously\n| created writeable view onto it.) Attempting to change a non-writeable\n| array raises a RuntimeError exception.\n| ALIGNED (A)\n| The data and all elements are aligned appropriately for the hardware.\n| WRITEBACKIFCOPY (X)\n| This array is a copy of some other array. The C-API function\n| PyArrayResolveWritebackIfCopy must be called before deallocating\n| to the base array will be updated with the contents of this array.\n| UPDATEIFCOPY (U)\n| (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.\n| When this array is\n| deallocated, the base array will be updated with the contents of\n| this array.\n| FNC\n| FCONTIGUOUS and not CCONTIGUOUS.\n| FORC\n| FCONTIGUOUS or CCONTIGUOUS (one-segment test).\n| BEHAVED (B)\n| ALIGNED and WRITEABLE.\n| CARRAY (CA)\n| BEHAVED and CCONTIGUOUS.\n| FARRAY (FA)\n| BEHAVED and FCONTIGUOUS and not CCONTIGUOUS.\n|\n| Notes\n| -----\n| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),\n| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag\n| names are only supported in dictionary access.\n|\n| Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be\n| changed by the user, via direct assignment to the attribute or dictionary\n| entry, or by calling `ndarray.setflags`.\n|\n| The array flags cannot be set arbitrarily:\n|\n| - UPDATEIFCOPY can only be set ``False``.\n| - WRITEBACKIFCOPY can only be set ``False``.\n| - ALIGNED can only be set ``True`` if the data is truly aligned.\n| - WRITEABLE can only be set ``True`` if the array owns its own memory\n| or the ultimate owner of the memory exposes a writeable buffer\n| interface or is a string.\n|\n| Arrays can be both C-style and Fortran-style contiguous simultaneously.\n| This is clear for 1-dimensional arrays, but can also be true for higher\n| dimensional arrays.\n|\n| Even for contiguous arrays a stride for a given dimension\n| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``\n| or the array has no elements.\n| It does *not* generally hold that ``self.strides[-1] == self.itemsize``\n| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for\n| Fortran-style contiguous arrays is true.\n|\n| flat\n| A 1-D iterator over the array.\n|\n| This is a `numpy.flatiter` instance, which acts similarly to, but is not\n| a subclass of, Python's built-in iterator object.\n|\n| See Also\n| --------\n| flatten : Return a copy of the array collapsed into one dimension.\n|\n| flatiter\n|\n| Examples\n| --------\n| >>> x = np.arange(1, 7).reshape(2, 3)\n| >>> x\n| array([[1, 2, 3],\n| [4, 5, 6]])\n| >>> x.flat[3]\n| 4\n| >>> x.T\n| array([[1, 4],\n| [2, 5],\n| [3, 6]])\n| >>> x.T.flat[3]\n| 5\n| >>> type(x.flat)\n| \n|\n| An assignment example:\n|\n| >>> x.flat = 3; x\n| array([[3, 3, 3],\n| [3, 3, 3]])\n| >>> x.flat[[1,4]] = 1; x\n| array([[3, 1, 3],\n| [3, 1, 3]])\n|\n| imag\n| The imaginary part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.imag\n| array([ 0. , 0.70710678])\n| >>> x.imag.dtype\n| dtype('float64')\n|\n| itemsize\n| Length of one array element in bytes.\n|\n| Examples\n| --------\n| >>> x = np.array([1,2,3], dtype=np.float64)\n| >>> x.itemsize\n| 8\n| >>> x = np.array([1,2,3], dtype=np.complex128)\n| >>> x.itemsize\n| 16\n|\n| nbytes\n| Total bytes consumed by the elements of the array.\n|\n| Notes\n| -----\n| Does not include memory consumed by non-element attributes of the\n| array object.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3,5,2), dtype=np.complex128)\n| >>> x.nbytes\n| 480\n| >>> np.prod(x.shape) * x.itemsize\n| 480\n|\n| ndim\n| Number of array dimensions.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3])\n| >>> x.ndim\n| 1\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.ndim\n| 3\n|\n| real\n| The real part of the array.\n|\n| Examples\n| --------\n| >>> x = np.sqrt([1+0j, 0+1j])\n| >>> x.real\n| array([ 1. , 0.70710678])\n| >>> x.real.dtype\n| dtype('float64')\n|\n| See Also\n| --------\n| numpy.real : equivalent function\n|\n| shape\n| Tuple of array dimensions.\n|\n| The shape property is usually used to get the current shape of an array,\n| but may also be used to reshape the array in-place by assigning a tuple of\n| array dimensions to it. As with `numpy.reshape`, one of the new shape\n| dimensions can be -1, in which case its value is inferred from the size of\n| the array and the remaining dimensions. Reshaping an array in-place will\n| fail if a copy is required.\n|\n| Examples\n| --------\n| >>> x = np.array([1, 2, 3, 4])\n| >>> x.shape\n| (4,)\n| >>> y = np.zeros((2, 3, 4))\n| >>> y.shape\n| (2, 3, 4)\n| >>> y.shape = (3, 8)\n| >>> y\n| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.],\n| [ 0., 0., 0., 0., 0., 0., 0., 0.]])\n| >>> y.shape = (3, 6)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| ValueError: total size of new array must be unchanged\n| >>> np.zeros((4,2))[::2].shape = (-1,)\n| Traceback (most recent call last):\n| File \"\", line 1, in \n| AttributeError: Incompatible shape for in-place modification. Use\n| `.reshape()` to make a copy with the desired shape.\n|\n| See Also\n| --------\n| numpy.reshape : similar function\n| ndarray.reshape : similar method\n|\n| size\n| Number of elements in the array.\n|\n| Equal to ``np.prod(a.shape)``, i.e., the product of the array's\n| dimensions.\n|\n| Notes\n| -----\n| `a.size` returns a standard arbitrary precision Python integer. This\n| may not be the case with other methods of obtaining the same value\n| (like the suggested ``np.prod(a.shape)``, which returns an instance\n| of ``np.int``), and may be relevant if the value is used further in\n| calculations that may overflow a fixed size integer type.\n|\n| Examples\n| --------\n| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)\n| >>> x.size\n| 30\n| >>> np.prod(x.shape)\n| 30\n|\n| strides\n| Tuple of bytes to step in each dimension when traversing an array.\n|\n| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`\n| is::\n|\n| offset = sum(np.array(i) * a.strides)\n|\n| A more detailed explanation of strides can be found in the\n| \"ndarray.rst\" file in the NumPy reference guide.\n|\n| Notes\n| -----\n| Imagine an array of 32-bit integers (each 4 bytes)::\n|\n| x = np.array([[0, 1, 2, 3, 4],\n| [5, 6, 7, 8, 9]], dtype=np.int32)\n|\n| This array is stored in memory as 40 bytes, one after the other\n| (known as a contiguous block of memory). The strides of an array tell\n| us how many bytes we have to skip in memory to move to the next position\n| along a certain axis. For example, we have to skip 4 bytes (1 value) to\n| move to the next column, but 20 bytes (5 values) to get to the same\n| position in the next row. As such, the strides for the array `x` will be\n| ``(20, 4)``.\n|\n| See Also\n| --------\n| numpy.lib.stridetricks.asstrided\n|\n| Examples\n| --------\n| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))\n| >>> y\n| array([[[ 0, 1, 2, 3],\n| [ 4, 5, 6, 7],\n| [ 8, 9, 10, 11]],\n| [[12, 13, 14, 15],\n| [16, 17, 18, 19],\n| [20, 21, 22, 23]]])\n| >>> y.strides\n| (48, 16, 4)\n| >>> y[1,1,1]\n| 17\n| >>> offset=sum(y.strides * np.array((1,1,1)))\n| >>> offset/y.itemsize\n| 17\n|\n| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)\n| >>> x.strides\n| (32, 4, 224, 1344)\n| >>> i = np.array([3,5,2,2])\n| >>> offset = sum(i * x.strides)\n| >>> x[3,5,2,2]\n| 813\n| >>> offset / x.itemsize\n| 813\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from ndarray:\n|\n| hash = None\n" }, { "name": "class record", "content": "| A data-type scalar that allows field access as attribute lookup.\n|\n| Method resolution order:\n| record\n| void\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| getattribute(self, attr)\n| Return getattr(self, name).\n|\n| getitem(self, indx)\n| Return self[key].\n|\n| repr(self)\n| Return repr(self).\n|\n| setattr(self, attr, val)\n| Implement setattr(self, name, value).\n|\n| str(self)\n| Return str(self).\n|\n| pprint(self)\n| Pretty-print all fields.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from void:\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| data\n| Pointer to start of data.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nshort = class int16(signedinteger)\n| Signed integer type, compatible with C ``short``.\n|\n| :Character code: ``'h'``\n| :Canonical name: `numpy.short`\n| :Alias on this platform (Linux x8664): `numpy.int16`: 16-bit signed integer (``-32768`` to ``32767``).\n|\n| Method resolution order:\n| int16\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class signedinteger", "content": "| Abstract base class of all signed integer scalar types.\n|\n| Method resolution order:\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n\nsingle = class float32(floating)\n| Single-precision floating-point number type, compatible with C ``float``.\n|\n| :Character code: ``'f'``\n| :Canonical name: `numpy.single`\n| :Alias on this platform (Linux x8664): `numpy.float32`: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.\n|\n| Method resolution order:\n| float32\n| floating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self (int, int)\n|\n| Return a pair of integers, whose ratio is exactly equal to the original\n| floating point number, and with a positive denominator.\n| Raise `OverflowError` on infinities and a `ValueError` on NaNs.\n|\n| >>> np.single(10.0).asintegerratio()\n| (10, 1)\n| >>> np.single(0.0).asintegerratio()\n| (0, 1)\n| >>> np.single(-.25).asintegerratio()\n| (-1, 4)\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from floating:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nsinglecomplex = class complex64(complexfloating)\n| Complex number type composed of two single-precision floating-point\n| numbers.\n|\n| :Character code: ``'F'``\n| :Canonical name: `numpy.csingle`\n| :Alias: `numpy.singlecomplex`\n| :Alias on this platform (Linux x8664): `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers.\n|\n| Method resolution order:\n| complex64\n| complexfloating\n| inexact\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| bool(self, /)\n| True if self else False\n|\n| complex(...)\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| int(self, /)\n| int(self)\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nstr0 = class str(builtins.str, character)\n| A unicode string.\n|\n| When used in arrays, this type strips trailing null codepoints.\n|\n| Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its\n| contents as UCS4:\n|\n| >>> m = memoryview(np.str(\"abc\"))\n| >>> m.format\n| '3w'\n| >>> m.tobytes()\n| b'a\\x00\\x00\\x00b\\x00\\x00\\x00c\\x00\\x00\\x00'\n|\n| :Character code: ``'U'``\n| :Alias: `numpy.unicode`\n|\n| Method resolution order:\n| str\n| builtins.str\n| character\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self int\n|\n| Return the number of non-overlapping occurrences of substring sub in\n| string S[start:end]. Optional arguments start and end are\n| interpreted as in slice notation.\n|\n| encode(self, /, encoding='utf-8', errors='strict')\n| Encode the string using the codec registered for encoding.\n|\n| encoding\n| The encoding in which to encode the string.\n| errors\n| The error handling scheme to use for encoding errors.\n| The default is 'strict' meaning that encoding errors raise a\n| UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n| 'xmlcharrefreplace' as well as any other name registered with\n| codecs.registererror that can handle UnicodeEncodeErrors.\n|\n| endswith(...)\n| S.endswith(suffix[, start[, end]]) -> bool\n|\n| Return True if S ends with the specified suffix, False otherwise.\n| With optional start, test S beginning at that position.\n| With optional end, stop comparing S at that position.\n| suffix can also be a tuple of strings to try.\n|\n| expandtabs(self, /, tabsize=8)\n| Return a copy where all tab characters are expanded using spaces.\n|\n| If tabsize is not given, a tab size of 8 characters is assumed.\n|\n| find(...)\n| S.find(sub[, start[, end]]) -> int\n|\n| Return the lowest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| format(...)\n| S.format(*args, kwargs) -> str\n|\n| Return a formatted version of S, using substitutions from args and kwargs.\n| The substitutions are identified by braces ('{' and '}').\n|\n| formatmap(...)\n| S.formatmap(mapping) -> str\n|\n| Return a formatted version of S, using substitutions from mapping.\n| The substitutions are identified by braces ('{' and '}').\n|\n| index(...)\n| S.index(sub[, start[, end]]) -> int\n|\n| Return the lowest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the substring is not found.\n|\n| isalnum(self, /)\n| Return True if the string is an alpha-numeric string, False otherwise.\n|\n| A string is alpha-numeric if all characters in the string are alpha-numeric and\n| there is at least one character in the string.\n|\n| isalpha(self, /)\n| Return True if the string is an alphabetic string, False otherwise.\n|\n| A string is alphabetic if all characters in the string are alphabetic and there\n| is at least one character in the string.\n|\n| isascii(self, /)\n| Return True if all characters in the string are ASCII, False otherwise.\n|\n| ASCII characters have code points in the range U+0000-U+007F.\n| Empty string is ASCII too.\n|\n| isdecimal(self, /)\n| Return True if the string is a decimal string, False otherwise.\n|\n| A string is a decimal string if all characters in the string are decimal and\n| there is at least one character in the string.\n|\n| isdigit(self, /)\n| Return True if the string is a digit string, False otherwise.\n|\n| A string is a digit string if all characters in the string are digits and there\n| is at least one character in the string.\n|\n| isidentifier(self, /)\n| Return True if the string is a valid Python identifier, False otherwise.\n|\n| Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n| such as \"def\" or \"class\".\n|\n| islower(self, /)\n| Return True if the string is a lowercase string, False otherwise.\n|\n| A string is lowercase if all cased characters in the string are lowercase and\n| there is at least one cased character in the string.\n|\n| isnumeric(self, /)\n| Return True if the string is a numeric string, False otherwise.\n|\n| A string is numeric if all characters in the string are numeric and there is at\n| least one character in the string.\n|\n| isprintable(self, /)\n| Return True if the string is printable, False otherwise.\n|\n| A string is printable if all of its characters are considered printable in\n| repr() or if it is empty.\n|\n| isspace(self, /)\n| Return True if the string is a whitespace string, False otherwise.\n|\n| A string is whitespace if all characters in the string are whitespace and there\n| is at least one character in the string.\n|\n| istitle(self, /)\n| Return True if the string is a title-cased string, False otherwise.\n|\n| In a title-cased string, upper- and title-case characters may only\n| follow uncased characters and lowercase characters only cased ones.\n|\n| isupper(self, /)\n| Return True if the string is an uppercase string, False otherwise.\n|\n| A string is uppercase if all cased characters in the string are uppercase and\n| there is at least one cased character in the string.\n|\n| join(self, iterable, /)\n| Concatenate any number of strings.\n|\n| The string whose method is called is inserted in between each given string.\n| The result is returned as a new string.\n|\n| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n|\n| ljust(self, width, fillchar=' ', /)\n| Return a left-justified string of length width.\n|\n| Padding is done using the specified fill character (default is a space).\n|\n| lower(self, /)\n| Return a copy of the string converted to lowercase.\n|\n| lstrip(self, chars=None, /)\n| Return a copy of the string with leading whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| partition(self, sep, /)\n| Partition the string into three parts using the given separator.\n|\n| This will search for the separator in the string. If the separator is found,\n| returns a 3-tuple containing the part before the separator, the separator\n| itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing the original string\n| and two empty strings.\n|\n| removeprefix(self, prefix, /)\n| Return a str with the given prefix string removed if present.\n|\n| If the string starts with the prefix string, return string[len(prefix):].\n| Otherwise, return a copy of the original string.\n|\n| removesuffix(self, suffix, /)\n| Return a str with the given suffix string removed if present.\n|\n| If the string ends with the suffix string and that suffix is not empty,\n| return string[:-len(suffix)]. Otherwise, return a copy of the original\n| string.\n|\n| replace(self, old, new, count=-1, /)\n| Return a copy with all occurrences of substring old replaced by new.\n|\n| count\n| Maximum number of occurrences to replace.\n| -1 (the default value) means replace all occurrences.\n|\n| If the optional argument count is given, only the first count occurrences are\n| replaced.\n|\n| rfind(...)\n| S.rfind(sub[, start[, end]]) -> int\n|\n| Return the highest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| rindex(...)\n| S.rindex(sub[, start[, end]]) -> int\n|\n| Return the highest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the substring is not found.\n|\n| rjust(self, width, fillchar=' ', /)\n| Return a right-justified string of length width.\n|\n| Padding is done using the specified fill character (default is a space).\n|\n| rpartition(self, sep, /)\n| Partition the string into three parts using the given separator.\n|\n| This will search for the separator in the string, starting at the end. If\n| the separator is found, returns a 3-tuple containing the part before the\n| separator, the separator itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing two empty strings\n| and the original string.\n|\n| rsplit(self, /, sep=None, maxsplit=-1)\n| Return a list of the substrings in the string, using sep as the separator string.\n|\n| sep\n| The separator used to split the string.\n|\n| When set to None (the default value), will split on any whitespace\n| character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n| empty strings from the result.\n| maxsplit\n| Maximum number of splits (starting from the left).\n| -1 (the default value) means no limit.\n|\n| Splitting starts at the end of the string and works to the front.\n|\n| rstrip(self, chars=None, /)\n| Return a copy of the string with trailing whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| split(self, /, sep=None, maxsplit=-1)\n| Return a list of the substrings in the string, using sep as the separator string.\n|\n| sep\n| The separator used to split the string.\n|\n| When set to None (the default value), will split on any whitespace\n| character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n| empty strings from the result.\n| maxsplit\n| Maximum number of splits (starting from the left).\n| -1 (the default value) means no limit.\n|\n| Note, str.split() is mainly useful for data that has been intentionally\n| delimited. With natural text that includes punctuation, consider using\n| the regular expression module.\n|\n| splitlines(self, /, keepends=False)\n| Return a list of the lines in the string, breaking at line boundaries.\n|\n| Line breaks are not included in the resulting list unless keepends is given and\n| true.\n|\n| startswith(...)\n| S.startswith(prefix[, start[, end]]) -> bool\n|\n| Return True if S starts with the specified prefix, False otherwise.\n| With optional start, test S beginning at that position.\n| With optional end, stop comparing S at that position.\n| prefix can also be a tuple of strings to try.\n|\n| strip(self, chars=None, /)\n| Return a copy of the string with leading and trailing whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| swapcase(self, /)\n| Convert uppercase characters to lowercase and lowercase characters to uppercase.\n|\n| title(self, /)\n| Return a version of the string where each word is titlecased.\n|\n| More specifically, words start with uppercased characters and all remaining\n| cased characters have lower case.\n|\n| translate(self, table, /)\n| Replace each character in the string using the given translation table.\n|\n| table\n| Translation table, which must be a mapping of Unicode ordinals to\n| Unicode ordinals, strings, or None.\n|\n| The table must implement lookup/indexing via getitem, for instance a\n| dictionary or list. If this operation raises LookupError, the character is\n| left untouched. Characters mapped to None are deleted.\n|\n| upper(self, /)\n| Return a copy of the string converted to uppercase.\n|\n| zfill(self, width, /)\n| Pad a numeric string with zeros on the left, to fill a field of the given width.\n|\n| The string is never truncated.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.str:\n|\n| maketrans(...)\n| Return a translation table usable for str.translate().\n|\n| If there is only one argument, it must be a dictionary mapping Unicode\n| ordinals (integers) or characters to Unicode ordinals, strings or None.\n| Character keys will be then converted to ordinals.\n| If there are two arguments, they must be strings of equal length, and\n| in the resulting dictionary, each character in x will be mapped to the\n| character at the same position in y. If there is a third argument, it\n| must be a string, whose characters will be mapped to None in the result.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class str_", "content": "| A unicode string.\n|\n| When used in arrays, this type strips trailing null codepoints.\n|\n| Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its\n| contents as UCS4:\n|\n| >>> m = memoryview(np.str(\"abc\"))\n| >>> m.format\n| '3w'\n| >>> m.tobytes()\n| b'a\\x00\\x00\\x00b\\x00\\x00\\x00c\\x00\\x00\\x00'\n|\n| :Character code: ``'U'``\n| :Alias: `numpy.unicode`\n|\n| Method resolution order:\n| str\n| builtins.str\n| character\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self int\n|\n| Return the number of non-overlapping occurrences of substring sub in\n| string S[start:end]. Optional arguments start and end are\n| interpreted as in slice notation.\n|\n| encode(self, /, encoding='utf-8', errors='strict')\n| Encode the string using the codec registered for encoding.\n|\n| encoding\n| The encoding in which to encode the string.\n| errors\n| The error handling scheme to use for encoding errors.\n| The default is 'strict' meaning that encoding errors raise a\n| UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n| 'xmlcharrefreplace' as well as any other name registered with\n| codecs.registererror that can handle UnicodeEncodeErrors.\n|\n| endswith(...)\n| S.endswith(suffix[, start[, end]]) -> bool\n|\n| Return True if S ends with the specified suffix, False otherwise.\n| With optional start, test S beginning at that position.\n| With optional end, stop comparing S at that position.\n| suffix can also be a tuple of strings to try.\n|\n| expandtabs(self, /, tabsize=8)\n| Return a copy where all tab characters are expanded using spaces.\n|\n| If tabsize is not given, a tab size of 8 characters is assumed.\n|\n| find(...)\n| S.find(sub[, start[, end]]) -> int\n|\n| Return the lowest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| format(...)\n| S.format(*args, kwargs) -> str\n|\n| Return a formatted version of S, using substitutions from args and kwargs.\n| The substitutions are identified by braces ('{' and '}').\n|\n| formatmap(...)\n| S.formatmap(mapping) -> str\n|\n| Return a formatted version of S, using substitutions from mapping.\n| The substitutions are identified by braces ('{' and '}').\n|\n| index(...)\n| S.index(sub[, start[, end]]) -> int\n|\n| Return the lowest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the substring is not found.\n|\n| isalnum(self, /)\n| Return True if the string is an alpha-numeric string, False otherwise.\n|\n| A string is alpha-numeric if all characters in the string are alpha-numeric and\n| there is at least one character in the string.\n|\n| isalpha(self, /)\n| Return True if the string is an alphabetic string, False otherwise.\n|\n| A string is alphabetic if all characters in the string are alphabetic and there\n| is at least one character in the string.\n|\n| isascii(self, /)\n| Return True if all characters in the string are ASCII, False otherwise.\n|\n| ASCII characters have code points in the range U+0000-U+007F.\n| Empty string is ASCII too.\n|\n| isdecimal(self, /)\n| Return True if the string is a decimal string, False otherwise.\n|\n| A string is a decimal string if all characters in the string are decimal and\n| there is at least one character in the string.\n|\n| isdigit(self, /)\n| Return True if the string is a digit string, False otherwise.\n|\n| A string is a digit string if all characters in the string are digits and there\n| is at least one character in the string.\n|\n| isidentifier(self, /)\n| Return True if the string is a valid Python identifier, False otherwise.\n|\n| Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n| such as \"def\" or \"class\".\n|\n| islower(self, /)\n| Return True if the string is a lowercase string, False otherwise.\n|\n| A string is lowercase if all cased characters in the string are lowercase and\n| there is at least one cased character in the string.\n|\n| isnumeric(self, /)\n| Return True if the string is a numeric string, False otherwise.\n|\n| A string is numeric if all characters in the string are numeric and there is at\n| least one character in the string.\n|\n| isprintable(self, /)\n| Return True if the string is printable, False otherwise.\n|\n| A string is printable if all of its characters are considered printable in\n| repr() or if it is empty.\n|\n| isspace(self, /)\n| Return True if the string is a whitespace string, False otherwise.\n|\n| A string is whitespace if all characters in the string are whitespace and there\n| is at least one character in the string.\n|\n| istitle(self, /)\n| Return True if the string is a title-cased string, False otherwise.\n|\n| In a title-cased string, upper- and title-case characters may only\n| follow uncased characters and lowercase characters only cased ones.\n|\n| isupper(self, /)\n| Return True if the string is an uppercase string, False otherwise.\n|\n| A string is uppercase if all cased characters in the string are uppercase and\n| there is at least one cased character in the string.\n|\n| join(self, iterable, /)\n| Concatenate any number of strings.\n|\n| The string whose method is called is inserted in between each given string.\n| The result is returned as a new string.\n|\n| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n|\n| ljust(self, width, fillchar=' ', /)\n| Return a left-justified string of length width.\n|\n| Padding is done using the specified fill character (default is a space).\n|\n| lower(self, /)\n| Return a copy of the string converted to lowercase.\n|\n| lstrip(self, chars=None, /)\n| Return a copy of the string with leading whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| partition(self, sep, /)\n| Partition the string into three parts using the given separator.\n|\n| This will search for the separator in the string. If the separator is found,\n| returns a 3-tuple containing the part before the separator, the separator\n| itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing the original string\n| and two empty strings.\n|\n| removeprefix(self, prefix, /)\n| Return a str with the given prefix string removed if present.\n|\n| If the string starts with the prefix string, return string[len(prefix):].\n| Otherwise, return a copy of the original string.\n|\n| removesuffix(self, suffix, /)\n| Return a str with the given suffix string removed if present.\n|\n| If the string ends with the suffix string and that suffix is not empty,\n| return string[:-len(suffix)]. Otherwise, return a copy of the original\n| string.\n|\n| replace(self, old, new, count=-1, /)\n| Return a copy with all occurrences of substring old replaced by new.\n|\n| count\n| Maximum number of occurrences to replace.\n| -1 (the default value) means replace all occurrences.\n|\n| If the optional argument count is given, only the first count occurrences are\n| replaced.\n|\n| rfind(...)\n| S.rfind(sub[, start[, end]]) -> int\n|\n| Return the highest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| rindex(...)\n| S.rindex(sub[, start[, end]]) -> int\n|\n| Return the highest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the substring is not found.\n|\n| rjust(self, width, fillchar=' ', /)\n| Return a right-justified string of length width.\n|\n| Padding is done using the specified fill character (default is a space).\n|\n| rpartition(self, sep, /)\n| Partition the string into three parts using the given separator.\n|\n| This will search for the separator in the string, starting at the end. If\n| the separator is found, returns a 3-tuple containing the part before the\n| separator, the separator itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing two empty strings\n| and the original string.\n|\n| rsplit(self, /, sep=None, maxsplit=-1)\n| Return a list of the substrings in the string, using sep as the separator string.\n|\n| sep\n| The separator used to split the string.\n|\n| When set to None (the default value), will split on any whitespace\n| character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n| empty strings from the result.\n| maxsplit\n| Maximum number of splits (starting from the left).\n| -1 (the default value) means no limit.\n|\n| Splitting starts at the end of the string and works to the front.\n|\n| rstrip(self, chars=None, /)\n| Return a copy of the string with trailing whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| split(self, /, sep=None, maxsplit=-1)\n| Return a list of the substrings in the string, using sep as the separator string.\n|\n| sep\n| The separator used to split the string.\n|\n| When set to None (the default value), will split on any whitespace\n| character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n| empty strings from the result.\n| maxsplit\n| Maximum number of splits (starting from the left).\n| -1 (the default value) means no limit.\n|\n| Note, str.split() is mainly useful for data that has been intentionally\n| delimited. With natural text that includes punctuation, consider using\n| the regular expression module.\n|\n| splitlines(self, /, keepends=False)\n| Return a list of the lines in the string, breaking at line boundaries.\n|\n| Line breaks are not included in the resulting list unless keepends is given and\n| true.\n|\n| startswith(...)\n| S.startswith(prefix[, start[, end]]) -> bool\n|\n| Return True if S starts with the specified prefix, False otherwise.\n| With optional start, test S beginning at that position.\n| With optional end, stop comparing S at that position.\n| prefix can also be a tuple of strings to try.\n|\n| strip(self, chars=None, /)\n| Return a copy of the string with leading and trailing whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| swapcase(self, /)\n| Convert uppercase characters to lowercase and lowercase characters to uppercase.\n|\n| title(self, /)\n| Return a version of the string where each word is titlecased.\n|\n| More specifically, words start with uppercased characters and all remaining\n| cased characters have lower case.\n|\n| translate(self, table, /)\n| Replace each character in the string using the given translation table.\n|\n| table\n| Translation table, which must be a mapping of Unicode ordinals to\n| Unicode ordinals, strings, or None.\n|\n| The table must implement lookup/indexing via getitem, for instance a\n| dictionary or list. If this operation raises LookupError, the character is\n| left untouched. Characters mapped to None are deleted.\n|\n| upper(self, /)\n| Return a copy of the string converted to uppercase.\n|\n| zfill(self, width, /)\n| Pad a numeric string with zeros on the left, to fill a field of the given width.\n|\n| The string is never truncated.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.str:\n|\n| maketrans(...)\n| Return a translation table usable for str.translate().\n|\n| If there is only one argument, it must be a dictionary mapping Unicode\n| ordinals (integers) or characters to Unicode ordinals, strings or None.\n| Character keys will be then converted to ordinals.\n| If there are two arguments, they must be strings of equal length, and\n| in the resulting dictionary, each character in x will be mapped to the\n| character at the same position in y. If there is a third argument, it\n| must be a string, whose characters will be mapped to None in the result.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nstring = class bytes(builtins.bytes, character)\n| A byte string.\n|\n| When used in arrays, this type strips trailing null bytes.\n|\n| :Character code: ``'S'``\n| :Alias: `numpy.string`\n|\n| Method resolution order:\n| bytes\n| builtins.bytes\n| character\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self copy of B\n|\n| Return a copy of B with only its first character capitalized (ASCII)\n| and the rest lower-cased.\n|\n| center(self, width, fillchar=b' ', /)\n| Return a centered string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| count(...)\n| B.count(sub[, start[, end]]) -> int\n|\n| Return the number of non-overlapping occurrences of subsection sub in\n| bytes B[start:end]. Optional arguments start and end are interpreted\n| as in slice notation.\n|\n| decode(self, /, encoding='utf-8', errors='strict')\n| Decode the bytes using the codec registered for encoding.\n|\n| encoding\n| The encoding with which to decode the bytes.\n| errors\n| The error handling scheme to use for the handling of decoding errors.\n| The default is 'strict' meaning that decoding errors raise a\n| UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n| as well as any other name registered with codecs.registererror that\n| can handle UnicodeDecodeErrors.\n|\n| endswith(...)\n| B.endswith(suffix[, start[, end]]) -> bool\n|\n| Return True if B ends with the specified suffix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| suffix can also be a tuple of bytes to try.\n|\n| expandtabs(self, /, tabsize=8)\n| Return a copy where all tab characters are expanded using spaces.\n|\n| If tabsize is not given, a tab size of 8 characters is assumed.\n|\n| find(...)\n| B.find(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| hex(...)\n| Create a string of hexadecimal numbers from a bytes object.\n|\n| sep\n| An optional single character or byte to separate hex bytes.\n| bytespersep\n| How many bytes between separators. Positive values count from the\n| right, negative values count from the left.\n|\n| Example:\n| >>> value = b'\\xb9\\x01\\xef'\n| >>> value.hex()\n| 'b901ef'\n| >>> value.hex(':')\n| 'b9:01:ef'\n| >>> value.hex(':', 2)\n| 'b9:01ef'\n| >>> value.hex(':', -2)\n| 'b901:ef'\n|\n| index(...)\n| B.index(sub[, start[, end]]) -> int\n|\n| Return the lowest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the subsection is not found.\n|\n| isalnum(...)\n| B.isalnum() -> bool\n|\n| Return True if all characters in B are alphanumeric\n| and there is at least one character in B, False otherwise.\n|\n| isalpha(...)\n| B.isalpha() -> bool\n|\n| Return True if all characters in B are alphabetic\n| and there is at least one character in B, False otherwise.\n|\n| isascii(...)\n| B.isascii() -> bool\n|\n| Return True if B is empty or all characters in B are ASCII,\n| False otherwise.\n|\n| isdigit(...)\n| B.isdigit() -> bool\n|\n| Return True if all characters in B are digits\n| and there is at least one character in B, False otherwise.\n|\n| islower(...)\n| B.islower() -> bool\n|\n| Return True if all cased characters in B are lowercase and there is\n| at least one cased character in B, False otherwise.\n|\n| isspace(...)\n| B.isspace() -> bool\n|\n| Return True if all characters in B are whitespace\n| and there is at least one character in B, False otherwise.\n|\n| istitle(...)\n| B.istitle() -> bool\n|\n| Return True if B is a titlecased string and there is at least one\n| character in B, i.e. uppercase characters may only follow uncased\n| characters and lowercase characters only cased ones. Return False\n| otherwise.\n|\n| isupper(...)\n| B.isupper() -> bool\n|\n| Return True if all cased characters in B are uppercase and there is\n| at least one cased character in B, False otherwise.\n|\n| join(self, iterableofbytes, /)\n| Concatenate any number of bytes objects.\n|\n| The bytes whose method is called is inserted in between each pair.\n|\n| The result is returned as a new bytes object.\n|\n| Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.\n|\n| ljust(self, width, fillchar=b' ', /)\n| Return a left-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| lower(...)\n| B.lower() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to lowercase.\n|\n| lstrip(self, bytes=None, /)\n| Strip leading bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading ASCII whitespace.\n|\n| partition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes. If the separator is found,\n| returns a 3-tuple containing the part before the separator, the separator\n| itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing the original bytes\n| object and two empty bytes objects.\n|\n| removeprefix(self, prefix, /)\n| Return a bytes object with the given prefix string removed if present.\n|\n| If the bytes starts with the prefix string, return bytes[len(prefix):].\n| Otherwise, return a copy of the original bytes.\n|\n| removesuffix(self, suffix, /)\n| Return a bytes object with the given suffix string removed if present.\n|\n| If the bytes ends with the suffix string and that suffix is not empty,\n| return bytes[:-len(prefix)]. Otherwise, return a copy of the original\n| bytes.\n|\n| replace(self, old, new, count=-1, /)\n| Return a copy with all occurrences of substring old replaced by new.\n|\n| count\n| Maximum number of occurrences to replace.\n| -1 (the default value) means replace all occurrences.\n|\n| If the optional argument count is given, only the first count occurrences are\n| replaced.\n|\n| rfind(...)\n| B.rfind(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| rindex(...)\n| B.rindex(sub[, start[, end]]) -> int\n|\n| Return the highest index in B where subsection sub is found,\n| such that sub is contained within B[start,end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raise ValueError when the subsection is not found.\n|\n| rjust(self, width, fillchar=b' ', /)\n| Return a right-justified string of length width.\n|\n| Padding is done using the specified fill character.\n|\n| rpartition(self, sep, /)\n| Partition the bytes into three parts using the given separator.\n|\n| This will search for the separator sep in the bytes, starting at the end. If\n| the separator is found, returns a 3-tuple containing the part before the\n| separator, the separator itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing two empty bytes\n| objects and the original bytes object.\n|\n| rsplit(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| Splitting is done starting at the end of the bytes and working to the front.\n|\n| rstrip(self, bytes=None, /)\n| Strip trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip trailing ASCII whitespace.\n|\n| split(self, /, sep=None, maxsplit=-1)\n| Return a list of the sections in the bytes, using sep as the delimiter.\n|\n| sep\n| The delimiter according which to split the bytes.\n| None (the default value) means split on ASCII whitespace characters\n| (space, tab, return, newline, formfeed, vertical tab).\n| maxsplit\n| Maximum number of splits to do.\n| -1 (the default value) means no limit.\n|\n| splitlines(self, /, keepends=False)\n| Return a list of the lines in the bytes, breaking at line boundaries.\n|\n| Line breaks are not included in the resulting list unless keepends is given and\n| true.\n|\n| startswith(...)\n| B.startswith(prefix[, start[, end]]) -> bool\n|\n| Return True if B starts with the specified prefix, False otherwise.\n| With optional start, test B beginning at that position.\n| With optional end, stop comparing B at that position.\n| prefix can also be a tuple of bytes to try.\n|\n| strip(self, bytes=None, /)\n| Strip leading and trailing bytes contained in the argument.\n|\n| If the argument is omitted or None, strip leading and trailing ASCII whitespace.\n|\n| swapcase(...)\n| B.swapcase() -> copy of B\n|\n| Return a copy of B with uppercase ASCII characters converted\n| to lowercase ASCII and vice versa.\n|\n| title(...)\n| B.title() -> copy of B\n|\n| Return a titlecased version of B, i.e. ASCII words start with uppercase\n| characters, all remaining cased characters have lowercase.\n|\n| translate(self, table, /, delete=b'')\n| Return a copy with each character mapped by the given translation table.\n|\n| table\n| Translation table, which must be a bytes object of length 256.\n|\n| All characters occurring in the optional argument delete are removed.\n| The remaining characters are mapped through the given translation table.\n|\n| upper(...)\n| B.upper() -> copy of B\n|\n| Return a copy of B with all ASCII characters converted to uppercase.\n|\n| zfill(self, width, /)\n| Pad a numeric string with zeros on the left, to fill a field of the given width.\n|\n| The original string is never truncated.\n|\n| ----------------------------------------------------------------------\n| Class methods inherited from builtins.bytes:\n|\n| fromhex(string, /) from builtins.type\n| Create a bytes object from a string of hexadecimal numbers.\n|\n| Spaces between two numbers are accepted.\n| Example: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.bytes:\n|\n| maketrans(frm, to, /)\n| Return a translation table useable for the bytes or bytearray translate method.\n|\n| The returned table will be one where each byte in frm is mapped to the byte at\n| the same position in to.\n|\n| The bytes objects frm and to must be of the same length.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class timedelta64", "content": "| A timedelta stored as a 64-bit integer.\n|\n| See :ref:`arrays.datetime` for more information.\n|\n| :Character code: ``'m'``\n|\n| Method resolution order:\n| timedelta64\n| signedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nubyte = class uint8(unsignedinteger)\n| Unsigned integer type, compatible with C ``unsigned char``.\n|\n| :Character code: ``'B'``\n| :Canonical name: `numpy.ubyte`\n| :Alias on this platform (Linux x8664): `numpy.uint8`: 8-bit unsigned integer (``0`` to ``255``).\n|\n| Method resolution order:\n| uint8\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class ufunc", "content": "| Functions that operate element by element on whole arrays.\n|\n| To see the documentation for a specific ufunc, use `info`. For\n| example, ``np.info(np.sin)``. Because ufuncs are written in C\n| (for speed) and linked into Python with NumPy's ufunc facility,\n| Python's help() function finds this page whenever help() is called\n| on a ufunc.\n|\n| A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`.\n|\n| Calling ufuncs: ``op(*x[, out], where=True, kwargs)``\n|\n| Apply `op` to the arguments `*x` elementwise, broadcasting the arguments.\n|\n| The broadcasting rules are:\n|\n| * Dimensions of length 1 may be prepended to either array.\n| * Arrays may be repeated along dimensions of length 1.\n|\n| Parameters\n| ----------\n| *x : arraylike\n| Input arrays.\n| out : ndarray, None, or tuple of ndarray and None, optional\n| Alternate array object(s) in which to put the result; if provided, it\n| must have a shape that the inputs broadcast to. A tuple of arrays\n| (possible only as a keyword argument) must have length equal to the\n| number of outputs; use None for uninitialized outputs to be\n| allocated by the ufunc.\n| where : arraylike, optional\n| This condition is broadcast over the input. At locations where the\n| condition is True, the `out` array will be set to the ufunc result.\n| Elsewhere, the `out` array will retain its original value.\n| Note that if an uninitialized `out` array is created via the default\n| ``out=None``, locations within it where the condition is False will\n| remain uninitialized.\n| kwargs\n| For other keyword-only arguments, see the :ref:`ufunc docs `.\n|\n| Returns\n| -------\n| r : ndarray or tuple of ndarray\n| `r` will have the shape that the arrays in `x` broadcast to; if `out` is\n| provided, it will be returned. If not, `r` will be allocated and\n| may contain uninitialized values. If the function has more than one\n| output, then the result will be a tuple of arrays.\n|\n| Methods defined here:\n|\n| call(self, /, *args, kwargs)\n| Call self as a function.\n|\n| repr(self, /)\n| Return repr(self).\n|\n| str(self, /)\n| Return str(self).\n|\n| accumulate(...)\n| accumulate(array, axis=0, dtype=None, out=None)\n|\n| Accumulate the result of applying the operator to all elements.\n|\n| For a one-dimensional array, accumulate produces results equivalent to::\n|\n| r = np.empty(len(A))\n| t = op.identity # op = the ufunc being applied to A's elements\n| for i in range(len(A)):\n| t = op(t, A[i])\n| r[i] = t\n| return r\n|\n| For example, add.accumulate() is equivalent to np.cumsum().\n|\n| For a multi-dimensional array, accumulate is applied along only one\n| axis (axis zero by default; see Examples below) so repeated use is\n| necessary if one wants to accumulate over multiple axes.\n|\n| Parameters\n| ----------\n| array : arraylike\n| The array to act on.\n| axis : int, optional\n| The axis along which to apply the accumulation; default is zero.\n| dtype : data-type code, optional\n| The data-type used to represent the intermediate results. Defaults\n| to the data-type of the output array if such is provided, or the\n| the data-type of the input array if no output array is provided.\n| out : ndarray, None, or tuple of ndarray and None, optional\n| A location into which the result is stored. If not provided or None,\n| a freshly-allocated array is returned. For consistency with\n| ``ufunc.call``, if given as a keyword, this may be wrapped in a\n| 1-element tuple.\n|\n| .. versionchanged:: 1.13.0\n| Tuples are allowed for keyword argument.\n|\n| Returns\n| -------\n| r : ndarray\n| The accumulated values. If `out` was supplied, `r` is a reference to\n| `out`.\n|\n| Examples\n| --------\n| 1-D array examples:\n|\n| >>> np.add.accumulate([2, 3, 5])\n| array([ 2, 5, 10])\n| >>> np.multiply.accumulate([2, 3, 5])\n| array([ 2, 6, 30])\n|\n| 2-D array examples:\n|\n| >>> I = np.eye(2)\n| >>> I\n| array([[1., 0.],\n| [0., 1.]])\n|\n| Accumulate along axis 0 (rows), down columns:\n|\n| >>> np.add.accumulate(I, 0)\n| array([[1., 0.],\n| [1., 1.]])\n| >>> np.add.accumulate(I) # no axis specified = axis zero\n| array([[1., 0.],\n| [1., 1.]])\n|\n| Accumulate along axis 1 (columns), through rows:\n|\n| >>> np.add.accumulate(I, 1)\n| array([[1., 1.],\n| [0., 1.]])\n|\n| at(...)\n| at(a, indices, b=None, /)\n|\n| Performs unbuffered in place operation on operand 'a' for elements\n| specified by 'indices'. For addition ufunc, this method is equivalent to\n| ``a[indices] += b``, except that results are accumulated for elements that\n| are indexed more than once. For example, ``a[[0,0]] += 1`` will only\n| increment the first element once because of buffering, whereas\n| ``add.at(a, [0,0], 1)`` will increment the first element twice.\n|\n| .. versionadded:: 1.8.0\n|\n| Parameters\n| ----------\n| a : arraylike\n| The array to perform in place operation on.\n| indices : arraylike or tuple\n| Array like index object or slice object for indexing into first\n| operand. If first operand has multiple dimensions, indices can be a\n| tuple of array like index objects or slice objects.\n| b : arraylike\n| Second operand for ufuncs requiring two operands. Operand must be\n| broadcastable over first operand after indexing or slicing.\n|\n| Examples\n| --------\n| Set items 0 and 1 to their negative values:\n|\n| >>> a = np.array([1, 2, 3, 4])\n| >>> np.negative.at(a, [0, 1])\n| >>> a\n| array([-1, -2, 3, 4])\n|\n| Increment items 0 and 1, and increment item 2 twice:\n|\n| >>> a = np.array([1, 2, 3, 4])\n| >>> np.add.at(a, [0, 1, 2, 2], 1)\n| >>> a\n| array([2, 3, 5, 4])\n|\n| Add items 0 and 1 in first array to second array,\n| and store results in first array:\n|\n| >>> a = np.array([1, 2, 3, 4])\n| >>> b = np.array([1, 2])\n| >>> np.add.at(a, [0, 1], b)\n| >>> a\n| array([2, 4, 3, 4])\n|\n| outer(...)\n| outer(A, B, /, kwargs)\n|\n| Apply the ufunc `op` to all pairs (a, b) with a in `A` and b in `B`.\n|\n| Let ``M = A.ndim``, ``N = B.ndim``. Then the result, `C`, of\n| ``op.outer(A, B)`` is an array of dimension M + N such that:\n|\n| .. math:: C[i0, ..., i{M-1}, j0, ..., j{N-1}] =\n| op(A[i0, ..., i{M-1}], B[j0, ..., j{N-1}])\n|\n| For `A` and `B` one-dimensional, this is equivalent to::\n|\n| r = empty(len(A),len(B))\n| for i in range(len(A)):\n| for j in range(len(B)):\n| r[i,j] = op(A[i], B[j]) # op = ufunc in question\n|\n| Parameters\n| ----------\n| A : arraylike\n| First array\n| B : arraylike\n| Second array\n| kwargs : any\n| Arguments to pass on to the ufunc. Typically `dtype` or `out`.\n| See `ufunc` for a comprehensive overview of all available arguments.\n|\n| Returns\n| -------\n| r : ndarray\n| Output array\n|\n| See Also\n| --------\n| numpy.outer : A less powerful version of ``np.multiply.outer``\n| that `ravel`\\ s all inputs to 1D. This exists\n| primarily for compatibility with old code.\n|\n| tensordot : ``np.tensordot(a, b, axes=((), ()))`` and\n| ``np.multiply.outer(a, b)`` behave same for all\n| dimensions of a and b.\n|\n| Examples\n| --------\n| >>> np.multiply.outer([1, 2, 3], [4, 5, 6])\n| array([[ 4, 5, 6],\n| [ 8, 10, 12],\n| [12, 15, 18]])\n|\n| A multi-dimensional example:\n|\n| >>> A = np.array([[1, 2, 3], [4, 5, 6]])\n| >>> A.shape\n| (2, 3)\n| >>> B = np.array([[1, 2, 3, 4]])\n| >>> B.shape\n| (1, 4)\n| >>> C = np.multiply.outer(A, B)\n| >>> C.shape; C\n| (2, 3, 1, 4)\n| array([[[[ 1, 2, 3, 4]],\n| [[ 2, 4, 6, 8]],\n| [[ 3, 6, 9, 12]]],\n| [[[ 4, 8, 12, 16]],\n| [[ 5, 10, 15, 20]],\n| [[ 6, 12, 18, 24]]]])\n|\n| reduce(...)\n| reduce(array, axis=0, dtype=None, out=None, keepdims=False, initial=, where=True)\n|\n| Reduces `array`'s dimension by one, by applying ufunc along one axis.\n|\n| Let :math:`array.shape = (N0, ..., Ni, ..., N{M-1})`. Then\n| :math:`ufunc.reduce(array, axis=i)[k0, ..,k{i-1}, k{i+1}, .., k{M-1}]` =\n| the result of iterating `j` over :math:`range(Ni)`, cumulatively applying\n| ufunc to each :math:`array[k0, ..,k{i-1}, j, k{i+1}, .., k{M-1}]`.\n| For a one-dimensional array, reduce produces results equivalent to:\n| ::\n|\n| r = op.identity # op = ufunc\n| for i in range(len(A)):\n| r = op(r, A[i])\n| return r\n|\n| For example, add.reduce() is equivalent to sum().\n|\n| Parameters\n| ----------\n| array : arraylike\n| The array to act on.\n| axis : None or int or tuple of ints, optional\n| Axis or axes along which a reduction is performed.\n| The default (`axis` = 0) is perform a reduction over the first\n| dimension of the input array. `axis` may be negative, in\n| which case it counts from the last to the first axis.\n|\n| .. versionadded:: 1.7.0\n|\n| If this is None, a reduction is performed over all the axes.\n| If this is a tuple of ints, a reduction is performed on multiple\n| axes, instead of a single axis or all the axes as before.\n|\n| For operations which are either not commutative or not associative,\n| doing a reduction over multiple axes is not well-defined. The\n| ufuncs do not currently raise an exception in this case, but will\n| likely do so in the future.\n| dtype : data-type code, optional\n| The type used to represent the intermediate results. Defaults\n| to the data-type of the output array if this is provided, or\n| the data-type of the input array if no output array is provided.\n| out : ndarray, None, or tuple of ndarray and None, optional\n| A location into which the result is stored. If not provided or None,\n| a freshly-allocated array is returned. For consistency with\n| ``ufunc.call``, if given as a keyword, this may be wrapped in a\n| 1-element tuple.\n|\n| .. versionchanged:: 1.13.0\n| Tuples are allowed for keyword argument.\n| keepdims : bool, optional\n| If this is set to True, the axes which are reduced are left\n| in the result as dimensions with size one. With this option,\n| the result will broadcast correctly against the original `array`.\n|\n| .. versionadded:: 1.7.0\n| initial : scalar, optional\n| The value with which to start the reduction.\n| If the ufunc has no identity or the dtype is object, this defaults\n| to None - otherwise it defaults to ufunc.identity.\n| If ``None`` is given, the first element of the reduction is used,\n| and an error is thrown if the reduction is empty.\n|\n| .. versionadded:: 1.15.0\n|\n| where : arraylike of bool, optional\n| A boolean array which is broadcasted to match the dimensions\n| of `array`, and selects elements to include in the reduction. Note\n| that for ufuncs like ``minimum`` that do not have an identity\n| defined, one has to pass in also ``initial``.\n|\n| .. versionadded:: 1.17.0\n|\n| Returns\n| -------\n| r : ndarray\n| The reduced array. If `out` was supplied, `r` is a reference to it.\n|\n| Examples\n| --------\n| >>> np.multiply.reduce([2,3,5])\n| 30\n|\n| A multi-dimensional array example:\n|\n| >>> X = np.arange(8).reshape((2,2,2))\n| >>> X\n| array([[[0, 1],\n| [2, 3]],\n| [[4, 5],\n| [6, 7]]])\n| >>> np.add.reduce(X, 0)\n| array([[ 4, 6],\n| [ 8, 10]])\n| >>> np.add.reduce(X) # confirm: default axis value is 0\n| array([[ 4, 6],\n| [ 8, 10]])\n| >>> np.add.reduce(X, 1)\n| array([[ 2, 4],\n| [10, 12]])\n| >>> np.add.reduce(X, 2)\n| array([[ 1, 5],\n| [ 9, 13]])\n|\n| You can use the ``initial`` keyword argument to initialize the reduction\n| with a different value, and ``where`` to select specific elements to include:\n|\n| >>> np.add.reduce([10], initial=5)\n| 15\n| >>> np.add.reduce(np.ones((2, 2, 2)), axis=(0, 2), initial=10)\n| array([14., 14.])\n| >>> a = np.array([10., np.nan, 10])\n| >>> np.add.reduce(a, where=~np.isnan(a))\n| 20.0\n|\n| Allows reductions of empty arrays where they would normally fail, i.e.\n| for ufuncs without an identity.\n|\n| >>> np.minimum.reduce([], initial=np.inf)\n| inf\n| >>> np.minimum.reduce([[1., 2.], [3., 4.]], initial=10., where=[True, False])\n| array([ 1., 10.])\n| >>> np.minimum.reduce([])\n| Traceback (most recent call last):\n| ...\n| ValueError: zero-size array to reduction operation minimum which has no identity\n|\n| reduceat(...)\n| reduceat(array, indices, axis=0, dtype=None, out=None)\n|\n| Performs a (local) reduce with specified slices over a single axis.\n|\n| For i in ``range(len(indices))``, `reduceat` computes\n| ``ufunc.reduce(array[indices[i]:indices[i+1]])``, which becomes the i-th\n| generalized \"row\" parallel to `axis` in the final result (i.e., in a\n| 2-D array, for example, if `axis = 0`, it becomes the i-th row, but if\n| `axis = 1`, it becomes the i-th column). There are three exceptions to this:\n|\n| * when ``i = len(indices) - 1`` (so for the last index),\n| ``indices[i+1] = array.shape[axis]``.\n| * if ``indices[i] >= indices[i + 1]``, the i-th generalized \"row\" is\n| simply ``array[indices[i]]``.\n| * if ``indices[i] >= len(array)`` or ``indices[i] < 0``, an error is raised.\n|\n| The shape of the output depends on the size of `indices`, and may be\n| larger than `array` (this happens if ``len(indices) > array.shape[axis]``).\n|\n| Parameters\n| ----------\n| array : arraylike\n| The array to act on.\n| indices : arraylike\n| Paired indices, comma separated (not colon), specifying slices to\n| reduce.\n| axis : int, optional\n| The axis along which to apply the reduceat.\n| dtype : data-type code, optional\n| The type used to represent the intermediate results. Defaults\n| to the data type of the output array if this is provided, or\n| the data type of the input array if no output array is provided.\n| out : ndarray, None, or tuple of ndarray and None, optional\n| A location into which the result is stored. If not provided or None,\n| a freshly-allocated array is returned. For consistency with\n| ``ufunc.call``, if given as a keyword, this may be wrapped in a\n| 1-element tuple.\n|\n| .. versionchanged:: 1.13.0\n| Tuples are allowed for keyword argument.\n|\n| Returns\n| -------\n| r : ndarray\n| The reduced values. If `out` was supplied, `r` is a reference to\n| `out`.\n|\n| Notes\n| -----\n| A descriptive example:\n|\n| If `array` is 1-D, the function `ufunc.accumulate(array)` is the same as\n| ``ufunc.reduceat(array, indices)[::2]`` where `indices` is\n| ``range(len(array) - 1)`` with a zero placed\n| in every other element:\n| ``indices = zeros(2 * len(array) - 1)``,\n| ``indices[1::2] = range(1, len(array))``.\n|\n| Don't be fooled by this attribute's name: `reduceat(array)` is not\n| necessarily smaller than `array`.\n|\n| Examples\n| --------\n| To take the running sum of four successive values:\n|\n| >>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]\n| array([ 6, 10, 14, 18])\n|\n| A 2-D example:\n|\n| >>> x = np.linspace(0, 15, 16).reshape(4,4)\n| >>> x\n| array([[ 0., 1., 2., 3.],\n| [ 4., 5., 6., 7.],\n| [ 8., 9., 10., 11.],\n| [12., 13., 14., 15.]])\n|\n| ::\n|\n| # reduce such that the result has the following five rows:\n| # [row1 + row2 + row3]\n| # [row4]\n| # [row2]\n| # [row3]\n| # [row1 + row2 + row3 + row4]\n|\n| >>> np.add.reduceat(x, [0, 3, 1, 2, 0])\n| array([[12., 15., 18., 21.],\n| [12., 13., 14., 15.],\n| [ 4., 5., 6., 7.],\n| [ 8., 9., 10., 11.],\n| [24., 28., 32., 36.]])\n|\n| ::\n|\n| # reduce such that result has the following two columns:\n| # [col1 * col2 * col3, col4]\n|\n| >>> np.multiply.reduceat(x, [0, 3], 1)\n| array([[ 0., 3.],\n| [ 120., 7.],\n| [ 720., 11.],\n| [2184., 15.]])\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| identity\n| The identity value.\n|\n| Data attribute containing the identity element for the ufunc, if it has one.\n| If it does not, the attribute value is None.\n|\n| Examples\n| --------\n| >>> np.add.identity\n| 0\n| >>> np.multiply.identity\n| 1\n| >>> np.power.identity\n| 1\n| >>> print(np.exp.identity)\n| None\n|\n| nargs\n| The number of arguments.\n|\n| Data attribute containing the number of arguments the ufunc takes, including\n| optional ones.\n|\n| Notes\n| -----\n| Typically this value will be one more than what you might expect because all\n| ufuncs take the optional \"out\" argument.\n|\n| Examples\n| --------\n| >>> np.add.nargs\n| 3\n| >>> np.multiply.nargs\n| 3\n| >>> np.power.nargs\n| 3\n| >>> np.exp.nargs\n| 2\n|\n| nin\n| The number of inputs.\n|\n| Data attribute containing the number of arguments the ufunc treats as input.\n|\n| Examples\n| --------\n| >>> np.add.nin\n| 2\n| >>> np.multiply.nin\n| 2\n| >>> np.power.nin\n| 2\n| >>> np.exp.nin\n| 1\n|\n| nout\n| The number of outputs.\n|\n| Data attribute containing the number of arguments the ufunc treats as output.\n|\n| Notes\n| -----\n| Since all ufuncs can take output arguments, this will always be (at least) 1.\n|\n| Examples\n| --------\n| >>> np.add.nout\n| 1\n| >>> np.multiply.nout\n| 1\n| >>> np.power.nout\n| 1\n| >>> np.exp.nout\n| 1\n|\n| ntypes\n| The number of types.\n|\n| The number of numerical NumPy types - of which there are 18 total - on which\n| the ufunc can operate.\n|\n| See Also\n| --------\n| numpy.ufunc.types\n|\n| Examples\n| --------\n| >>> np.add.ntypes\n| 18\n| >>> np.multiply.ntypes\n| 18\n| >>> np.power.ntypes\n| 17\n| >>> np.exp.ntypes\n| 7\n| >>> np.remainder.ntypes\n| 14\n|\n| signature\n| Definition of the core elements a generalized ufunc operates on.\n|\n| The signature determines how the dimensions of each input/output array\n| are split into core and loop dimensions:\n|\n| 1. Each dimension in the signature is matched to a dimension of the\n| corresponding passed-in array, starting from the end of the shape tuple.\n| 2. Core dimensions assigned to the same label in the signature must have\n| exactly matching sizes, no broadcasting is performed.\n| 3. The core dimensions are removed from all inputs and the remaining\n| dimensions are broadcast together, defining the loop dimensions.\n|\n| Notes\n| -----\n| Generalized ufuncs are used internally in many linalg functions, and in\n| the testing suite; the examples below are taken from these.\n| For ufuncs that operate on scalars, the signature is None, which is\n| equivalent to '()' for every argument.\n|\n| Examples\n| --------\n| >>> np.core.umathtests.matrixmultiply.signature\n| '(m,n),(n,p)->(m,p)'\n| >>> np.linalg.umathlinalg.det.signature\n| '(m,m)->()'\n| >>> np.add.signature is None\n| True # equivalent to '(),()->()'\n|\n| types\n| Returns a list with types grouped input->output.\n|\n| Data attribute listing the data-type \"Domain-Range\" groupings the ufunc can\n| deliver. The data-types are given using the character codes.\n|\n| See Also\n| --------\n| numpy.ufunc.ntypes\n|\n| Examples\n| --------\n| >>> np.add.types\n| ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',\n| 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',\n| 'GG->G', 'OO->O']\n|\n| >>> np.multiply.types\n| ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',\n| 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',\n| 'GG->G', 'OO->O']\n|\n| >>> np.power.types\n| ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',\n| 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G',\n| 'OO->O']\n|\n| >>> np.exp.types\n| ['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O']\n|\n| >>> np.remainder.types\n| ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',\n| 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O']\n\nuint = class uint64(unsignedinteger)\n| Unsigned integer type, compatible with C ``unsigned long``.\n|\n| :Character code: ``'L'``\n| :Canonical name: `numpy.uint`\n| :Alias on this platform (Linux x8664): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18446744073709551615``).\n| :Alias on this platform (Linux x8664): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptrt``.\n|\n| Method resolution order:\n| uint64\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nuint0 = class uint64(unsignedinteger)\n| Unsigned integer type, compatible with C ``unsigned long``.\n|\n| :Character code: ``'L'``\n| :Canonical name: `numpy.uint`\n| :Alias on this platform (Linux x8664): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18446744073709551615``).\n| :Alias on this platform (Linux x8664): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptrt``.\n|\n| Method resolution order:\n| uint64\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class uint16", "content": "| Unsigned integer type, compatible with C ``unsigned short``.\n|\n| :Character code: ``'H'``\n| :Canonical name: `numpy.ushort`\n| :Alias on this platform (Linux x8664): `numpy.uint16`: 16-bit unsigned integer (``0`` to ``65535``).\n|\n| Method resolution order:\n| uint16\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class uint32", "content": "| Unsigned integer type, compatible with C ``unsigned int``.\n|\n| :Character code: ``'I'``\n| :Canonical name: `numpy.uintc`\n| :Alias on this platform (Linux x8664): `numpy.uint32`: 32-bit unsigned integer (``0`` to ``4294967295``).\n|\n| Method resolution order:\n| uint32\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class uint64", "content": "| Unsigned integer type, compatible with C ``unsigned long``.\n|\n| :Character code: ``'L'``\n| :Canonical name: `numpy.uint`\n| :Alias on this platform (Linux x8664): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18446744073709551615``).\n| :Alias on this platform (Linux x8664): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptrt``.\n|\n| Method resolution order:\n| uint64\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class uint8", "content": "| Unsigned integer type, compatible with C ``unsigned char``.\n|\n| :Character code: ``'B'``\n| :Canonical name: `numpy.ubyte`\n| :Alias on this platform (Linux x8664): `numpy.uint8`: 8-bit unsigned integer (``0`` to ``255``).\n|\n| Method resolution order:\n| uint8\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nuintc = class uint32(unsignedinteger)\n| Unsigned integer type, compatible with C ``unsigned int``.\n|\n| :Character code: ``'I'``\n| :Canonical name: `numpy.uintc`\n| :Alias on this platform (Linux x8664): `numpy.uint32`: 32-bit unsigned integer (``0`` to ``4294967295``).\n|\n| Method resolution order:\n| uint32\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nuintp = class uint64(unsignedinteger)\n| Unsigned integer type, compatible with C ``unsigned long``.\n|\n| :Character code: ``'L'``\n| :Canonical name: `numpy.uint`\n| :Alias on this platform (Linux x8664): `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18446744073709551615``).\n| :Alias on this platform (Linux x8664): `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptrt``.\n|\n| Method resolution order:\n| uint64\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class ulonglong", "content": "| Signed integer type, compatible with C ``unsigned long long``.\n|\n| :Character code: ``'Q'``\n|\n| Method resolution order:\n| ulonglong\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nunicode = class str(builtins.str, character)\n| A unicode string.\n|\n| When used in arrays, this type strips trailing null codepoints.\n|\n| Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its\n| contents as UCS4:\n|\n| >>> m = memoryview(np.str(\"abc\"))\n| >>> m.format\n| '3w'\n| >>> m.tobytes()\n| b'a\\x00\\x00\\x00b\\x00\\x00\\x00c\\x00\\x00\\x00'\n|\n| :Character code: ``'U'``\n| :Alias: `numpy.unicode`\n|\n| Method resolution order:\n| str\n| builtins.str\n| character\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lt(self, value, /)\n| Return self int\n|\n| Return the number of non-overlapping occurrences of substring sub in\n| string S[start:end]. Optional arguments start and end are\n| interpreted as in slice notation.\n|\n| encode(self, /, encoding='utf-8', errors='strict')\n| Encode the string using the codec registered for encoding.\n|\n| encoding\n| The encoding in which to encode the string.\n| errors\n| The error handling scheme to use for encoding errors.\n| The default is 'strict' meaning that encoding errors raise a\n| UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n| 'xmlcharrefreplace' as well as any other name registered with\n| codecs.registererror that can handle UnicodeEncodeErrors.\n|\n| endswith(...)\n| S.endswith(suffix[, start[, end]]) -> bool\n|\n| Return True if S ends with the specified suffix, False otherwise.\n| With optional start, test S beginning at that position.\n| With optional end, stop comparing S at that position.\n| suffix can also be a tuple of strings to try.\n|\n| expandtabs(self, /, tabsize=8)\n| Return a copy where all tab characters are expanded using spaces.\n|\n| If tabsize is not given, a tab size of 8 characters is assumed.\n|\n| find(...)\n| S.find(sub[, start[, end]]) -> int\n|\n| Return the lowest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| format(...)\n| S.format(*args, kwargs) -> str\n|\n| Return a formatted version of S, using substitutions from args and kwargs.\n| The substitutions are identified by braces ('{' and '}').\n|\n| formatmap(...)\n| S.formatmap(mapping) -> str\n|\n| Return a formatted version of S, using substitutions from mapping.\n| The substitutions are identified by braces ('{' and '}').\n|\n| index(...)\n| S.index(sub[, start[, end]]) -> int\n|\n| Return the lowest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the substring is not found.\n|\n| isalnum(self, /)\n| Return True if the string is an alpha-numeric string, False otherwise.\n|\n| A string is alpha-numeric if all characters in the string are alpha-numeric and\n| there is at least one character in the string.\n|\n| isalpha(self, /)\n| Return True if the string is an alphabetic string, False otherwise.\n|\n| A string is alphabetic if all characters in the string are alphabetic and there\n| is at least one character in the string.\n|\n| isascii(self, /)\n| Return True if all characters in the string are ASCII, False otherwise.\n|\n| ASCII characters have code points in the range U+0000-U+007F.\n| Empty string is ASCII too.\n|\n| isdecimal(self, /)\n| Return True if the string is a decimal string, False otherwise.\n|\n| A string is a decimal string if all characters in the string are decimal and\n| there is at least one character in the string.\n|\n| isdigit(self, /)\n| Return True if the string is a digit string, False otherwise.\n|\n| A string is a digit string if all characters in the string are digits and there\n| is at least one character in the string.\n|\n| isidentifier(self, /)\n| Return True if the string is a valid Python identifier, False otherwise.\n|\n| Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n| such as \"def\" or \"class\".\n|\n| islower(self, /)\n| Return True if the string is a lowercase string, False otherwise.\n|\n| A string is lowercase if all cased characters in the string are lowercase and\n| there is at least one cased character in the string.\n|\n| isnumeric(self, /)\n| Return True if the string is a numeric string, False otherwise.\n|\n| A string is numeric if all characters in the string are numeric and there is at\n| least one character in the string.\n|\n| isprintable(self, /)\n| Return True if the string is printable, False otherwise.\n|\n| A string is printable if all of its characters are considered printable in\n| repr() or if it is empty.\n|\n| isspace(self, /)\n| Return True if the string is a whitespace string, False otherwise.\n|\n| A string is whitespace if all characters in the string are whitespace and there\n| is at least one character in the string.\n|\n| istitle(self, /)\n| Return True if the string is a title-cased string, False otherwise.\n|\n| In a title-cased string, upper- and title-case characters may only\n| follow uncased characters and lowercase characters only cased ones.\n|\n| isupper(self, /)\n| Return True if the string is an uppercase string, False otherwise.\n|\n| A string is uppercase if all cased characters in the string are uppercase and\n| there is at least one cased character in the string.\n|\n| join(self, iterable, /)\n| Concatenate any number of strings.\n|\n| The string whose method is called is inserted in between each given string.\n| The result is returned as a new string.\n|\n| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n|\n| ljust(self, width, fillchar=' ', /)\n| Return a left-justified string of length width.\n|\n| Padding is done using the specified fill character (default is a space).\n|\n| lower(self, /)\n| Return a copy of the string converted to lowercase.\n|\n| lstrip(self, chars=None, /)\n| Return a copy of the string with leading whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| partition(self, sep, /)\n| Partition the string into three parts using the given separator.\n|\n| This will search for the separator in the string. If the separator is found,\n| returns a 3-tuple containing the part before the separator, the separator\n| itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing the original string\n| and two empty strings.\n|\n| removeprefix(self, prefix, /)\n| Return a str with the given prefix string removed if present.\n|\n| If the string starts with the prefix string, return string[len(prefix):].\n| Otherwise, return a copy of the original string.\n|\n| removesuffix(self, suffix, /)\n| Return a str with the given suffix string removed if present.\n|\n| If the string ends with the suffix string and that suffix is not empty,\n| return string[:-len(suffix)]. Otherwise, return a copy of the original\n| string.\n|\n| replace(self, old, new, count=-1, /)\n| Return a copy with all occurrences of substring old replaced by new.\n|\n| count\n| Maximum number of occurrences to replace.\n| -1 (the default value) means replace all occurrences.\n|\n| If the optional argument count is given, only the first count occurrences are\n| replaced.\n|\n| rfind(...)\n| S.rfind(sub[, start[, end]]) -> int\n|\n| Return the highest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Return -1 on failure.\n|\n| rindex(...)\n| S.rindex(sub[, start[, end]]) -> int\n|\n| Return the highest index in S where substring sub is found,\n| such that sub is contained within S[start:end]. Optional\n| arguments start and end are interpreted as in slice notation.\n|\n| Raises ValueError when the substring is not found.\n|\n| rjust(self, width, fillchar=' ', /)\n| Return a right-justified string of length width.\n|\n| Padding is done using the specified fill character (default is a space).\n|\n| rpartition(self, sep, /)\n| Partition the string into three parts using the given separator.\n|\n| This will search for the separator in the string, starting at the end. If\n| the separator is found, returns a 3-tuple containing the part before the\n| separator, the separator itself, and the part after it.\n|\n| If the separator is not found, returns a 3-tuple containing two empty strings\n| and the original string.\n|\n| rsplit(self, /, sep=None, maxsplit=-1)\n| Return a list of the substrings in the string, using sep as the separator string.\n|\n| sep\n| The separator used to split the string.\n|\n| When set to None (the default value), will split on any whitespace\n| character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n| empty strings from the result.\n| maxsplit\n| Maximum number of splits (starting from the left).\n| -1 (the default value) means no limit.\n|\n| Splitting starts at the end of the string and works to the front.\n|\n| rstrip(self, chars=None, /)\n| Return a copy of the string with trailing whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| split(self, /, sep=None, maxsplit=-1)\n| Return a list of the substrings in the string, using sep as the separator string.\n|\n| sep\n| The separator used to split the string.\n|\n| When set to None (the default value), will split on any whitespace\n| character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n| empty strings from the result.\n| maxsplit\n| Maximum number of splits (starting from the left).\n| -1 (the default value) means no limit.\n|\n| Note, str.split() is mainly useful for data that has been intentionally\n| delimited. With natural text that includes punctuation, consider using\n| the regular expression module.\n|\n| splitlines(self, /, keepends=False)\n| Return a list of the lines in the string, breaking at line boundaries.\n|\n| Line breaks are not included in the resulting list unless keepends is given and\n| true.\n|\n| startswith(...)\n| S.startswith(prefix[, start[, end]]) -> bool\n|\n| Return True if S starts with the specified prefix, False otherwise.\n| With optional start, test S beginning at that position.\n| With optional end, stop comparing S at that position.\n| prefix can also be a tuple of strings to try.\n|\n| strip(self, chars=None, /)\n| Return a copy of the string with leading and trailing whitespace removed.\n|\n| If chars is given and not None, remove characters in chars instead.\n|\n| swapcase(self, /)\n| Convert uppercase characters to lowercase and lowercase characters to uppercase.\n|\n| title(self, /)\n| Return a version of the string where each word is titlecased.\n|\n| More specifically, words start with uppercased characters and all remaining\n| cased characters have lower case.\n|\n| translate(self, table, /)\n| Replace each character in the string using the given translation table.\n|\n| table\n| Translation table, which must be a mapping of Unicode ordinals to\n| Unicode ordinals, strings, or None.\n|\n| The table must implement lookup/indexing via getitem, for instance a\n| dictionary or list. If this operation raises LookupError, the character is\n| left untouched. Characters mapped to None are deleted.\n|\n| upper(self, /)\n| Return a copy of the string converted to uppercase.\n|\n| zfill(self, width, /)\n| Pad a numeric string with zeros on the left, to fill a field of the given width.\n|\n| The string is never truncated.\n|\n| ----------------------------------------------------------------------\n| Static methods inherited from builtins.str:\n|\n| maketrans(...)\n| Return a translation table usable for str.translate().\n|\n| If there is only one argument, it must be a dictionary mapping Unicode\n| ordinals (integers) or characters to Unicode ordinals, strings or None.\n| Character keys will be then converted to ordinals.\n| If there are two arguments, they must be strings of equal length, and\n| in the resulting dictionary, each character in x will be mapped to the\n| character at the same position in y. If there is a third argument, it\n| must be a string, whose characters will be mapped to None in the result.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class unsignedinteger", "content": "| Abstract base class of all unsigned integer scalar types.\n|\n| Method resolution order:\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| bool(self, /)\n| True if self else False\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n|\n| ----------------------------------------------------------------------\n| Data and other attributes inherited from generic:\n|\n| hash = None\n\nushort = class uint16(unsignedinteger)\n| Unsigned integer type, compatible with C ``unsigned short``.\n|\n| :Character code: ``'H'``\n| :Canonical name: `numpy.ushort`\n| :Alias on this platform (Linux x8664): `numpy.uint16`: 16-bit unsigned integer (``0`` to ``65535``).\n|\n| Method resolution order:\n| uint16\n| unsignedinteger\n| integer\n| number\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| abs(self, /)\n| abs(self)\n|\n| add(self, value, /)\n| Return self+value.\n|\n| and(self, value, /)\n| Return self&value.\n|\n| bool(self, /)\n| True if self else False\n|\n| divmod(self, value, /)\n| Return divmod(self, value).\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| float(self, /)\n| float(self)\n|\n| floordiv(self, value, /)\n| Return self//value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| index(self, /)\n| Return self converted to an integer, if self is suitable for use as an index into a list.\n|\n| int(self, /)\n| int(self)\n|\n| invert(self, /)\n| ~self\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| lshift(self, value, /)\n| Return self<>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| str(self, /)\n| Return str(self).\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| ----------------------------------------------------------------------\n| Static methods defined here:\n|\n| new(*args, kwargs) from builtins.type\n| Create and return a new object. See help(type) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Methods inherited from integer:\n|\n| round(...)\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from integer:\n|\n| denominator\n| denominator of value (1)\n|\n| numerator\n| numerator of value (the value itself)\n|\n| ----------------------------------------------------------------------\n| Methods inherited from generic:\n|\n| array(...)\n| sc.array(dtype) return 0-dim array from scalar with specified dtype\n|\n| arraywrap(...)\n| sc.arraywrap(obj) return scalar from array\n|\n| copy(...)\n|\n| deepcopy(...)\n|\n| format(...)\n| NumPy array scalar formatter\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| reduce(...)\n| Helper for pickle.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| getfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.getfield`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setfield(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setfield`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| base\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.base`.\n|\n| data\n| Pointer to start of data.\n|\n| dtype\n| Get array data-descriptor.\n|\n| flags\n| The integer value of flags.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" }, { "name": "class vectorize", "content": "| vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)\n|\n| vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,\n| signature=None)\n|\n| Generalized function class.\n|\n| Define a vectorized function which takes a nested sequence of objects or\n| numpy arrays as inputs and returns a single numpy array or a tuple of numpy\n| arrays. The vectorized function evaluates `pyfunc` over successive tuples\n| of the input arrays like the python map function, except it uses the\n| broadcasting rules of numpy.\n|\n| The data type of the output of `vectorized` is determined by calling\n| the function with the first element of the input. This can be avoided\n| by specifying the `otypes` argument.\n|\n| Parameters\n| ----------\n| pyfunc : callable\n| A python function or method.\n| otypes : str or list of dtypes, optional\n| The output data type. It must be specified as either a string of\n| typecode characters or a list of data type specifiers. There should\n| be one data type specifier for each output.\n| doc : str, optional\n| The docstring for the function. If None, the docstring will be the\n| ``pyfunc.doc``.\n| excluded : set, optional\n| Set of strings or integers representing the positional or keyword\n| arguments for which the function will not be vectorized. These will be\n| passed directly to `pyfunc` unmodified.\n|\n| .. versionadded:: 1.7.0\n|\n| cache : bool, optional\n| If `True`, then cache the first function call that determines the number\n| of outputs if `otypes` is not provided.\n|\n| .. versionadded:: 1.7.0\n|\n| signature : string, optional\n| Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for\n| vectorized matrix-vector multiplication. If provided, ``pyfunc`` will\n| be called with (and expected to return) arrays with shapes given by the\n| size of corresponding core dimensions. By default, ``pyfunc`` is\n| assumed to take scalars as input and output.\n|\n| .. versionadded:: 1.12.0\n|\n| Returns\n| -------\n| vectorized : callable\n| Vectorized function.\n|\n| See Also\n| --------\n| frompyfunc : Takes an arbitrary Python function and returns a ufunc\n|\n| Notes\n| -----\n| The `vectorize` function is provided primarily for convenience, not for\n| performance. The implementation is essentially a for loop.\n|\n| If `otypes` is not specified, then a call to the function with the\n| first argument will be used to determine the number of outputs. The\n| results of this call will be cached if `cache` is `True` to prevent\n| calling the function twice. However, to implement the cache, the\n| original function must be wrapped which will slow down subsequent\n| calls, so only do this if your function is expensive.\n|\n| The new keyword argument interface and `excluded` argument support\n| further degrades performance.\n|\n| References\n| ----------\n| .. [1] :doc:`/reference/c-api/generalized-ufuncs`\n|\n| Examples\n| --------\n| >>> def myfunc(a, b):\n| ... \"Return a-b if a>b, otherwise return a+b\"\n| ... if a > b:\n| ... return a - b\n| ... else:\n| ... return a + b\n|\n| >>> vfunc = np.vectorize(myfunc)\n| >>> vfunc([1, 2, 3, 4], 2)\n| array([3, 4, 1, 2])\n|\n| The docstring is taken from the input function to `vectorize` unless it\n| is specified:\n|\n| >>> vfunc.doc\n| 'Return a-b if a>b, otherwise return a+b'\n| >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')\n| >>> vfunc.doc\n| 'Vectorized `myfunc`'\n|\n| The output type is determined by evaluating the first element of the input,\n| unless it is specified:\n|\n| >>> out = vfunc([1, 2, 3, 4], 2)\n| >>> type(out[0])\n| \n| >>> vfunc = np.vectorize(myfunc, otypes=[float])\n| >>> out = vfunc([1, 2, 3, 4], 2)\n| >>> type(out[0])\n| \n|\n| The `excluded` argument can be used to prevent vectorizing over certain\n| arguments. This can be useful for array-like arguments of a fixed length\n| such as the coefficients for a polynomial as in `polyval`:\n|\n| >>> def mypolyval(p, x):\n| ... p = list(p)\n| ... res = p.pop(0)\n| ... while p:\n| ... res = res*x + p.pop(0)\n| ... return res\n| >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])\n| >>> vpolyval(p=[1, 2, 3], x=[0, 1])\n| array([3, 6])\n|\n| Positional arguments may also be excluded by specifying their position:\n|\n| >>> vpolyval.excluded.add(0)\n| >>> vpolyval([1, 2, 3], x=[0, 1])\n| array([3, 6])\n|\n| The `signature` argument allows for vectorizing functions that act on\n| non-scalar arrays of fixed length. For example, you can use it for a\n| vectorized calculation of Pearson correlation coefficient and its p-value:\n|\n| >>> import scipy.stats\n| >>> pearsonr = np.vectorize(scipy.stats.pearsonr,\n| ... signature='(n),(n)->(),()')\n| >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])\n| (array([ 1., -1.]), array([ 0., 0.]))\n|\n| Or for a vectorized convolution:\n|\n| >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')\n| >>> convolve(np.eye(4), [1, 2, 1])\n| array([[1., 2., 1., 0., 0., 0.],\n| [0., 1., 2., 1., 0., 0.],\n| [0., 0., 1., 2., 1., 0.],\n| [0., 0., 0., 1., 2., 1.]])\n|\n| Methods defined here:\n|\n| call(self, *args, kwargs)\n| Return arrays with the results of `pyfunc` broadcast (vectorized) over\n| `args` and `kwargs` not in `excluded`.\n|\n| init(self, pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)\n| Initialize self. See help(type(self)) for accurate signature.\n|\n| ----------------------------------------------------------------------\n| Data descriptors defined here:\n|\n| dict\n| dictionary for instance variables (if defined)\n|\n| weakref\n| list of weak references to the object (if defined)\n" }, { "name": "class void", "content": "| Either an opaque sequence of bytes, or a structure.\n|\n| >>> np.void(b'abcd')\n| void(b'\\x61\\x62\\x63\\x64')\n|\n| Structured `void` scalars can only be constructed via extraction from :ref:`structuredarrays`:\n|\n| >>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])\n| >>> arr[()]\n| (1, 2) # looks like a tuple, but is `np.void`\n|\n| :Character code: ``'V'``\n|\n| Method resolution order:\n| void\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| data\n| Pointer to start of data.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n\nvoid0 = class void(flexible)\n| Either an opaque sequence of bytes, or a structure.\n|\n| >>> np.void(b'abcd')\n| void(b'\\x61\\x62\\x63\\x64')\n|\n| Structured `void` scalars can only be constructed via extraction from :ref:`structuredarrays`:\n|\n| >>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])\n| >>> arr[()]\n| (1, 2) # looks like a tuple, but is `np.void`\n|\n| :Character code: ``'V'``\n|\n| Method resolution order:\n| void\n| flexible\n| generic\n| builtins.object\n|\n| Methods defined here:\n|\n| delitem(self, key, /)\n| Delete self[key].\n|\n| eq(self, value, /)\n| Return self==value.\n|\n| ge(self, value, /)\n| Return self>=value.\n|\n| getitem(self, key, /)\n| Return self[key].\n|\n| gt(self, value, /)\n| Return self>value.\n|\n| hash(self, /)\n| Return hash(self).\n|\n| le(self, value, /)\n| Return self<=value.\n|\n| len(self, /)\n| Return len(self).\n|\n| lt(self, value, /)\n| Return self>self.\n|\n| rshift(self, value, /)\n| Return self>>value.\n|\n| rsub(self, value, /)\n| Return value-self.\n|\n| rtruediv(self, value, /)\n| Return value/self.\n|\n| rxor(self, value, /)\n| Return value^self.\n|\n| setstate(...)\n|\n| sizeof(...)\n| Size of object in memory, in bytes.\n|\n| sub(self, value, /)\n| Return self-value.\n|\n| truediv(self, value, /)\n| Return self/value.\n|\n| xor(self, value, /)\n| Return self^value.\n|\n| all(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.all`.\n|\n| any(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.any`.\n|\n| argmax(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmax`.\n|\n| argmin(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argmin`.\n|\n| argsort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.argsort`.\n|\n| astype(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.astype`.\n|\n| byteswap(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.byteswap`.\n|\n| choose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.choose`.\n|\n| clip(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.clip`.\n|\n| compress(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.compress`.\n|\n| conj(...)\n|\n| conjugate(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.conjugate`.\n|\n| copy(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.copy`.\n|\n| cumprod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumprod`.\n|\n| cumsum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.cumsum`.\n|\n| diagonal(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.diagonal`.\n|\n| dump(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dump`.\n|\n| dumps(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.dumps`.\n|\n| fill(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.fill`.\n|\n| flatten(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.flatten`.\n|\n| item(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.item`.\n|\n| itemset(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.itemset`.\n|\n| max(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.max`.\n|\n| mean(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.mean`.\n|\n| min(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.min`.\n|\n| newbyteorder(...)\n| newbyteorder(neworder='S', /)\n|\n| Return a new `dtype` with a different byte order.\n|\n| Changes are also made in all fields and sub-arrays of the data type.\n|\n| The `neworder` code can be any from the following:\n|\n| * 'S' - swap dtype from current to opposite endian\n| * {'<', 'little'} - little endian\n| * {'>', 'big'} - big endian\n| * '=' - native order\n| * {'|', 'I'} - ignore (no change to byte order)\n|\n| Parameters\n| ----------\n| neworder : str, optional\n| Byte order to force; a value from the byte order specifications\n| above. The default value ('S') results in swapping the current\n| byte order.\n|\n|\n| Returns\n| -------\n| newdtype : dtype\n| New `dtype` object with the given change to the byte order.\n|\n| nonzero(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.nonzero`.\n|\n| prod(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.prod`.\n|\n| ptp(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ptp`.\n|\n| put(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.put`.\n|\n| ravel(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.ravel`.\n|\n| repeat(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.repeat`.\n|\n| reshape(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.reshape`.\n|\n| resize(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.resize`.\n|\n| round(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.round`.\n|\n| searchsorted(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.searchsorted`.\n|\n| setflags(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.setflags`.\n|\n| sort(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sort`.\n|\n| squeeze(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.squeeze`.\n|\n| std(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.std`.\n|\n| sum(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.sum`.\n|\n| swapaxes(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.swapaxes`.\n|\n| take(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.take`.\n|\n| tobytes(...)\n|\n| tofile(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tofile`.\n|\n| tolist(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tolist`.\n|\n| tostring(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.tostring`.\n|\n| trace(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.trace`.\n|\n| transpose(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.transpose`.\n|\n| var(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.var`.\n|\n| view(...)\n| Scalar method identical to the corresponding array attribute.\n|\n| Please see `ndarray.view`.\n|\n| ----------------------------------------------------------------------\n| Data descriptors inherited from generic:\n|\n| T\n| Scalar attribute identical to the corresponding array attribute.\n|\n| Please see `ndarray.T`.\n|\n| arrayinterface\n| Array protocol: Python side\n|\n| arraypriority\n| Array priority.\n|\n| arraystruct\n| Array protocol: struct\n|\n| data\n| Pointer to start of data.\n|\n| flat\n| A 1-D view of the scalar.\n|\n| imag\n| The imaginary part of the scalar.\n|\n| itemsize\n| The length of one element in bytes.\n|\n| nbytes\n| The length of the scalar in bytes.\n|\n| ndim\n| The number of array dimensions.\n|\n| real\n| The real part of the scalar.\n|\n| shape\n| Tuple of array dimensions.\n|\n| size\n| The number of elements in the gentype.\n|\n| strides\n| Tuple of bytes steps in each dimension.\n" } ] }, "FUNCTIONS": { "content": "dir()\n\ngetattr(attr)\n# module level getattr is only supported in 3.7 onwards\n# https://www.python.org/dev/peps/pep-0562/\n\naddnewdocufunc(...)\naddufuncdocstring(ufunc, newdocstring)\n\nReplace the docstring for a ufunc with newdocstring.\nThis method will only work if the current docstring for\nthe ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)\n\nParameters\n----------\nufunc : numpy.ufunc\nA ufunc whose current doc is NULL.\nnewdocstring : string\nThe new docstring for the ufunc.\n\nNotes\n-----\nThis method allocates memory for newdocstring on\nthe heap. Technically this creates a mempory leak, since this\nmemory will not be reclaimed until the end of the program\neven if the ufunc itself is removed. However this will only\nbe a problem if the user is repeatedly creating ufuncs with\nno documentation, adding documentation via addnewdocufunc,\nand then throwing away the ufunc.\n", "subsections": [ { "name": "add_docstring", "content": "adddocstring(obj, docstring)\n\nAdd a docstring to a built-in obj if possible.\nIf the obj already has a docstring raise a RuntimeError\nIf this routine does not know how to add a docstring to the object\nraise a TypeError\n" }, { "name": "add_newdoc", "content": "Add documentation to an existing object, typically one defined in C\n\nThe purpose is to allow easier editing of the docstrings without requiring\na re-compile. This exists primarily for internal use within numpy itself.\n\nParameters\n----------\nplace : str\nThe absolute name of the module to import from\nobj : str\nThe name of the object to add documentation to, typically a class or\nfunction name\ndoc : {str, Tuple[str, str], List[Tuple[str, str]]}\nIf a string, the documentation to apply to `obj`\n\nIf a tuple, then the first element is interpreted as an attribute of\n`obj` and the second as the docstring to apply - ``(method, docstring)``\n\nIf a list, then each element of the list should be a tuple of length\ntwo - ``[(method1, docstring1), (method2, docstring2), ...]``\nwarnonpython : bool\nIf True, the default, emit `UserWarning` if this is used to attach\ndocumentation to a pure-python object.\n\nNotes\n-----\nThis routine never raises an error if the docstring can't be written, but\nwill raise an error if the object being documented does not exist.\n\nThis routine cannot modify read-only docstrings, as appear\nin new-style classes or built-in functions. Because this\nroutine never raises an error the caller must check manually\nthat the docstrings were changed.\n\nSince this function grabs the ``char *`` from a c-level str object and puts\nit into the ``tpdoc`` slot of the type of `obj`, it violates a number of\nC-API best-practices, by:\n\n- modifying a `PyTypeObject` after calling `PyTypeReady`\n- calling `PyINCREF` on the str and losing the reference, so the str\nwill never be released\n\nIf possible it should be avoided.\n\naddnewdocufunc = addnewdocufunc(...)\naddufuncdocstring(ufunc, newdocstring)\n\nReplace the docstring for a ufunc with newdocstring.\nThis method will only work if the current docstring for\nthe ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)\n\nParameters\n----------\nufunc : numpy.ufunc\nA ufunc whose current doc is NULL.\nnewdocstring : string\nThe new docstring for the ufunc.\n\nNotes\n-----\nThis method allocates memory for newdocstring on\nthe heap. Technically this creates a mempory leak, since this\nmemory will not be reclaimed until the end of the program\neven if the ufunc itself is removed. However this will only\nbe a problem if the user is repeatedly creating ufuncs with\nno documentation, adding documentation via addnewdocufunc,\nand then throwing away the ufunc.\n" }, { "name": "alen", "content": "Return the length of the first dimension of the input array.\n\n.. deprecated:: 1.18\n`numpy.alen` is deprecated, use `len` instead.\n\nParameters\n----------\na : arraylike\nInput array.\n\nReturns\n-------\nalen : int\nLength of the first dimension of `a`.\n\nSee Also\n--------\nshape, size\n\nExamples\n--------\n>>> a = np.zeros((7,4,5))\n>>> a.shape[0]\n7\n>>> np.alen(a)\n7\n" }, { "name": "all", "content": "Test whether all array elements along a given axis evaluate to True.\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array.\naxis : None or int or tuple of ints, optional\nAxis or axes along which a logical AND reduction is performed.\nThe default (``axis=None``) is to perform a logical AND over all\nthe dimensions of the input array. `axis` may be negative, in\nwhich case it counts from the last to the first axis.\n\n.. versionadded:: 1.7.0\n\nIf this is a tuple of ints, a reduction is performed on multiple\naxes, instead of a single axis or all the axes as before.\nout : ndarray, optional\nAlternate output array in which to place the result.\nIt must have the same shape as the expected output and its\ntype is preserved (e.g., if ``dtype(out)`` is float, the result\nwill consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` for more\ndetails.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `all` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\nwhere : arraylike of bool, optional\nElements to include in checking for all `True` values.\nSee `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nall : ndarray, bool\nA new boolean or array is returned unless `out` is specified,\nin which case a reference to `out` is returned.\n\nSee Also\n--------\nndarray.all : equivalent method\n\nany : Test whether any element along a given axis evaluates to True.\n\nNotes\n-----\nNot a Number (NaN), positive infinity and negative infinity\nevaluate to `True` because these are not equal to zero.\n\nExamples\n--------\n>>> np.all([[True,False],[True,True]])\nFalse\n\n>>> np.all([[True,False],[True,True]], axis=0)\narray([ True, False])\n\n>>> np.all([-1, 4, 5])\nTrue\n\n>>> np.all([1.0, np.nan])\nTrue\n\n>>> np.all([[True, True], [False, True]], where=[[True], [False]])\nTrue\n\n>>> o=np.array(False)\n>>> z=np.all([-1, 4, 5], out=o)\n>>> id(z), id(o), z\n(28293632, 28293632, array(True)) # may vary\n" }, { "name": "allclose", "content": "Returns True if two arrays are element-wise equal within a tolerance.\n\nThe tolerance values are positive, typically very small numbers. The\nrelative difference (`rtol` * abs(`b`)) and the absolute difference\n`atol` are added together to compare against the absolute difference\nbetween `a` and `b`.\n\nNaNs are treated as equal if they are in the same place and if\n``equalnan=True``. Infs are treated as equal if they are in the same\nplace and of the same sign in both arrays.\n\nParameters\n----------\na, b : arraylike\nInput arrays to compare.\nrtol : float\nThe relative tolerance parameter (see Notes).\natol : float\nThe absolute tolerance parameter (see Notes).\nequalnan : bool\nWhether to compare NaN's as equal. If True, NaN's in `a` will be\nconsidered equal to NaN's in `b` in the output array.\n\n.. versionadded:: 1.10.0\n\nReturns\n-------\nallclose : bool\nReturns True if the two arrays are equal within the given\ntolerance; False otherwise.\n\nSee Also\n--------\nisclose, all, any, equal\n\nNotes\n-----\nIf the following equation is element-wise True, then allclose returns\nTrue.\n\nabsolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))\n\nThe above equation is not symmetric in `a` and `b`, so that\n``allclose(a, b)`` might be different from ``allclose(b, a)`` in\nsome rare cases.\n\nThe comparison of `a` and `b` uses standard broadcasting, which\nmeans that `a` and `b` need not have the same shape in order for\n``allclose(a, b)`` to evaluate to True. The same is true for\n`equal` but not `arrayequal`.\n\n`allclose` is not defined for non-numeric data types.\n\nExamples\n--------\n>>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])\nFalse\n>>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])\nTrue\n>>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])\nFalse\n>>> np.allclose([1.0, np.nan], [1.0, np.nan])\nFalse\n>>> np.allclose([1.0, np.nan], [1.0, np.nan], equalnan=True)\nTrue\n" }, { "name": "alltrue", "content": "Check if all elements of input array are true.\n\nSee Also\n--------\nnumpy.all : Equivalent function; see for details.\n" }, { "name": "amax", "content": "Return the maximum of an array or maximum along an axis.\n\nParameters\n----------\na : arraylike\nInput data.\naxis : None or int or tuple of ints, optional\nAxis or axes along which to operate. By default, flattened input is\nused.\n\n.. versionadded:: 1.7.0\n\nIf this is a tuple of ints, the maximum is selected over multiple axes,\ninstead of a single axis or all the axes as before.\nout : ndarray, optional\nAlternative output array in which to place the result. Must\nbe of the same shape and buffer length as the expected output.\nSee :ref:`ufuncs-output-type` for more details.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `amax` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\ninitial : scalar, optional\nThe minimum value of an output element. Must be present to allow\ncomputation on empty slice. See `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.15.0\n\nwhere : arraylike of bool, optional\nElements to compare for the maximum. See `~numpy.ufunc.reduce`\nfor details.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\namax : ndarray or scalar\nMaximum of `a`. If `axis` is None, the result is a scalar value.\nIf `axis` is given, the result is an array of dimension\n``a.ndim - 1``.\n\nSee Also\n--------\namin :\nThe minimum value of an array along a given axis, propagating any NaNs.\nnanmax :\nThe maximum value of an array along a given axis, ignoring any NaNs.\nmaximum :\nElement-wise maximum of two arrays, propagating any NaNs.\nfmax :\nElement-wise maximum of two arrays, ignoring any NaNs.\nargmax :\nReturn the indices of the maximum values.\n\nnanmin, minimum, fmin\n\nNotes\n-----\nNaN values are propagated, that is if at least one item is NaN, the\ncorresponding max value will be NaN as well. To ignore NaN values\n(MATLAB behavior), please use nanmax.\n\nDon't use `amax` for element-wise comparison of 2 arrays; when\n``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than\n``amax(a, axis=0)``.\n\nExamples\n--------\n>>> a = np.arange(4).reshape((2,2))\n>>> a\narray([[0, 1],\n[2, 3]])\n>>> np.amax(a) # Maximum of the flattened array\n3\n>>> np.amax(a, axis=0) # Maxima along the first axis\narray([2, 3])\n>>> np.amax(a, axis=1) # Maxima along the second axis\narray([1, 3])\n>>> np.amax(a, where=[False, True], initial=-1, axis=0)\narray([-1, 3])\n>>> b = np.arange(5, dtype=float)\n>>> b[2] = np.NaN\n>>> np.amax(b)\nnan\n>>> np.amax(b, where=~np.isnan(b), initial=-1)\n4.0\n>>> np.nanmax(b)\n4.0\n\nYou can use an initial value to compute the maximum of an empty slice, or\nto initialize it to a different value:\n\n>>> np.max([[-50], [10]], axis=-1, initial=0)\narray([ 0, 10])\n\nNotice that the initial value is used as one of the elements for which the\nmaximum is determined, unlike for the default argument Python's max\nfunction, which is only used for empty iterables.\n\n>>> np.max([5], initial=6)\n6\n>>> max([5], default=6)\n5\n" }, { "name": "amin", "content": "Return the minimum of an array or minimum along an axis.\n\nParameters\n----------\na : arraylike\nInput data.\naxis : None or int or tuple of ints, optional\nAxis or axes along which to operate. By default, flattened input is\nused.\n\n.. versionadded:: 1.7.0\n\nIf this is a tuple of ints, the minimum is selected over multiple axes,\ninstead of a single axis or all the axes as before.\nout : ndarray, optional\nAlternative output array in which to place the result. Must\nbe of the same shape and buffer length as the expected output.\nSee :ref:`ufuncs-output-type` for more details.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `amin` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\ninitial : scalar, optional\nThe maximum value of an output element. Must be present to allow\ncomputation on empty slice. See `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.15.0\n\nwhere : arraylike of bool, optional\nElements to compare for the minimum. See `~numpy.ufunc.reduce`\nfor details.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\namin : ndarray or scalar\nMinimum of `a`. If `axis` is None, the result is a scalar value.\nIf `axis` is given, the result is an array of dimension\n``a.ndim - 1``.\n\nSee Also\n--------\namax :\nThe maximum value of an array along a given axis, propagating any NaNs.\nnanmin :\nThe minimum value of an array along a given axis, ignoring any NaNs.\nminimum :\nElement-wise minimum of two arrays, propagating any NaNs.\nfmin :\nElement-wise minimum of two arrays, ignoring any NaNs.\nargmin :\nReturn the indices of the minimum values.\n\nnanmax, maximum, fmax\n\nNotes\n-----\nNaN values are propagated, that is if at least one item is NaN, the\ncorresponding min value will be NaN as well. To ignore NaN values\n(MATLAB behavior), please use nanmin.\n\nDon't use `amin` for element-wise comparison of 2 arrays; when\n``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than\n``amin(a, axis=0)``.\n\nExamples\n--------\n>>> a = np.arange(4).reshape((2,2))\n>>> a\narray([[0, 1],\n[2, 3]])\n>>> np.amin(a) # Minimum of the flattened array\n0\n>>> np.amin(a, axis=0) # Minima along the first axis\narray([0, 1])\n>>> np.amin(a, axis=1) # Minima along the second axis\narray([0, 2])\n>>> np.amin(a, where=[False, True], initial=10, axis=0)\narray([10, 1])\n\n>>> b = np.arange(5, dtype=float)\n>>> b[2] = np.NaN\n>>> np.amin(b)\nnan\n>>> np.amin(b, where=~np.isnan(b), initial=10)\n0.0\n>>> np.nanmin(b)\n0.0\n\n>>> np.min([[-50], [10]], axis=-1, initial=0)\narray([-50, 0])\n\nNotice that the initial value is used as one of the elements for which the\nminimum is determined, unlike for the default argument Python's max\nfunction, which is only used for empty iterables.\n\nNotice that this isn't the same as Python's ``default`` argument.\n\n>>> np.min([6], initial=5)\n5\n>>> min([6], default=5)\n6\n" }, { "name": "angle", "content": "Return the angle of the complex argument.\n\nParameters\n----------\nz : arraylike\nA complex number or sequence of complex numbers.\ndeg : bool, optional\nReturn angle in degrees if True, radians if False (default).\n\nReturns\n-------\nangle : ndarray or scalar\nThe counterclockwise angle from the positive real axis on the complex\nplane in the range ``(-pi, pi]``, with dtype as numpy.float64.\n\n.. versionchanged:: 1.16.0\nThis function works on subclasses of ndarray like `ma.array`.\n\nSee Also\n--------\narctan2\nabsolute\n\nNotes\n-----\nAlthough the angle of the complex number 0 is undefined, ``numpy.angle(0)``\nreturns the value 0.\n\nExamples\n--------\n>>> np.angle([1.0, 1.0j, 1+1j]) # in radians\narray([ 0. , 1.57079633, 0.78539816]) # may vary\n>>> np.angle(1+1j, deg=True) # in degrees\n45.0\n" }, { "name": "any", "content": "Test whether any array element along a given axis evaluates to True.\n\nReturns single boolean unless `axis` is not ``None``\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array.\naxis : None or int or tuple of ints, optional\nAxis or axes along which a logical OR reduction is performed.\nThe default (``axis=None``) is to perform a logical OR over all\nthe dimensions of the input array. `axis` may be negative, in\nwhich case it counts from the last to the first axis.\n\n.. versionadded:: 1.7.0\n\nIf this is a tuple of ints, a reduction is performed on multiple\naxes, instead of a single axis or all the axes as before.\nout : ndarray, optional\nAlternate output array in which to place the result. It must have\nthe same shape as the expected output and its type is preserved\n(e.g., if it is of type float, then it will remain so, returning\n1.0 for True and 0.0 for False, regardless of the type of `a`).\nSee :ref:`ufuncs-output-type` for more details.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `any` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\nwhere : arraylike of bool, optional\nElements to include in checking for any `True` values.\nSee `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nany : bool or ndarray\nA new boolean or `ndarray` is returned unless `out` is specified,\nin which case a reference to `out` is returned.\n\nSee Also\n--------\nndarray.any : equivalent method\n\nall : Test whether all elements along a given axis evaluate to True.\n\nNotes\n-----\nNot a Number (NaN), positive infinity and negative infinity evaluate\nto `True` because these are not equal to zero.\n\nExamples\n--------\n>>> np.any([[True, False], [True, True]])\nTrue\n\n>>> np.any([[True, False], [False, False]], axis=0)\narray([ True, False])\n\n>>> np.any([-1, 0, 5])\nTrue\n\n>>> np.any(np.nan)\nTrue\n\n>>> np.any([[True, False], [False, False]], where=[[False], [True]])\nFalse\n\n>>> o=np.array(False)\n>>> z=np.any([-1, 4, 5], out=o)\n>>> z, o\n(array(True), array(True))\n>>> # Check now that z is a reference to o\n>>> z is o\nTrue\n>>> id(z), id(o) # identity of z and o # doctest: +SKIP\n(191614240, 191614240)\n" }, { "name": "append", "content": "Append values to the end of an array.\n\nParameters\n----------\narr : arraylike\nValues are appended to a copy of this array.\nvalues : arraylike\nThese values are appended to a copy of `arr`. It must be of the\ncorrect shape (the same shape as `arr`, excluding `axis`). If\n`axis` is not specified, `values` can be any shape and will be\nflattened before use.\naxis : int, optional\nThe axis along which `values` are appended. If `axis` is not\ngiven, both `arr` and `values` are flattened before use.\n\nReturns\n-------\nappend : ndarray\nA copy of `arr` with `values` appended to `axis`. Note that\n`append` does not occur in-place: a new array is allocated and\nfilled. If `axis` is None, `out` is a flattened array.\n\nSee Also\n--------\ninsert : Insert elements into an array.\ndelete : Delete elements from an array.\n\nExamples\n--------\n>>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])\narray([1, 2, 3, ..., 7, 8, 9])\n\nWhen `axis` is specified, `values` must have the correct shape.\n\n>>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)\narray([[1, 2, 3],\n[4, 5, 6],\n[7, 8, 9]])\n>>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)\nTraceback (most recent call last):\n...\nValueError: all the input arrays must have same number of dimensions, but\nthe array at index 0 has 2 dimension(s) and the array at index 1 has 1\ndimension(s)\n" }, { "name": "apply_along_axis", "content": "Apply a function to 1-D slices along the given axis.\n\nExecute `func1d(a, *args, kwargs)` where `func1d` operates on 1-D arrays\nand `a` is a 1-D slice of `arr` along `axis`.\n\nThis is equivalent to (but faster than) the following use of `ndindex` and\n`s`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::\n\nNi, Nk = a.shape[:axis], a.shape[axis+1:]\nfor ii in ndindex(Ni):\nfor kk in ndindex(Nk):\nf = func1d(arr[ii + s[:,] + kk])\nNj = f.shape\nfor jj in ndindex(Nj):\nout[ii + jj + kk] = f[jj]\n\nEquivalently, eliminating the inner loop, this can be expressed as::\n\nNi, Nk = a.shape[:axis], a.shape[axis+1:]\nfor ii in ndindex(Ni):\nfor kk in ndindex(Nk):\nout[ii + s[...,] + kk] = func1d(arr[ii + s[:,] + kk])\n\nParameters\n----------\nfunc1d : function (M,) -> (Nj...)\nThis function should accept 1-D arrays. It is applied to 1-D\nslices of `arr` along the specified axis.\naxis : integer\nAxis along which `arr` is sliced.\narr : ndarray (Ni..., M, Nk...)\nInput array.\nargs : any\nAdditional arguments to `func1d`.\nkwargs : any\nAdditional named arguments to `func1d`.\n\n.. versionadded:: 1.9.0\n\n\nReturns\n-------\nout : ndarray (Ni..., Nj..., Nk...)\nThe output array. The shape of `out` is identical to the shape of\n`arr`, except along the `axis` dimension. This axis is removed, and\nreplaced with new dimensions equal to the shape of the return value\nof `func1d`. So if `func1d` returns a scalar `out` will have one\nfewer dimensions than `arr`.\n\nSee Also\n--------\napplyoveraxes : Apply a function repeatedly over multiple axes.\n\nExamples\n--------\n>>> def myfunc(a):\n... \"\"\"Average first and last element of a 1-D array\"\"\"\n... return (a[0] + a[-1]) * 0.5\n>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n>>> np.applyalongaxis(myfunc, 0, b)\narray([4., 5., 6.])\n>>> np.applyalongaxis(myfunc, 1, b)\narray([2., 5., 8.])\n\nFor a function that returns a 1D array, the number of dimensions in\n`outarr` is the same as `arr`.\n\n>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])\n>>> np.applyalongaxis(sorted, 1, b)\narray([[1, 7, 8],\n[3, 4, 9],\n[2, 5, 6]])\n\nFor a function that returns a higher dimensional array, those dimensions\nare inserted in place of the `axis` dimension.\n\n>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n>>> np.applyalongaxis(np.diag, -1, b)\narray([[[1, 0, 0],\n[0, 2, 0],\n[0, 0, 3]],\n[[4, 0, 0],\n[0, 5, 0],\n[0, 0, 6]],\n[[7, 0, 0],\n[0, 8, 0],\n[0, 0, 9]]])\n" }, { "name": "apply_over_axes", "content": "Apply a function repeatedly over multiple axes.\n\n`func` is called as `res = func(a, axis)`, where `axis` is the first\nelement of `axes`. The result `res` of the function call must have\neither the same dimensions as `a` or one less dimension. If `res`\nhas one less dimension than `a`, a dimension is inserted before\n`axis`. The call to `func` is then repeated for each axis in `axes`,\nwith `res` as the first argument.\n\nParameters\n----------\nfunc : function\nThis function must take two arguments, `func(a, axis)`.\na : arraylike\nInput array.\naxes : arraylike\nAxes over which `func` is applied; the elements must be integers.\n\nReturns\n-------\napplyoveraxis : ndarray\nThe output array. The number of dimensions is the same as `a`,\nbut the shape can be different. This depends on whether `func`\nchanges the shape of its output with respect to its input.\n\nSee Also\n--------\napplyalongaxis :\nApply a function to 1-D slices of an array along the given axis.\n\nNotes\n-----\nThis function is equivalent to tuple axis arguments to reorderable ufuncs\nwith keepdims=True. Tuple axis arguments to ufuncs have been available since\nversion 1.7.0.\n\nExamples\n--------\n>>> a = np.arange(24).reshape(2,3,4)\n>>> a\narray([[[ 0, 1, 2, 3],\n[ 4, 5, 6, 7],\n[ 8, 9, 10, 11]],\n[[12, 13, 14, 15],\n[16, 17, 18, 19],\n[20, 21, 22, 23]]])\n\nSum over axes 0 and 2. The result has same number of dimensions\nas the original array:\n\n>>> np.applyoveraxes(np.sum, a, [0,2])\narray([[[ 60],\n[ 92],\n[124]]])\n\nTuple axis arguments to ufuncs are equivalent:\n\n>>> np.sum(a, axis=(0,2), keepdims=True)\narray([[[ 60],\n[ 92],\n[124]]])\n" }, { "name": "arange", "content": "arange([start,] stop[, step,], dtype=None, *, like=None)\n\nReturn evenly spaced values within a given interval.\n\nValues are generated within the half-open interval ``[start, stop)``\n(in other words, the interval including `start` but excluding `stop`).\nFor integer arguments the function is equivalent to the Python built-in\n`range` function, but returns an ndarray rather than a list.\n\nWhen using a non-integer step, such as 0.1, the results will often not\nbe consistent. It is better to use `numpy.linspace` for these cases.\n\nParameters\n----------\nstart : integer or real, optional\nStart of interval. The interval includes this value. The default\nstart value is 0.\nstop : integer or real\nEnd of interval. The interval does not include this value, except\nin some cases where `step` is not an integer and floating point\nround-off affects the length of `out`.\nstep : integer or real, optional\nSpacing between values. For any output `out`, this is the distance\nbetween two adjacent values, ``out[i+1] - out[i]``. The default\nstep size is 1. If `step` is specified as a position argument,\n`start` must also be given.\ndtype : dtype\nThe type of the output array. If `dtype` is not given, infer the data\ntype from the other input arguments.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\narange : ndarray\nArray of evenly spaced values.\n\nFor floating point arguments, the length of the result is\n``ceil((stop - start)/step)``. Because of floating point overflow,\nthis rule may result in the last element of `out` being greater\nthan `stop`.\n\nSee Also\n--------\nnumpy.linspace : Evenly spaced numbers with careful handling of endpoints.\nnumpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.\nnumpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.\n\nExamples\n--------\n>>> np.arange(3)\narray([0, 1, 2])\n>>> np.arange(3.0)\narray([ 0., 1., 2.])\n>>> np.arange(3,7)\narray([3, 4, 5, 6])\n>>> np.arange(3,7,2)\narray([3, 5])\n" }, { "name": "argmax", "content": "Returns the indices of the maximum values along an axis.\n\nParameters\n----------\na : arraylike\nInput array.\naxis : int, optional\nBy default, the index is into the flattened array, otherwise\nalong the specified axis.\nout : array, optional\nIf provided, the result will be inserted into this array. It should\nbe of the appropriate shape and dtype.\n\nReturns\n-------\nindexarray : ndarray of ints\nArray of indices into the array. It has the same shape as `a.shape`\nwith the dimension along `axis` removed.\n\nSee Also\n--------\nndarray.argmax, argmin\namax : The maximum value along a given axis.\nunravelindex : Convert a flat index into an index tuple.\ntakealongaxis : Apply ``np.expanddims(indexarray, axis)``\nfrom argmax to an array as if by calling max.\n\nNotes\n-----\nIn case of multiple occurrences of the maximum values, the indices\ncorresponding to the first occurrence are returned.\n\nExamples\n--------\n>>> a = np.arange(6).reshape(2,3) + 10\n>>> a\narray([[10, 11, 12],\n[13, 14, 15]])\n>>> np.argmax(a)\n5\n>>> np.argmax(a, axis=0)\narray([1, 1, 1])\n>>> np.argmax(a, axis=1)\narray([2, 2])\n\nIndexes of the maximal elements of a N-dimensional array:\n\n>>> ind = np.unravelindex(np.argmax(a, axis=None), a.shape)\n>>> ind\n(1, 2)\n>>> a[ind]\n15\n\n>>> b = np.arange(6)\n>>> b[1] = 5\n>>> b\narray([0, 5, 2, 3, 4, 5])\n>>> np.argmax(b) # Only the first occurrence is returned.\n1\n\n>>> x = np.array([[4,2,3], [1,0,3]])\n>>> indexarray = np.argmax(x, axis=-1)\n>>> # Same as np.max(x, axis=-1, keepdims=True)\n>>> np.takealongaxis(x, np.expanddims(indexarray, axis=-1), axis=-1)\narray([[4],\n[3]])\n>>> # Same as np.max(x, axis=-1)\n>>> np.takealongaxis(x, np.expanddims(indexarray, axis=-1), axis=-1).squeeze(axis=-1)\narray([4, 3])\n" }, { "name": "argmin", "content": "Returns the indices of the minimum values along an axis.\n\nParameters\n----------\na : arraylike\nInput array.\naxis : int, optional\nBy default, the index is into the flattened array, otherwise\nalong the specified axis.\nout : array, optional\nIf provided, the result will be inserted into this array. It should\nbe of the appropriate shape and dtype.\n\nReturns\n-------\nindexarray : ndarray of ints\nArray of indices into the array. It has the same shape as `a.shape`\nwith the dimension along `axis` removed.\n\nSee Also\n--------\nndarray.argmin, argmax\namin : The minimum value along a given axis.\nunravelindex : Convert a flat index into an index tuple.\ntakealongaxis : Apply ``np.expanddims(indexarray, axis)``\nfrom argmin to an array as if by calling min.\n\nNotes\n-----\nIn case of multiple occurrences of the minimum values, the indices\ncorresponding to the first occurrence are returned.\n\nExamples\n--------\n>>> a = np.arange(6).reshape(2,3) + 10\n>>> a\narray([[10, 11, 12],\n[13, 14, 15]])\n>>> np.argmin(a)\n0\n>>> np.argmin(a, axis=0)\narray([0, 0, 0])\n>>> np.argmin(a, axis=1)\narray([0, 0])\n\nIndices of the minimum elements of a N-dimensional array:\n\n>>> ind = np.unravelindex(np.argmin(a, axis=None), a.shape)\n>>> ind\n(0, 0)\n>>> a[ind]\n10\n\n>>> b = np.arange(6) + 10\n>>> b[4] = 10\n>>> b\narray([10, 11, 12, 13, 10, 15])\n>>> np.argmin(b) # Only the first occurrence is returned.\n0\n\n>>> x = np.array([[4,2,3], [1,0,3]])\n>>> indexarray = np.argmin(x, axis=-1)\n>>> # Same as np.min(x, axis=-1, keepdims=True)\n>>> np.takealongaxis(x, np.expanddims(indexarray, axis=-1), axis=-1)\narray([[2],\n[0]])\n>>> # Same as np.max(x, axis=-1)\n>>> np.takealongaxis(x, np.expanddims(indexarray, axis=-1), axis=-1).squeeze(axis=-1)\narray([2, 0])\n" }, { "name": "argpartition", "content": "Perform an indirect partition along the given axis using the\nalgorithm specified by the `kind` keyword. It returns an array of\nindices of the same shape as `a` that index data along the given\naxis in partitioned order.\n\n.. versionadded:: 1.8.0\n\nParameters\n----------\na : arraylike\nArray to sort.\nkth : int or sequence of ints\nElement index to partition by. The k-th element will be in its\nfinal sorted position and all smaller elements will be moved\nbefore it and all larger elements behind it. The order all\nelements in the partitions is undefined. If provided with a\nsequence of k-th it will partition all of them into their sorted\nposition at once.\naxis : int or None, optional\nAxis along which to sort. The default is -1 (the last axis). If\nNone, the flattened array is used.\nkind : {'introselect'}, optional\nSelection algorithm. Default is 'introselect'\norder : str or list of str, optional\nWhen `a` is an array with fields defined, this argument\nspecifies which fields to compare first, second, etc. A single\nfield can be specified as a string, and not all fields need be\nspecified, but unspecified fields will still be used, in the\norder in which they come up in the dtype, to break ties.\n\nReturns\n-------\nindexarray : ndarray, int\nArray of indices that partition `a` along the specified axis.\nIf `a` is one-dimensional, ``a[indexarray]`` yields a partitioned `a`.\nMore generally, ``np.takealongaxis(a, indexarray, axis=a)`` always\nyields the partitioned `a`, irrespective of dimensionality.\n\nSee Also\n--------\npartition : Describes partition algorithms used.\nndarray.partition : Inplace partition.\nargsort : Full indirect sort.\ntakealongaxis : Apply ``indexarray`` from argpartition\nto an array as if by calling partition.\n\nNotes\n-----\nSee `partition` for notes on the different selection algorithms.\n\nExamples\n--------\nOne dimensional array:\n\n>>> x = np.array([3, 4, 2, 1])\n>>> x[np.argpartition(x, 3)]\narray([2, 1, 3, 4])\n>>> x[np.argpartition(x, (1, 3))]\narray([1, 2, 3, 4])\n\n>>> x = [3, 4, 2, 1]\n>>> np.array(x)[np.argpartition(x, 3)]\narray([2, 1, 3, 4])\n\nMulti-dimensional array:\n\n>>> x = np.array([[3, 4, 2], [1, 3, 1]])\n>>> indexarray = np.argpartition(x, kth=1, axis=-1)\n>>> np.takealongaxis(x, indexarray, axis=-1) # same as np.partition(x, kth=1)\narray([[2, 3, 4],\n[1, 1, 3]])\n" }, { "name": "argsort", "content": "Returns the indices that would sort an array.\n\nPerform an indirect sort along the given axis using the algorithm specified\nby the `kind` keyword. It returns an array of indices of the same shape as\n`a` that index data along the given axis in sorted order.\n\nParameters\n----------\na : arraylike\nArray to sort.\naxis : int or None, optional\nAxis along which to sort. The default is -1 (the last axis). If None,\nthe flattened array is used.\nkind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\nSorting algorithm. The default is 'quicksort'. Note that both 'stable'\nand 'mergesort' use timsort under the covers and, in general, the\nactual implementation will vary with data type. The 'mergesort' option\nis retained for backwards compatibility.\n\n.. versionchanged:: 1.15.0.\nThe 'stable' option was added.\norder : str or list of str, optional\nWhen `a` is an array with fields defined, this argument specifies\nwhich fields to compare first, second, etc. A single field can\nbe specified as a string, and not all fields need be specified,\nbut unspecified fields will still be used, in the order in which\nthey come up in the dtype, to break ties.\n\nReturns\n-------\nindexarray : ndarray, int\nArray of indices that sort `a` along the specified `axis`.\nIf `a` is one-dimensional, ``a[indexarray]`` yields a sorted `a`.\nMore generally, ``np.takealongaxis(a, indexarray, axis=axis)``\nalways yields the sorted `a`, irrespective of dimensionality.\n\nSee Also\n--------\nsort : Describes sorting algorithms used.\nlexsort : Indirect stable sort with multiple keys.\nndarray.sort : Inplace sort.\nargpartition : Indirect partial sort.\ntakealongaxis : Apply ``indexarray`` from argsort\nto an array as if by calling sort.\n\nNotes\n-----\nSee `sort` for notes on the different sorting algorithms.\n\nAs of NumPy 1.4.0 `argsort` works with real/complex arrays containing\nnan values. The enhanced sort order is documented in `sort`.\n\nExamples\n--------\nOne dimensional array:\n\n>>> x = np.array([3, 1, 2])\n>>> np.argsort(x)\narray([1, 2, 0])\n\nTwo-dimensional array:\n\n>>> x = np.array([[0, 3], [2, 2]])\n>>> x\narray([[0, 3],\n[2, 2]])\n\n>>> ind = np.argsort(x, axis=0) # sorts along first axis (down)\n>>> ind\narray([[0, 1],\n[1, 0]])\n>>> np.takealongaxis(x, ind, axis=0) # same as np.sort(x, axis=0)\narray([[0, 2],\n[2, 3]])\n\n>>> ind = np.argsort(x, axis=1) # sorts along last axis (across)\n>>> ind\narray([[0, 1],\n[0, 1]])\n>>> np.takealongaxis(x, ind, axis=1) # same as np.sort(x, axis=1)\narray([[0, 3],\n[2, 2]])\n\nIndices of the sorted elements of a N-dimensional array:\n\n>>> ind = np.unravelindex(np.argsort(x, axis=None), x.shape)\n>>> ind\n(array([0, 1, 1, 0]), array([0, 0, 1, 1]))\n>>> x[ind] # same as np.sort(x, axis=None)\narray([0, 2, 2, 3])\n\nSorting with keys:\n\n>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '>> x\narray([(1, 0), (0, 1)],\ndtype=[('x', '>> np.argsort(x, order=('x','y'))\narray([1, 0])\n\n>>> np.argsort(x, order=('y','x'))\narray([0, 1])\n" }, { "name": "argwhere", "content": "Find the indices of array elements that are non-zero, grouped by element.\n\nParameters\n----------\na : arraylike\nInput data.\n\nReturns\n-------\nindexarray : (N, a.ndim) ndarray\nIndices of elements that are non-zero. Indices are grouped by element.\nThis array will have shape ``(N, a.ndim)`` where ``N`` is the number of\nnon-zero items.\n\nSee Also\n--------\nwhere, nonzero\n\nNotes\n-----\n``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,\nbut produces a result of the correct shape for a 0D array.\n\nThe output of ``argwhere`` is not suitable for indexing arrays.\nFor this purpose use ``nonzero(a)`` instead.\n\nExamples\n--------\n>>> x = np.arange(6).reshape(2,3)\n>>> x\narray([[0, 1, 2],\n[3, 4, 5]])\n>>> np.argwhere(x>1)\narray([[0, 2],\n[1, 0],\n[1, 1],\n[1, 2]])\n" }, { "name": "around", "content": "Evenly round to the given number of decimals.\n\nParameters\n----------\na : arraylike\nInput data.\ndecimals : int, optional\nNumber of decimal places to round to (default: 0). If\ndecimals is negative, it specifies the number of positions to\nthe left of the decimal point.\nout : ndarray, optional\nAlternative output array in which to place the result. It must have\nthe same shape as the expected output, but the type of the output\nvalues will be cast if necessary. See :ref:`ufuncs-output-type` for more\ndetails.\n\nReturns\n-------\nroundedarray : ndarray\nAn array of the same type as `a`, containing the rounded values.\nUnless `out` was specified, a new array is created. A reference to\nthe result is returned.\n\nThe real and imaginary parts of complex numbers are rounded\nseparately. The result of rounding a float is a float.\n\nSee Also\n--------\nndarray.round : equivalent method\n\nceil, fix, floor, rint, trunc\n\n\nNotes\n-----\nFor values exactly halfway between rounded decimal values, NumPy\nrounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,\n-0.5 and 0.5 round to 0.0, etc.\n\n``np.around`` uses a fast but sometimes inexact algorithm to round\nfloating-point datatypes. For positive `decimals` it is equivalent to\n``np.truedivide(np.rint(a * 10decimals), 10decimals)``, which has\nerror due to the inexact representation of decimal fractions in the IEEE\nfloating point standard [1] and errors introduced when scaling by powers\nof ten. For instance, note the extra \"1\" in the following:\n\n>>> np.round(56294995342131.5, 3)\n56294995342131.51\n\nIf your goal is to print such values with a fixed number of decimals, it is\npreferable to use numpy's float printing routines to limit the number of\nprinted decimals:\n\n>>> np.formatfloatpositional(56294995342131.5, precision=3)\n'56294995342131.5'\n\nThe float printing routines use an accurate but much more computationally\ndemanding algorithm to compute the number of digits after the decimal\npoint.\n\nAlternatively, Python's builtin `round` function uses a more accurate\nbut slower algorithm for 64-bit floating point values:\n\n>>> round(56294995342131.5, 3)\n56294995342131.5\n>>> np.round(16.055, 2), round(16.055, 2) # equals 16.0549999999999997\n(16.06, 16.05)\n\n\nReferences\n----------\n.. [1] \"Lecture Notes on the Status of IEEE 754\", William Kahan,\nhttps://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF\n.. [2] \"How Futile are Mindless Assessments of\nRoundoff in Floating-Point Computation?\", William Kahan,\nhttps://people.eecs.berkeley.edu/~wkahan/Mindless.pdf\n\nExamples\n--------\n>>> np.around([0.37, 1.64])\narray([0., 2.])\n>>> np.around([0.37, 1.64], decimals=1)\narray([0.4, 1.6])\n>>> np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value\narray([0., 2., 2., 4., 4.])\n>>> np.around([1,2,3,11], decimals=1) # ndarray of ints is returned\narray([ 1, 2, 3, 11])\n>>> np.around([1,2,3,11], decimals=-1)\narray([ 0, 0, 0, 10])\n" }, { "name": "array", "content": "array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,\nlike=None)\n\nCreate an array.\n\nParameters\n----------\nobject : arraylike\nAn array, any object exposing the array interface, an object whose\narray method returns an array, or any (nested) sequence.\ndtype : data-type, optional\nThe desired data-type for the array. If not given, then the type will\nbe determined as the minimum type required to hold the objects in the\nsequence.\ncopy : bool, optional\nIf true (default), then the object is copied. Otherwise, a copy will\nonly be made if array returns a copy, if obj is a nested sequence,\nor if a copy is needed to satisfy any of the other requirements\n(`dtype`, `order`, etc.).\norder : {'K', 'A', 'C', 'F'}, optional\nSpecify the memory layout of the array. If object is not an array, the\nnewly created array will be in C order (row major) unless 'F' is\nspecified, in which case it will be in Fortran order (column major).\nIf object is an array the following holds.\n\n===== ========= ===================================================\norder no copy copy=True\n===== ========= ===================================================\n'K' unchanged F & C order preserved, otherwise most similar order\n'A' unchanged F order if input is F and not C, otherwise C order\n'C' C order C order\n'F' F order F order\n===== ========= ===================================================\n\nWhen ``copy=False`` and a copy is made for other reasons, the result is\nthe same as if ``copy=True``, with some exceptions for 'A', see the\nNotes section. The default order is 'K'.\nsubok : bool, optional\nIf True, then sub-classes will be passed-through, otherwise\nthe returned array will be forced to be a base-class array (default).\nndmin : int, optional\nSpecifies the minimum number of dimensions that the resulting\narray should have. Ones will be pre-pended to the shape as\nneeded to meet this requirement.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nAn array object satisfying the specified requirements.\n\nSee Also\n--------\nemptylike : Return an empty array with shape and type of input.\noneslike : Return an array of ones with shape and type of input.\nzeroslike : Return an array of zeros with shape and type of input.\nfulllike : Return a new array with shape of input filled with value.\nempty : Return a new uninitialized array.\nones : Return a new array setting values to one.\nzeros : Return a new array setting values to zero.\nfull : Return a new array of given shape filled with value.\n\n\nNotes\n-----\nWhen order is 'A' and `object` is an array in neither 'C' nor 'F' order,\nand a copy is forced by a change in dtype, then the order of the result is\nnot necessarily 'C' as expected. This is likely a bug.\n\nExamples\n--------\n>>> np.array([1, 2, 3])\narray([1, 2, 3])\n\nUpcasting:\n\n>>> np.array([1, 2, 3.0])\narray([ 1., 2., 3.])\n\nMore than one dimension:\n\n>>> np.array([[1, 2], [3, 4]])\narray([[1, 2],\n[3, 4]])\n\nMinimum dimensions 2:\n\n>>> np.array([1, 2, 3], ndmin=2)\narray([[1, 2, 3]])\n\nType provided:\n\n>>> np.array([1, 2, 3], dtype=complex)\narray([ 1.+0.j, 2.+0.j, 3.+0.j])\n\nData-type consisting of more than one element:\n\n>>> x = np.array([(1,2),(3,4)],dtype=[('a','>> x['a']\narray([1, 3])\n\nCreating an array from sub-classes:\n\n>>> np.array(np.mat('1 2; 3 4'))\narray([[1, 2],\n[3, 4]])\n\n>>> np.array(np.mat('1 2; 3 4'), subok=True)\nmatrix([[1, 2],\n[3, 4]])\n" }, { "name": "array2string", "content": "Return a string representation of an array.\n\nParameters\n----------\na : ndarray\nInput array.\nmaxlinewidth : int, optional\nInserts newlines if text is longer than `maxlinewidth`.\nDefaults to ``numpy.getprintoptions()['linewidth']``.\nprecision : int or None, optional\nFloating point precision.\nDefaults to ``numpy.getprintoptions()['precision']``.\nsuppresssmall : bool, optional\nRepresent numbers \"very close\" to zero as zero; default is False.\nVery close is defined by precision: if the precision is 8, e.g.,\nnumbers smaller (in absolute value) than 5e-9 are represented as\nzero.\nDefaults to ``numpy.getprintoptions()['suppress']``.\nseparator : str, optional\nInserted between elements.\nprefix : str, optional\nsuffix : str, optional\nThe length of the prefix and suffix strings are used to respectively\nalign and wrap the output. An array is typically printed as::\n\nprefix + array2string(a) + suffix\n\nThe output is left-padded by the length of the prefix string, and\nwrapping is forced at the column ``maxlinewidth - len(suffix)``.\nIt should be noted that the content of prefix and suffix strings are\nnot included in the output.\nstyle : NoValue, optional\nHas no effect, do not use.\n\n.. deprecated:: 1.14.0\nformatter : dict of callables, optional\nIf not None, the keys should indicate the type(s) that the respective\nformatting function applies to. Callables should return a string.\nTypes that are not specified (by their corresponding keys) are handled\nby the default formatters. Individual types for which a formatter\ncan be set are:\n\n- 'bool'\n- 'int'\n- 'timedelta' : a `numpy.timedelta64`\n- 'datetime' : a `numpy.datetime64`\n- 'float'\n- 'longfloat' : 128-bit floats\n- 'complexfloat'\n- 'longcomplexfloat' : composed of two 128-bit floats\n- 'void' : type `numpy.void`\n- 'numpystr' : types `numpy.string` and `numpy.unicode`\n\nOther keys that can be used to set a group of types at once are:\n\n- 'all' : sets all types\n- 'intkind' : sets 'int'\n- 'floatkind' : sets 'float' and 'longfloat'\n- 'complexkind' : sets 'complexfloat' and 'longcomplexfloat'\n- 'strkind' : sets 'numpystr'\nthreshold : int, optional\nTotal number of array elements which trigger summarization\nrather than full repr.\nDefaults to ``numpy.getprintoptions()['threshold']``.\nedgeitems : int, optional\nNumber of array items in summary at beginning and end of\neach dimension.\nDefaults to ``numpy.getprintoptions()['edgeitems']``.\nsign : string, either '-', '+', or ' ', optional\nControls printing of the sign of floating-point types. If '+', always\nprint the sign of positive values. If ' ', always prints a space\n(whitespace character) in the sign position of positive values. If\n'-', omit the sign character of positive values.\nDefaults to ``numpy.getprintoptions()['sign']``.\nfloatmode : str, optional\nControls the interpretation of the `precision` option for\nfloating-point types.\nDefaults to ``numpy.getprintoptions()['floatmode']``.\nCan take the following values:\n\n- 'fixed': Always print exactly `precision` fractional digits,\neven if this would print more or fewer digits than\nnecessary to specify the value uniquely.\n- 'unique': Print the minimum number of fractional digits necessary\nto represent each value uniquely. Different elements may\nhave a different number of digits. The value of the\n`precision` option is ignored.\n- 'maxprec': Print at most `precision` fractional digits, but if\nan element can be uniquely represented with fewer digits\nonly print it with that many.\n- 'maxprecequal': Print at most `precision` fractional digits,\nbut if every element in the array can be uniquely\nrepresented with an equal number of fewer digits, use that\nmany digits for all elements.\nlegacy : string or `False`, optional\nIf set to the string `'1.13'` enables 1.13 legacy printing mode. This\napproximates numpy 1.13 print output by including a space in the sign\nposition of floats and different behavior for 0d arrays. If set to\n`False`, disables legacy mode. Unrecognized strings will be ignored\nwith a warning for forward compatibility.\n\n.. versionadded:: 1.14.0\n\nReturns\n-------\narraystr : str\nString representation of the array.\n\nRaises\n------\nTypeError\nif a callable in `formatter` does not return a string.\n\nSee Also\n--------\narraystr, arrayrepr, setprintoptions, getprintoptions\n\nNotes\n-----\nIf a formatter is specified for a certain type, the `precision` keyword is\nignored for that type.\n\nThis is a very flexible function; `arrayrepr` and `arraystr` are using\n`array2string` internally so keywords with the same name should work\nidentically in all three functions.\n\nExamples\n--------\n>>> x = np.array([1e-16,1,2,3])\n>>> np.array2string(x, precision=2, separator=',',\n... suppresssmall=True)\n'[0.,1.,2.,3.]'\n\n>>> x = np.arange(3.)\n>>> np.array2string(x, formatter={'floatkind':lambda x: \"%.2f\" % x})\n'[0.00 1.00 2.00]'\n\n>>> x = np.arange(3)\n>>> np.array2string(x, formatter={'int':lambda x: hex(x)})\n'[0x0 0x1 0x2]'\n" }, { "name": "array_equal", "content": "True if two arrays have the same shape and elements, False otherwise.\n\nParameters\n----------\na1, a2 : arraylike\nInput arrays.\nequalnan : bool\nWhether to compare NaN's as equal. If the dtype of a1 and a2 is\ncomplex, values will be considered equal if either the real or the\nimaginary component of a given value is ``nan``.\n\n.. versionadded:: 1.19.0\n\nReturns\n-------\nb : bool\nReturns True if the arrays are equal.\n\nSee Also\n--------\nallclose: Returns True if two arrays are element-wise equal within a\ntolerance.\narrayequiv: Returns True if input arrays are shape consistent and all\nelements equal.\n\nExamples\n--------\n>>> np.arrayequal([1, 2], [1, 2])\nTrue\n>>> np.arrayequal(np.array([1, 2]), np.array([1, 2]))\nTrue\n>>> np.arrayequal([1, 2], [1, 2, 3])\nFalse\n>>> np.arrayequal([1, 2], [1, 4])\nFalse\n>>> a = np.array([1, np.nan])\n>>> np.arrayequal(a, a)\nFalse\n>>> np.arrayequal(a, a, equalnan=True)\nTrue\n\nWhen ``equalnan`` is True, complex values with nan components are\nconsidered equal if either the real *or* the imaginary components are nan.\n\n>>> a = np.array([1 + 1j])\n>>> b = a.copy()\n>>> a.real = np.nan\n>>> b.imag = np.nan\n>>> np.arrayequal(a, b, equalnan=True)\nTrue\n" }, { "name": "array_equiv", "content": "Returns True if input arrays are shape consistent and all elements equal.\n\nShape consistent means they are either the same shape, or one input array\ncan be broadcasted to create the same shape as the other one.\n\nParameters\n----------\na1, a2 : arraylike\nInput arrays.\n\nReturns\n-------\nout : bool\nTrue if equivalent, False otherwise.\n\nExamples\n--------\n>>> np.arrayequiv([1, 2], [1, 2])\nTrue\n>>> np.arrayequiv([1, 2], [1, 3])\nFalse\n\nShowing the shape equivalence:\n\n>>> np.arrayequiv([1, 2], [[1, 2], [1, 2]])\nTrue\n>>> np.arrayequiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])\nFalse\n\n>>> np.arrayequiv([1, 2], [[1, 2], [1, 3]])\nFalse\n" }, { "name": "array_repr", "content": "Return the string representation of an array.\n\nParameters\n----------\narr : ndarray\nInput array.\nmaxlinewidth : int, optional\nInserts newlines if text is longer than `maxlinewidth`.\nDefaults to ``numpy.getprintoptions()['linewidth']``.\nprecision : int, optional\nFloating point precision.\nDefaults to ``numpy.getprintoptions()['precision']``.\nsuppresssmall : bool, optional\nRepresent numbers \"very close\" to zero as zero; default is False.\nVery close is defined by precision: if the precision is 8, e.g.,\nnumbers smaller (in absolute value) than 5e-9 are represented as\nzero.\nDefaults to ``numpy.getprintoptions()['suppress']``.\n\nReturns\n-------\nstring : str\nThe string representation of an array.\n\nSee Also\n--------\narraystr, array2string, setprintoptions\n\nExamples\n--------\n>>> np.arrayrepr(np.array([1,2]))\n'array([1, 2])'\n>>> np.arrayrepr(np.ma.array([0.]))\n'MaskedArray([0.])'\n>>> np.arrayrepr(np.array([], np.int32))\n'array([], dtype=int32)'\n\n>>> x = np.array([1e-6, 4e-7, 2, 3])\n>>> np.arrayrepr(x, precision=6, suppresssmall=True)\n'array([0.000001, 0. , 2. , 3. ])'\n" }, { "name": "array_split", "content": "Split an array into multiple sub-arrays.\n\nPlease refer to the ``split`` documentation. The only difference\nbetween these functions is that ``arraysplit`` allows\n`indicesorsections` to be an integer that does *not* equally\ndivide the axis. For an array of length l that should be split\ninto n sections, it returns l % n sub-arrays of size l//n + 1\nand the rest of size l//n.\n\nSee Also\n--------\nsplit : Split array into multiple sub-arrays of equal size.\n\nExamples\n--------\n>>> x = np.arange(8.0)\n>>> np.arraysplit(x, 3)\n[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]\n\n>>> x = np.arange(9)\n>>> np.arraysplit(x, 4)\n[array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]\n" }, { "name": "array_str", "content": "Return a string representation of the data in an array.\n\nThe data in the array is returned as a single string. This function is\nsimilar to `arrayrepr`, the difference being that `arrayrepr` also\nreturns information on the kind of array and its data type.\n\nParameters\n----------\na : ndarray\nInput array.\nmaxlinewidth : int, optional\nInserts newlines if text is longer than `maxlinewidth`.\nDefaults to ``numpy.getprintoptions()['linewidth']``.\nprecision : int, optional\nFloating point precision.\nDefaults to ``numpy.getprintoptions()['precision']``.\nsuppresssmall : bool, optional\nRepresent numbers \"very close\" to zero as zero; default is False.\nVery close is defined by precision: if the precision is 8, e.g.,\nnumbers smaller (in absolute value) than 5e-9 are represented as\nzero.\nDefaults to ``numpy.getprintoptions()['suppress']``.\n\nSee Also\n--------\narray2string, arrayrepr, setprintoptions\n\nExamples\n--------\n>>> np.arraystr(np.arange(3))\n'[0 1 2]'\n" }, { "name": "asanyarray", "content": "asanyarray(a, dtype=None, order=None, *, like=None)\n\nConvert the input to an ndarray, but pass ndarray subclasses through.\n\nParameters\n----------\na : arraylike\nInput data, in any form that can be converted to an array. This\nincludes scalars, lists, lists of tuples, tuples, tuples of tuples,\ntuples of lists, and ndarrays.\ndtype : data-type, optional\nBy default, the data-type is inferred from the input data.\norder : {'C', 'F', 'A', 'K'}, optional\nMemory layout. 'A' and 'K' depend on the order of input array a.\n'C' row-major (C-style),\n'F' column-major (Fortran-style) memory representation.\n'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise\n'K' (keep) preserve input order\nDefaults to 'C'.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray or an ndarray subclass\nArray interpretation of `a`. If `a` is an ndarray or a subclass\nof ndarray, it is returned as-is and no copy is performed.\n\nSee Also\n--------\nasarray : Similar function which always returns ndarrays.\nascontiguousarray : Convert input to a contiguous array.\nasfarray : Convert input to a floating point ndarray.\nasfortranarray : Convert input to an ndarray with column-major\nmemory order.\nasarraychkfinite : Similar function which checks input for NaNs and\nInfs.\nfromiter : Create an array from an iterator.\nfromfunction : Construct an array by executing a function on grid\npositions.\n\nExamples\n--------\nConvert a list into an array:\n\n>>> a = [1, 2]\n>>> np.asanyarray(a)\narray([1, 2])\n\nInstances of `ndarray` subclasses are passed through as-is:\n\n>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)\n>>> np.asanyarray(a) is a\nTrue\n" }, { "name": "asarray", "content": "asarray(a, dtype=None, order=None, *, like=None)\n\nConvert the input to an array.\n\nParameters\n----------\na : arraylike\nInput data, in any form that can be converted to an array. This\nincludes lists, lists of tuples, tuples, tuples of tuples, tuples\nof lists and ndarrays.\ndtype : data-type, optional\nBy default, the data-type is inferred from the input data.\norder : {'C', 'F', 'A', 'K'}, optional\nMemory layout. 'A' and 'K' depend on the order of input array a.\n'C' row-major (C-style),\n'F' column-major (Fortran-style) memory representation.\n'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise\n'K' (keep) preserve input order\nDefaults to 'C'.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nArray interpretation of `a`. No copy is performed if the input\nis already an ndarray with matching dtype and order. If `a` is a\nsubclass of ndarray, a base class ndarray is returned.\n\nSee Also\n--------\nasanyarray : Similar function which passes through subclasses.\nascontiguousarray : Convert input to a contiguous array.\nasfarray : Convert input to a floating point ndarray.\nasfortranarray : Convert input to an ndarray with column-major\nmemory order.\nasarraychkfinite : Similar function which checks input for NaNs and Infs.\nfromiter : Create an array from an iterator.\nfromfunction : Construct an array by executing a function on grid\npositions.\n\nExamples\n--------\nConvert a list into an array:\n\n>>> a = [1, 2]\n>>> np.asarray(a)\narray([1, 2])\n\nExisting arrays are not copied:\n\n>>> a = np.array([1, 2])\n>>> np.asarray(a) is a\nTrue\n\nIf `dtype` is set, array is copied only if dtype does not match:\n\n>>> a = np.array([1, 2], dtype=np.float32)\n>>> np.asarray(a, dtype=np.float32) is a\nTrue\n>>> np.asarray(a, dtype=np.float64) is a\nFalse\n\nContrary to `asanyarray`, ndarray subclasses are not passed through:\n\n>>> issubclass(np.recarray, np.ndarray)\nTrue\n>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)\n>>> np.asarray(a) is a\nFalse\n>>> np.asanyarray(a) is a\nTrue\n" }, { "name": "asarray_chkfinite", "content": "Convert the input to an array, checking for NaNs or Infs.\n\nParameters\n----------\na : arraylike\nInput data, in any form that can be converted to an array. This\nincludes lists, lists of tuples, tuples, tuples of tuples, tuples\nof lists and ndarrays. Success requires no NaNs or Infs.\ndtype : data-type, optional\nBy default, the data-type is inferred from the input data.\norder : {'C', 'F', 'A', 'K'}, optional\nMemory layout. 'A' and 'K' depend on the order of input array a.\n'C' row-major (C-style),\n'F' column-major (Fortran-style) memory representation.\n'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise\n'K' (keep) preserve input order\nDefaults to 'C'.\n\nReturns\n-------\nout : ndarray\nArray interpretation of `a`. No copy is performed if the input\nis already an ndarray. If `a` is a subclass of ndarray, a base\nclass ndarray is returned.\n\nRaises\n------\nValueError\nRaises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).\n\nSee Also\n--------\nasarray : Create and array.\nasanyarray : Similar function which passes through subclasses.\nascontiguousarray : Convert input to a contiguous array.\nasfarray : Convert input to a floating point ndarray.\nasfortranarray : Convert input to an ndarray with column-major\nmemory order.\nfromiter : Create an array from an iterator.\nfromfunction : Construct an array by executing a function on grid\npositions.\n\nExamples\n--------\nConvert a list into an array. If all elements are finite\n``asarraychkfinite`` is identical to ``asarray``.\n\n>>> a = [1, 2]\n>>> np.asarraychkfinite(a, dtype=float)\narray([1., 2.])\n\nRaises ValueError if arraylike contains Nans or Infs.\n\n>>> a = [1, 2, np.inf]\n>>> try:\n... np.asarraychkfinite(a)\n... except ValueError:\n... print('ValueError')\n...\nValueError\n" }, { "name": "ascontiguousarray", "content": "ascontiguousarray(a, dtype=None, *, like=None)\n\nReturn a contiguous array (ndim >= 1) in memory (C order).\n\nParameters\n----------\na : arraylike\nInput array.\ndtype : str or dtype object, optional\nData-type of returned array.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nContiguous array of same shape and content as `a`, with type `dtype`\nif specified.\n\nSee Also\n--------\nasfortranarray : Convert input to an ndarray with column-major\nmemory order.\nrequire : Return an ndarray that satisfies requirements.\nndarray.flags : Information about the memory layout of the array.\n\nExamples\n--------\n>>> x = np.arange(6).reshape(2,3)\n>>> np.ascontiguousarray(x, dtype=np.float32)\narray([[0., 1., 2.],\n[3., 4., 5.]], dtype=float32)\n>>> x.flags['CCONTIGUOUS']\nTrue\n\nNote: This function returns an array with at least one-dimension (1-d)\nso it will not preserve 0-d arrays.\n" }, { "name": "asfarray", "content": "Return an array converted to a float type.\n\nParameters\n----------\na : arraylike\nThe input array.\ndtype : str or dtype object, optional\nFloat type code to coerce input array `a`. If `dtype` is one of the\n'int' dtypes, it is replaced with float64.\n\nReturns\n-------\nout : ndarray\nThe input `a` as a float ndarray.\n\nExamples\n--------\n>>> np.asfarray([2, 3])\narray([2., 3.])\n>>> np.asfarray([2, 3], dtype='float')\narray([2., 3.])\n>>> np.asfarray([2, 3], dtype='int8')\narray([2., 3.])\n" }, { "name": "asfortranarray", "content": "asfortranarray(a, dtype=None, *, like=None)\n\nReturn an array (ndim >= 1) laid out in Fortran order in memory.\n\nParameters\n----------\na : arraylike\nInput array.\ndtype : str or dtype object, optional\nBy default, the data-type is inferred from the input data.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nThe input `a` in Fortran, or column-major, order.\n\nSee Also\n--------\nascontiguousarray : Convert input to a contiguous (C order) array.\nasanyarray : Convert input to an ndarray with either row or\ncolumn-major memory order.\nrequire : Return an ndarray that satisfies requirements.\nndarray.flags : Information about the memory layout of the array.\n\nExamples\n--------\n>>> x = np.arange(6).reshape(2,3)\n>>> y = np.asfortranarray(x)\n>>> x.flags['FCONTIGUOUS']\nFalse\n>>> y.flags['FCONTIGUOUS']\nTrue\n\nNote: This function returns an array with at least one-dimension (1-d)\nso it will not preserve 0-d arrays.\n" }, { "name": "asmatrix", "content": "Interpret the input as a matrix.\n\nUnlike `matrix`, `asmatrix` does not make a copy if the input is already\na matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``.\n\nParameters\n----------\ndata : arraylike\nInput data.\ndtype : data-type\nData-type of the output matrix.\n\nReturns\n-------\nmat : matrix\n`data` interpreted as a matrix.\n\nExamples\n--------\n>>> x = np.array([[1, 2], [3, 4]])\n\n>>> m = np.asmatrix(x)\n\n>>> x[0,0] = 5\n\n>>> m\nmatrix([[5, 2],\n[3, 4]])\n" }, { "name": "asscalar", "content": "Convert an array of size 1 to its scalar equivalent.\n\n.. deprecated:: 1.16\n\nDeprecated, use `numpy.ndarray.item()` instead.\n\nParameters\n----------\na : ndarray\nInput array of size 1.\n\nReturns\n-------\nout : scalar\nScalar representation of `a`. The output data type is the same type\nreturned by the input's `item` method.\n\nExamples\n--------\n>>> np.asscalar(np.array([24]))\n24\n" }, { "name": "atleast_1d", "content": "Convert inputs to arrays with at least one dimension.\n\nScalar inputs are converted to 1-dimensional arrays, whilst\nhigher-dimensional inputs are preserved.\n\nParameters\n----------\narys1, arys2, ... : arraylike\nOne or more input arrays.\n\nReturns\n-------\nret : ndarray\nAn array, or list of arrays, each with ``a.ndim >= 1``.\nCopies are made only if necessary.\n\nSee Also\n--------\natleast2d, atleast3d\n\nExamples\n--------\n>>> np.atleast1d(1.0)\narray([1.])\n\n>>> x = np.arange(9.0).reshape(3,3)\n>>> np.atleast1d(x)\narray([[0., 1., 2.],\n[3., 4., 5.],\n[6., 7., 8.]])\n>>> np.atleast1d(x) is x\nTrue\n\n>>> np.atleast1d(1, [3, 4])\n[array([1]), array([3, 4])]\n" }, { "name": "atleast_2d", "content": "View inputs as arrays with at least two dimensions.\n\nParameters\n----------\narys1, arys2, ... : arraylike\nOne or more array-like sequences. Non-array inputs are converted\nto arrays. Arrays that already have two or more dimensions are\npreserved.\n\nReturns\n-------\nres, res2, ... : ndarray\nAn array, or list of arrays, each with ``a.ndim >= 2``.\nCopies are avoided where possible, and views with two or more\ndimensions are returned.\n\nSee Also\n--------\natleast1d, atleast3d\n\nExamples\n--------\n>>> np.atleast2d(3.0)\narray([[3.]])\n\n>>> x = np.arange(3.0)\n>>> np.atleast2d(x)\narray([[0., 1., 2.]])\n>>> np.atleast2d(x).base is x\nTrue\n\n>>> np.atleast2d(1, [1, 2], [[1, 2]])\n[array([[1]]), array([[1, 2]]), array([[1, 2]])]\n" }, { "name": "atleast_3d", "content": "View inputs as arrays with at least three dimensions.\n\nParameters\n----------\narys1, arys2, ... : arraylike\nOne or more array-like sequences. Non-array inputs are converted to\narrays. Arrays that already have three or more dimensions are\npreserved.\n\nReturns\n-------\nres1, res2, ... : ndarray\nAn array, or list of arrays, each with ``a.ndim >= 3``. Copies are\navoided where possible, and views with three or more dimensions are\nreturned. For example, a 1-D array of shape ``(N,)`` becomes a view\nof shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a\nview of shape ``(M, N, 1)``.\n\nSee Also\n--------\natleast1d, atleast2d\n\nExamples\n--------\n>>> np.atleast3d(3.0)\narray([[[3.]]])\n\n>>> x = np.arange(3.0)\n>>> np.atleast3d(x).shape\n(1, 3, 1)\n\n>>> x = np.arange(12.0).reshape(4,3)\n>>> np.atleast3d(x).shape\n(4, 3, 1)\n>>> np.atleast3d(x).base is x.base # x is a reshape, so not base itself\nTrue\n\n>>> for arr in np.atleast3d([1, 2], [[1, 2]], [[[1, 2]]]):\n... print(arr, arr.shape) # doctest: +SKIP\n...\n[[[1]\n[2]]] (1, 2, 1)\n[[[1]\n[2]]] (1, 2, 1)\n[[[1 2]]] (1, 1, 2)\n" }, { "name": "average", "content": "Compute the weighted average along the specified axis.\n\nParameters\n----------\na : arraylike\nArray containing data to be averaged. If `a` is not an array, a\nconversion is attempted.\naxis : None or int or tuple of ints, optional\nAxis or axes along which to average `a`. The default,\naxis=None, will average over all of the elements of the input array.\nIf axis is negative it counts from the last to the first axis.\n\n.. versionadded:: 1.7.0\n\nIf axis is a tuple of ints, averaging is performed on all of the axes\nspecified in the tuple instead of a single axis or all the axes as\nbefore.\nweights : arraylike, optional\nAn array of weights associated with the values in `a`. Each value in\n`a` contributes to the average according to its associated weight.\nThe weights array can either be 1-D (in which case its length must be\nthe size of `a` along the given axis) or of the same shape as `a`.\nIf `weights=None`, then all data in `a` are assumed to have a\nweight equal to one. The 1-D calculation is::\n\navg = sum(a * weights) / sum(weights)\n\nThe only constraint on `weights` is that `sum(weights)` must not be 0.\nreturned : bool, optional\nDefault is `False`. If `True`, the tuple (`average`, `sumofweights`)\nis returned, otherwise only the average is returned.\nIf `weights=None`, `sumofweights` is equivalent to the number of\nelements over which the average is taken.\n\nReturns\n-------\nretval, [sumofweights] : arraytype or double\nReturn the average along the specified axis. When `returned` is `True`,\nreturn a tuple with the average as the first element and the sum\nof the weights as the second element. `sumofweights` is of the\nsame type as `retval`. The result dtype follows a genereal pattern.\nIf `weights` is None, the result dtype will be that of `a` , or ``float64``\nif `a` is integral. Otherwise, if `weights` is not None and `a` is non-\nintegral, the result type will be the type of lowest precision capable of\nrepresenting values of both `a` and `weights`. If `a` happens to be\nintegral, the previous rules still applies but the result dtype will\nat least be ``float64``.\n\nRaises\n------\nZeroDivisionError\nWhen all weights along axis are zero. See `numpy.ma.average` for a\nversion robust to this type of error.\nTypeError\nWhen the length of 1D `weights` is not the same as the shape of `a`\nalong axis.\n\nSee Also\n--------\nmean\n\nma.average : average for masked arrays -- useful if your data contains\n\"missing\" values\nnumpy.resulttype : Returns the type that results from applying the\nnumpy type promotion rules to the arguments.\n\nExamples\n--------\n>>> data = np.arange(1, 5)\n>>> data\narray([1, 2, 3, 4])\n>>> np.average(data)\n2.5\n>>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))\n4.0\n\n>>> data = np.arange(6).reshape((3,2))\n>>> data\narray([[0, 1],\n[2, 3],\n[4, 5]])\n>>> np.average(data, axis=1, weights=[1./4, 3./4])\narray([0.75, 2.75, 4.75])\n>>> np.average(data, weights=[1./4, 3./4])\nTraceback (most recent call last):\n...\nTypeError: Axis must be specified when shapes of a and weights differ.\n\n>>> a = np.ones(5, dtype=np.float128)\n>>> w = np.ones(5, dtype=np.complex64)\n>>> avg = np.average(a, weights=w)\n>>> print(avg.dtype)\ncomplex256\n" }, { "name": "bartlett", "content": "Return the Bartlett window.\n\nThe Bartlett window is very similar to a triangular window, except\nthat the end points are at zero. It is often used in signal\nprocessing for tapering a signal, without generating too much\nripple in the frequency domain.\n\nParameters\n----------\nM : int\nNumber of points in the output window. If zero or less, an\nempty array is returned.\n\nReturns\n-------\nout : array\nThe triangular window, with the maximum value normalized to one\n(the value one appears only if the number of samples is odd), with\nthe first and last samples equal to zero.\n\nSee Also\n--------\nblackman, hamming, hanning, kaiser\n\nNotes\n-----\nThe Bartlett window is defined as\n\n.. math:: w(n) = \\frac{2}{M-1} \\left(\n\\frac{M-1}{2} - \\left|n - \\frac{M-1}{2}\\right|\n\\right)\n\nMost references to the Bartlett window come from the signal\nprocessing literature, where it is used as one of many windowing\nfunctions for smoothing values. Note that convolution with this\nwindow produces linear interpolation. It is also known as an\napodization (which means\"removing the foot\", i.e. smoothing\ndiscontinuities at the beginning and end of the sampled signal) or\ntapering function. The fourier transform of the Bartlett is the product\nof two sinc functions.\nNote the excellent discussion in Kanasewich.\n\nReferences\n----------\n.. [1] M.S. Bartlett, \"Periodogram Analysis and Continuous Spectra\",\nBiometrika 37, 1-16, 1950.\n.. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",\nThe University of Alberta Press, 1975, pp. 109-110.\n.. [3] A.V. Oppenheim and R.W. Schafer, \"Discrete-Time Signal\nProcessing\", Prentice-Hall, 1999, pp. 468-471.\n.. [4] Wikipedia, \"Window function\",\nhttps://en.wikipedia.org/wiki/Windowfunction\n.. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,\n\"Numerical Recipes\", Cambridge University Press, 1986, page 429.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> np.bartlett(12)\narray([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary\n0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636,\n0.18181818, 0. ])\n\nPlot the window and its frequency response (requires SciPy and matplotlib):\n\n>>> from numpy.fft import fft, fftshift\n>>> window = np.bartlett(51)\n>>> plt.plot(window)\n[]\n>>> plt.title(\"Bartlett window\")\nText(0.5, 1.0, 'Bartlett window')\n>>> plt.ylabel(\"Amplitude\")\nText(0, 0.5, 'Amplitude')\n>>> plt.xlabel(\"Sample\")\nText(0.5, 0, 'Sample')\n>>> plt.show()\n\n>>> plt.figure()\n
\n>>> A = fft(window, 2048) / 25.5\n>>> mag = np.abs(fftshift(A))\n>>> freq = np.linspace(-0.5, 0.5, len(A))\n>>> with np.errstate(divide='ignore', invalid='ignore'):\n... response = 20 * np.log10(mag)\n...\n>>> response = np.clip(response, -100, 100)\n>>> plt.plot(freq, response)\n[]\n>>> plt.title(\"Frequency response of Bartlett window\")\nText(0.5, 1.0, 'Frequency response of Bartlett window')\n>>> plt.ylabel(\"Magnitude [dB]\")\nText(0, 0.5, 'Magnitude [dB]')\n>>> plt.xlabel(\"Normalized frequency [cycles per sample]\")\nText(0.5, 0, 'Normalized frequency [cycles per sample]')\n>>> = plt.axis('tight')\n>>> plt.show()\n" }, { "name": "base_repr", "content": "Return a string representation of a number in the given base system.\n\nParameters\n----------\nnumber : int\nThe value to convert. Positive and negative values are handled.\nbase : int, optional\nConvert `number` to the `base` number system. The valid range is 2-36,\nthe default value is 2.\npadding : int, optional\nNumber of zeros padded on the left. Default is 0 (no padding).\n\nReturns\n-------\nout : str\nString representation of `number` in `base` system.\n\nSee Also\n--------\nbinaryrepr : Faster version of `baserepr` for base 2.\n\nExamples\n--------\n>>> np.baserepr(5)\n'101'\n>>> np.baserepr(6, 5)\n'11'\n>>> np.baserepr(7, base=5, padding=3)\n'00012'\n\n>>> np.baserepr(10, base=16)\n'A'\n>>> np.baserepr(32, base=16)\n'20'\n" }, { "name": "binary_repr", "content": "Return the binary representation of the input number as a string.\n\nFor negative numbers, if width is not given, a minus sign is added to the\nfront. If width is given, the two's complement of the number is\nreturned, with respect to that width.\n\nIn a two's-complement system negative numbers are represented by the two's\ncomplement of the absolute value. This is the most common method of\nrepresenting signed integers on computers [1]. A N-bit two's-complement\nsystem can represent every integer in the range\n:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.\n\nParameters\n----------\nnum : int\nOnly an integer decimal number can be used.\nwidth : int, optional\nThe length of the returned string if `num` is positive, or the length\nof the two's complement if `num` is negative, provided that `width` is\nat least a sufficient number of bits for `num` to be represented in the\ndesignated form.\n\nIf the `width` value is insufficient, it will be ignored, and `num` will\nbe returned in binary (`num` > 0) or two's complement (`num` < 0) form\nwith its width equal to the minimum number of bits needed to represent\nthe number in the designated form. This behavior is deprecated and will\nlater raise an error.\n\n.. deprecated:: 1.12.0\n\nReturns\n-------\nbin : str\nBinary representation of `num` or two's complement of `num`.\n\nSee Also\n--------\nbaserepr: Return a string representation of a number in the given base\nsystem.\nbin: Python's built-in binary representation generator of an integer.\n\nNotes\n-----\n`binaryrepr` is equivalent to using `baserepr` with base 2, but about 25x\nfaster.\n\nReferences\n----------\n.. [1] Wikipedia, \"Two's complement\",\nhttps://en.wikipedia.org/wiki/Two'scomplement\n\nExamples\n--------\n>>> np.binaryrepr(3)\n'11'\n>>> np.binaryrepr(-3)\n'-11'\n>>> np.binaryrepr(3, width=4)\n'0011'\n\nThe two's complement is returned when the input number is negative and\nwidth is specified:\n\n>>> np.binaryrepr(-3, width=3)\n'101'\n>>> np.binaryrepr(-3, width=5)\n'11101'\n" }, { "name": "bincount", "content": "bincount(x, weights=None, minlength=0)\n\nCount number of occurrences of each value in array of non-negative ints.\n\nThe number of bins (of size 1) is one larger than the largest value in\n`x`. If `minlength` is specified, there will be at least this number\nof bins in the output array (though it will be longer if necessary,\ndepending on the contents of `x`).\nEach bin gives the number of occurrences of its index value in `x`.\nIf `weights` is specified the input array is weighted by it, i.e. if a\nvalue ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead\nof ``out[n] += 1``.\n\nParameters\n----------\nx : arraylike, 1 dimension, nonnegative ints\nInput array.\nweights : arraylike, optional\nWeights, array of the same shape as `x`.\nminlength : int, optional\nA minimum number of bins for the output array.\n\n.. versionadded:: 1.6.0\n\nReturns\n-------\nout : ndarray of ints\nThe result of binning the input array.\nThe length of `out` is equal to ``np.amax(x)+1``.\n\nRaises\n------\nValueError\nIf the input is not 1-dimensional, or contains elements with negative\nvalues, or if `minlength` is negative.\nTypeError\nIf the type of the input is float or complex.\n\nSee Also\n--------\nhistogram, digitize, unique\n\nExamples\n--------\n>>> np.bincount(np.arange(5))\narray([1, 1, 1, 1, 1])\n>>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))\narray([1, 3, 1, 1, 0, 0, 0, 1])\n\n>>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])\n>>> np.bincount(x).size == np.amax(x)+1\nTrue\n\nThe input array needs to be of integer dtype, otherwise a\nTypeError is raised:\n\n>>> np.bincount(np.arange(5, dtype=float))\nTraceback (most recent call last):\n...\nTypeError: Cannot cast array data from dtype('float64') to dtype('int64')\naccording to the rule 'safe'\n\nA possible use of ``bincount`` is to perform sums over\nvariable-size chunks of an array, using the ``weights`` keyword.\n\n>>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights\n>>> x = np.array([0, 1, 1, 2, 2, 2])\n>>> np.bincount(x, weights=w)\narray([ 0.3, 0.7, 1.1])\n" }, { "name": "blackman", "content": "Return the Blackman window.\n\nThe Blackman window is a taper formed by using the first three\nterms of a summation of cosines. It was designed to have close to the\nminimal leakage possible. It is close to optimal, only slightly worse\nthan a Kaiser window.\n\nParameters\n----------\nM : int\nNumber of points in the output window. If zero or less, an empty\narray is returned.\n\nReturns\n-------\nout : ndarray\nThe window, with the maximum value normalized to one (the value one\nappears only if the number of samples is odd).\n\nSee Also\n--------\nbartlett, hamming, hanning, kaiser\n\nNotes\n-----\nThe Blackman window is defined as\n\n.. math:: w(n) = 0.42 - 0.5 \\cos(2\\pi n/M) + 0.08 \\cos(4\\pi n/M)\n\nMost references to the Blackman window come from the signal processing\nliterature, where it is used as one of many windowing functions for\nsmoothing values. It is also known as an apodization (which means\n\"removing the foot\", i.e. smoothing discontinuities at the beginning\nand end of the sampled signal) or tapering function. It is known as a\n\"near optimal\" tapering function, almost as good (by some measures)\nas the kaiser window.\n\nReferences\n----------\nBlackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra,\nDover Publications, New York.\n\nOppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing.\nUpper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> np.blackman(12)\narray([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary\n4.14397981e-01, 7.36045180e-01, 9.67046769e-01,\n9.67046769e-01, 7.36045180e-01, 4.14397981e-01,\n1.59903635e-01, 3.26064346e-02, -1.38777878e-17])\n\nPlot the window and the frequency response:\n\n>>> from numpy.fft import fft, fftshift\n>>> window = np.blackman(51)\n>>> plt.plot(window)\n[]\n>>> plt.title(\"Blackman window\")\nText(0.5, 1.0, 'Blackman window')\n>>> plt.ylabel(\"Amplitude\")\nText(0, 0.5, 'Amplitude')\n>>> plt.xlabel(\"Sample\")\nText(0.5, 0, 'Sample')\n>>> plt.show()\n\n>>> plt.figure()\n
\n>>> A = fft(window, 2048) / 25.5\n>>> mag = np.abs(fftshift(A))\n>>> freq = np.linspace(-0.5, 0.5, len(A))\n>>> with np.errstate(divide='ignore', invalid='ignore'):\n... response = 20 * np.log10(mag)\n...\n>>> response = np.clip(response, -100, 100)\n>>> plt.plot(freq, response)\n[]\n>>> plt.title(\"Frequency response of Blackman window\")\nText(0.5, 1.0, 'Frequency response of Blackman window')\n>>> plt.ylabel(\"Magnitude [dB]\")\nText(0, 0.5, 'Magnitude [dB]')\n>>> plt.xlabel(\"Normalized frequency [cycles per sample]\")\nText(0.5, 0, 'Normalized frequency [cycles per sample]')\n>>> = plt.axis('tight')\n>>> plt.show()\n" }, { "name": "block", "content": "Assemble an nd-array from nested lists of blocks.\n\nBlocks in the innermost lists are concatenated (see `concatenate`) along\nthe last dimension (-1), then these are concatenated along the\nsecond-last dimension (-2), and so on until the outermost list is reached.\n\nBlocks can be of any dimension, but will not be broadcasted using the normal\nrules. Instead, leading axes of size 1 are inserted, to make ``block.ndim``\nthe same for all blocks. This is primarily useful for working with scalars,\nand means that code like ``np.block([v, 1])`` is valid, where\n``v.ndim == 1``.\n\nWhen the nested list is two levels deep, this allows block matrices to be\nconstructed from their components.\n\n.. versionadded:: 1.13.0\n\nParameters\n----------\narrays : nested list of arraylike or scalars (but not tuples)\nIf passed a single ndarray or scalar (a nested list of depth 0), this\nis returned unmodified (and not copied).\n\nElements shapes must match along the appropriate axes (without\nbroadcasting), but leading 1s will be prepended to the shape as\nnecessary to make the dimensions match.\n\nReturns\n-------\nblockarray : ndarray\nThe array assembled from the given blocks.\n\nThe dimensionality of the output is equal to the greatest of:\n* the dimensionality of all the inputs\n* the depth to which the input list is nested\n\nRaises\n------\nValueError\n* If list depths are mismatched - for instance, ``[[a, b], c]`` is\nillegal, and should be spelt ``[[a, b], [c]]``\n* If lists are empty - for instance, ``[[a, b], []]``\n\nSee Also\n--------\nconcatenate : Join a sequence of arrays along an existing axis.\nstack : Join a sequence of arrays along a new axis.\nvstack : Stack arrays in sequence vertically (row wise).\nhstack : Stack arrays in sequence horizontally (column wise).\ndstack : Stack arrays in sequence depth wise (along third axis).\ncolumnstack : Stack 1-D arrays as columns into a 2-D array.\nvsplit : Split an array into multiple sub-arrays vertically (row-wise).\n\nNotes\n-----\n\nWhen called with only scalars, ``np.block`` is equivalent to an ndarray\ncall. So ``np.block([[1, 2], [3, 4]])`` is equivalent to\n``np.array([[1, 2], [3, 4]])``.\n\nThis function does not enforce that the blocks lie on a fixed grid.\n``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::\n\nAAAbb\nAAAbb\ncccDD\n\nBut is also allowed to produce, for some ``a, b, c, d``::\n\nAAAbb\nAAAbb\ncDDDD\n\nSince concatenation happens along the last axis first, `block` is not\ncapable of producing the following directly::\n\nAAAbb\ncccbb\ncccDD\n\nMatlab's \"square bracket stacking\", ``[A, B, ...; p, q, ...]``, is\nequivalent to ``np.block([[A, B, ...], [p, q, ...]])``.\n\nExamples\n--------\nThe most common use of this function is to build a block matrix\n\n>>> A = np.eye(2) * 2\n>>> B = np.eye(3) * 3\n>>> np.block([\n... [A, np.zeros((2, 3))],\n... [np.ones((3, 2)), B ]\n... ])\narray([[2., 0., 0., 0., 0.],\n[0., 2., 0., 0., 0.],\n[1., 1., 3., 0., 0.],\n[1., 1., 0., 3., 0.],\n[1., 1., 0., 0., 3.]])\n\nWith a list of depth 1, `block` can be used as `hstack`\n\n>>> np.block([1, 2, 3]) # hstack([1, 2, 3])\narray([1, 2, 3])\n\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.block([a, b, 10]) # hstack([a, b, 10])\narray([ 1, 2, 3, 4, 5, 6, 10])\n\n>>> A = np.ones((2, 2), int)\n>>> B = 2 * A\n>>> np.block([A, B]) # hstack([A, B])\narray([[1, 1, 2, 2],\n[1, 1, 2, 2]])\n\nWith a list of depth 2, `block` can be used in place of `vstack`:\n\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.block([[a], [b]]) # vstack([a, b])\narray([[1, 2, 3],\n[4, 5, 6]])\n\n>>> A = np.ones((2, 2), int)\n>>> B = 2 * A\n>>> np.block([[A], [B]]) # vstack([A, B])\narray([[1, 1],\n[1, 1],\n[2, 2],\n[2, 2]])\n\nIt can also be used in places of `atleast1d` and `atleast2d`\n\n>>> a = np.array(0)\n>>> b = np.array([1])\n>>> np.block([a]) # atleast1d(a)\narray([0])\n>>> np.block([b]) # atleast1d(b)\narray([1])\n\n>>> np.block([[a]]) # atleast2d(a)\narray([[0]])\n>>> np.block([[b]]) # atleast2d(b)\narray([[1]])\n" }, { "name": "bmat", "content": "Build a matrix object from a string, nested sequence, or array.\n\nParameters\n----------\nobj : str or arraylike\nInput data. If a string, variables in the current scope may be\nreferenced by name.\nldict : dict, optional\nA dictionary that replaces local operands in current frame.\nIgnored if `obj` is not a string or `gdict` is None.\ngdict : dict, optional\nA dictionary that replaces global operands in current frame.\nIgnored if `obj` is not a string.\n\nReturns\n-------\nout : matrix\nReturns a matrix object, which is a specialized 2-D array.\n\nSee Also\n--------\nblock :\nA generalization of this function for N-d arrays, that returns normal\nndarrays.\n\nExamples\n--------\n>>> A = np.mat('1 1; 1 1')\n>>> B = np.mat('2 2; 2 2')\n>>> C = np.mat('3 4; 5 6')\n>>> D = np.mat('7 8; 9 0')\n\nAll the following expressions construct the same block matrix:\n\n>>> np.bmat([[A, B], [C, D]])\nmatrix([[1, 1, 2, 2],\n[1, 1, 2, 2],\n[3, 4, 7, 8],\n[5, 6, 9, 0]])\n>>> np.bmat(np.r[np.c[A, B], np.c[C, D]])\nmatrix([[1, 1, 2, 2],\n[1, 1, 2, 2],\n[3, 4, 7, 8],\n[5, 6, 9, 0]])\n>>> np.bmat('A,B; C,D')\nmatrix([[1, 1, 2, 2],\n[1, 1, 2, 2],\n[3, 4, 7, 8],\n[5, 6, 9, 0]])\n" }, { "name": "broadcast_arrays", "content": "Broadcast any number of arrays against each other.\n\nParameters\n----------\n`*args` : arraylikes\nThe arrays to broadcast.\n\nsubok : bool, optional\nIf True, then sub-classes will be passed-through, otherwise\nthe returned arrays will be forced to be a base-class array (default).\n\nReturns\n-------\nbroadcasted : list of arrays\nThese arrays are views on the original arrays. They are typically\nnot contiguous. Furthermore, more than one element of a\nbroadcasted array may refer to a single memory location. If you need\nto write to the arrays, make copies first. While you can set the\n``writable`` flag True, writing to a single output value may end up\nchanging more than one location in the output array.\n\n.. deprecated:: 1.17\nThe output is currently marked so that if written to, a deprecation\nwarning will be emitted. A future version will set the\n``writable`` flag False so writing to it will raise an error.\n\nSee Also\n--------\nbroadcast\nbroadcastto\nbroadcastshapes\n\nExamples\n--------\n>>> x = np.array([[1,2,3]])\n>>> y = np.array([[4],[5]])\n>>> np.broadcastarrays(x, y)\n[array([[1, 2, 3],\n[1, 2, 3]]), array([[4, 4, 4],\n[5, 5, 5]])]\n\nHere is a useful idiom for getting contiguous copies instead of\nnon-contiguous views.\n\n>>> [np.array(a) for a in np.broadcastarrays(x, y)]\n[array([[1, 2, 3],\n[1, 2, 3]]), array([[4, 4, 4],\n[5, 5, 5]])]\n" }, { "name": "broadcast_shapes", "content": "Broadcast the input shapes into a single shape.\n\n:ref:`Learn more about broadcasting here `.\n\n.. versionadded:: 1.20.0\n\nParameters\n----------\n`*args` : tuples of ints, or ints\nThe shapes to be broadcast against each other.\n\nReturns\n-------\ntuple\nBroadcasted shape.\n\nRaises\n------\nValueError\nIf the shapes are not compatible and cannot be broadcast according\nto NumPy's broadcasting rules.\n\nSee Also\n--------\nbroadcast\nbroadcastarrays\nbroadcastto\n\nExamples\n--------\n>>> np.broadcastshapes((1, 2), (3, 1), (3, 2))\n(3, 2)\n\n>>> np.broadcastshapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))\n(5, 6, 7)\n" }, { "name": "broadcast_to", "content": "Broadcast an array to a new shape.\n\nParameters\n----------\narray : arraylike\nThe array to broadcast.\nshape : tuple\nThe shape of the desired array.\nsubok : bool, optional\nIf True, then sub-classes will be passed-through, otherwise\nthe returned array will be forced to be a base-class array (default).\n\nReturns\n-------\nbroadcast : array\nA readonly view on the original array with the given shape. It is\ntypically not contiguous. Furthermore, more than one element of a\nbroadcasted array may refer to a single memory location.\n\nRaises\n------\nValueError\nIf the array is not compatible with the new shape according to NumPy's\nbroadcasting rules.\n\nSee Also\n--------\nbroadcast\nbroadcastarrays\nbroadcastshapes\n\nNotes\n-----\n.. versionadded:: 1.10.0\n\nExamples\n--------\n>>> x = np.array([1, 2, 3])\n>>> np.broadcastto(x, (3, 3))\narray([[1, 2, 3],\n[1, 2, 3],\n[1, 2, 3]])\n" }, { "name": "busday_count", "content": "busdaycount(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)\n\nCounts the number of valid days between `begindates` and\n`enddates`, not including the day of `enddates`.\n\nIf ``enddates`` specifies a date value that is earlier than the\ncorresponding ``begindates`` date value, the count will be negative.\n\n.. versionadded:: 1.7.0\n\nParameters\n----------\nbegindates : arraylike of datetime64[D]\nThe array of the first dates for counting.\nenddates : arraylike of datetime64[D]\nThe array of the end dates for counting, which are excluded\nfrom the count themselves.\nweekmask : str or arraylike of bool, optional\nA seven-element array indicating which of Monday through Sunday are\nvalid days. May be specified as a length-seven list or array, like\n[1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string\nlike \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for\nweekdays, optionally separated by white space. Valid abbreviations\nare: Mon Tue Wed Thu Fri Sat Sun\nholidays : arraylike of datetime64[D], optional\nAn array of dates to consider as invalid dates. They may be\nspecified in any order, and NaT (not-a-time) dates are ignored.\nThis list is saved in a normalized form that is suited for\nfast calculations of valid days.\nbusdaycal : busdaycalendar, optional\nA `busdaycalendar` object which specifies the valid days. If this\nparameter is provided, neither weekmask nor holidays may be\nprovided.\nout : array of int, optional\nIf provided, this array is filled with the result.\n\nReturns\n-------\nout : array of int\nAn array with a shape from broadcasting ``begindates`` and ``enddates``\ntogether, containing the number of valid days between\nthe begin and end dates.\n\nSee Also\n--------\nbusdaycalendar : An object that specifies a custom set of valid days.\nisbusday : Returns a boolean array indicating valid days.\nbusdayoffset : Applies an offset counted in valid days.\n\nExamples\n--------\n>>> # Number of weekdays in January 2011\n... np.busdaycount('2011-01', '2011-02')\n21\n>>> # Number of weekdays in 2011\n>>> np.busdaycount('2011', '2012')\n260\n>>> # Number of Saturdays in 2011\n... np.busdaycount('2011', '2012', weekmask='Sat')\n53\n" }, { "name": "busday_offset", "content": "busdayoffset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)\n\nFirst adjusts the date to fall on a valid day according to\nthe ``roll`` rule, then applies offsets to the given dates\ncounted in valid days.\n\n.. versionadded:: 1.7.0\n\nParameters\n----------\ndates : arraylike of datetime64[D]\nThe array of dates to process.\noffsets : arraylike of int\nThe array of offsets, which is broadcast with ``dates``.\nroll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional\nHow to treat dates that do not fall on a valid day. The default\nis 'raise'.\n\n* 'raise' means to raise an exception for an invalid day.\n* 'nat' means to return a NaT (not-a-time) for an invalid day.\n* 'forward' and 'following' mean to take the first valid day\nlater in time.\n* 'backward' and 'preceding' mean to take the first valid day\nearlier in time.\n* 'modifiedfollowing' means to take the first valid day\nlater in time unless it is across a Month boundary, in which\ncase to take the first valid day earlier in time.\n* 'modifiedpreceding' means to take the first valid day\nearlier in time unless it is across a Month boundary, in which\ncase to take the first valid day later in time.\nweekmask : str or arraylike of bool, optional\nA seven-element array indicating which of Monday through Sunday are\nvalid days. May be specified as a length-seven list or array, like\n[1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string\nlike \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for\nweekdays, optionally separated by white space. Valid abbreviations\nare: Mon Tue Wed Thu Fri Sat Sun\nholidays : arraylike of datetime64[D], optional\nAn array of dates to consider as invalid dates. They may be\nspecified in any order, and NaT (not-a-time) dates are ignored.\nThis list is saved in a normalized form that is suited for\nfast calculations of valid days.\nbusdaycal : busdaycalendar, optional\nA `busdaycalendar` object which specifies the valid days. If this\nparameter is provided, neither weekmask nor holidays may be\nprovided.\nout : array of datetime64[D], optional\nIf provided, this array is filled with the result.\n\nReturns\n-------\nout : array of datetime64[D]\nAn array with a shape from broadcasting ``dates`` and ``offsets``\ntogether, containing the dates with offsets applied.\n\nSee Also\n--------\nbusdaycalendar : An object that specifies a custom set of valid days.\nisbusday : Returns a boolean array indicating valid days.\nbusdaycount : Counts how many valid days are in a half-open date range.\n\nExamples\n--------\n>>> # First business day in October 2011 (not accounting for holidays)\n... np.busdayoffset('2011-10', 0, roll='forward')\nnumpy.datetime64('2011-10-03')\n>>> # Last business day in February 2012 (not accounting for holidays)\n... np.busdayoffset('2012-03', -1, roll='forward')\nnumpy.datetime64('2012-02-29')\n>>> # Third Wednesday in January 2011\n... np.busdayoffset('2011-01', 2, roll='forward', weekmask='Wed')\nnumpy.datetime64('2011-01-19')\n>>> # 2012 Mother's Day in Canada and the U.S.\n... np.busdayoffset('2012-05', 1, roll='forward', weekmask='Sun')\nnumpy.datetime64('2012-05-13')\n\n>>> # First business day on or after a date\n... np.busdayoffset('2011-03-20', 0, roll='forward')\nnumpy.datetime64('2011-03-21')\n>>> np.busdayoffset('2011-03-22', 0, roll='forward')\nnumpy.datetime64('2011-03-22')\n>>> # First business day after a date\n... np.busdayoffset('2011-03-20', 1, roll='backward')\nnumpy.datetime64('2011-03-21')\n>>> np.busdayoffset('2011-03-22', 1, roll='backward')\nnumpy.datetime64('2011-03-23')\n" }, { "name": "byte_bounds", "content": "Returns pointers to the end-points of an array.\n\nParameters\n----------\na : ndarray\nInput array. It must conform to the Python-side of the array\ninterface.\n\nReturns\n-------\n(low, high) : tuple of 2 integers\nThe first integer is the first byte of the array, the second\ninteger is just past the last byte of the array. If `a` is not\ncontiguous it will not use every byte between the (`low`, `high`)\nvalues.\n\nExamples\n--------\n>>> I = np.eye(2, dtype='f'); I.dtype\ndtype('float32')\n>>> low, high = np.bytebounds(I)\n>>> high - low == I.size*I.itemsize\nTrue\n>>> I = np.eye(2); I.dtype\ndtype('float64')\n>>> low, high = np.bytebounds(I)\n>>> high - low == I.size*I.itemsize\nTrue\n" }, { "name": "can_cast", "content": "cancast(from, to, casting='safe')\n\nReturns True if cast between data types can occur according to the\ncasting rule. If from is a scalar or array scalar, also returns\nTrue if the scalar value can be cast without overflow or truncation\nto an integer.\n\nParameters\n----------\nfrom : dtype, dtype specifier, scalar, or array\nData type, scalar, or array to cast from.\nto : dtype or dtype specifier\nData type to cast to.\ncasting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\nControls what kind of data casting may occur.\n\n* 'no' means the data types should not be cast at all.\n* 'equiv' means only byte-order changes are allowed.\n* 'safe' means only casts which can preserve values are allowed.\n* 'samekind' means only safe casts or casts within a kind,\nlike float64 to float32, are allowed.\n* 'unsafe' means any data conversions may be done.\n\nReturns\n-------\nout : bool\nTrue if cast can occur according to the casting rule.\n\nNotes\n-----\n.. versionchanged:: 1.17.0\nCasting between a simple data type and a structured one is possible only\nfor \"unsafe\" casting. Casting to multiple fields is allowed, but\ncasting from multiple fields is not.\n\n.. versionchanged:: 1.9.0\nCasting from numeric to string types in 'safe' casting mode requires\nthat the string dtype length is long enough to store the maximum\ninteger/float value converted.\n\nSee also\n--------\ndtype, resulttype\n\nExamples\n--------\nBasic examples\n\n>>> np.cancast(np.int32, np.int64)\nTrue\n>>> np.cancast(np.float64, complex)\nTrue\n>>> np.cancast(complex, float)\nFalse\n\n>>> np.cancast('i8', 'f8')\nTrue\n>>> np.cancast('i8', 'f4')\nFalse\n>>> np.cancast('i4', 'S4')\nFalse\n\nCasting scalars\n\n>>> np.cancast(100, 'i1')\nTrue\n>>> np.cancast(150, 'i1')\nFalse\n>>> np.cancast(150, 'u1')\nTrue\n\n>>> np.cancast(3.5e100, np.float32)\nFalse\n>>> np.cancast(1000.0, np.float32)\nTrue\n\nArray scalar checks the value, array does not\n\n>>> np.cancast(np.array(1000.0), np.float32)\nTrue\n>>> np.cancast(np.array([1000.0]), np.float32)\nFalse\n\nUsing the casting rules\n\n>>> np.cancast('i8', 'i8', 'no')\nTrue\n>>> np.cancast('i8', 'no')\nFalse\n\n>>> np.cancast('i8', 'equiv')\nTrue\n>>> np.cancast('i8', 'equiv')\nFalse\n\n>>> np.cancast('i8', 'safe')\nTrue\n>>> np.cancast('i4', 'safe')\nFalse\n\n>>> np.cancast('i4', 'samekind')\nTrue\n>>> np.cancast('u4', 'samekind')\nFalse\n\n>>> np.cancast('u4', 'unsafe')\nTrue\n" }, { "name": "choose", "content": "Construct an array from an index array and a list of arrays to choose from.\n\nFirst of all, if confused or uncertain, definitely look at the Examples -\nin its full generality, this function is less simple than it might\nseem from the following code description (below ndi =\n`numpy.lib.indextricks`):\n\n``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.\n\nBut this omits some subtleties. Here is a fully general summary:\n\nGiven an \"index\" array (`a`) of integers and a sequence of ``n`` arrays\n(`choices`), `a` and each choice array are first broadcast, as necessary,\nto arrays of a common shape; calling these *Ba* and *Bchoices[i], i =\n0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``\nfor each ``i``. Then, a new array with shape ``Ba.shape`` is created as\nfollows:\n\n* if ``mode='raise'`` (the default), then, first of all, each element of\n``a`` (and thus ``Ba``) must be in the range ``[0, n-1]``; now, suppose\nthat ``i`` (in that range) is the value at the ``(j0, j1, ..., jm)``\nposition in ``Ba`` - then the value at the same position in the new array\nis the value in ``Bchoices[i]`` at that same position;\n\n* if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed)\ninteger; modular arithmetic is used to map integers outside the range\n`[0, n-1]` back into that range; and then the new array is constructed\nas above;\n\n* if ``mode='clip'``, values in `a` (and thus ``Ba``) may be any (signed)\ninteger; negative integers are mapped to 0; values greater than ``n-1``\nare mapped to ``n-1``; and then the new array is constructed as above.\n\nParameters\n----------\na : int array\nThis array must contain integers in ``[0, n-1]``, where ``n`` is the\nnumber of choices, unless ``mode=wrap`` or ``mode=clip``, in which\ncases any integers are permissible.\nchoices : sequence of arrays\nChoice arrays. `a` and all of the choices must be broadcastable to the\nsame shape. If `choices` is itself an array (not recommended), then\nits outermost dimension (i.e., the one corresponding to\n``choices.shape[0]``) is taken as defining the \"sequence\".\nout : array, optional\nIf provided, the result will be inserted into this array. It should\nbe of the appropriate shape and dtype. Note that `out` is always\nbuffered if ``mode='raise'``; use other modes for better performance.\nmode : {'raise' (default), 'wrap', 'clip'}, optional\nSpecifies how indices outside ``[0, n-1]`` will be treated:\n\n* 'raise' : an exception is raised\n* 'wrap' : value becomes value mod ``n``\n* 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1\n\nReturns\n-------\nmergedarray : array\nThe merged result.\n\nRaises\n------\nValueError: shape mismatch\nIf `a` and each choice array are not all broadcastable to the same\nshape.\n\nSee Also\n--------\nndarray.choose : equivalent method\nnumpy.takealongaxis : Preferable if `choices` is an array\n\nNotes\n-----\nTo reduce the chance of misinterpretation, even though the following\n\"abuse\" is nominally supported, `choices` should neither be, nor be\nthought of as, a single array, i.e., the outermost sequence-like container\nshould be either a list or a tuple.\n\nExamples\n--------\n\n>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],\n... [20, 21, 22, 23], [30, 31, 32, 33]]\n>>> np.choose([2, 3, 1, 0], choices\n... # the first element of the result will be the first element of the\n... # third (2+1) \"array\" in choices, namely, 20; the second element\n... # will be the second element of the fourth (3+1) choice array, i.e.,\n... # 31, etc.\n... )\narray([20, 31, 12, 3])\n>>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)\narray([20, 31, 12, 3])\n>>> # because there are 4 choice arrays\n>>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)\narray([20, 1, 12, 3])\n>>> # i.e., 0\n\nA couple examples illustrating how choose broadcasts:\n\n>>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]\n>>> choices = [-10, 10]\n>>> np.choose(a, choices)\narray([[ 10, -10, 10],\n[-10, 10, -10],\n[ 10, -10, 10]])\n\n>>> # With thanks to Anne Archibald\n>>> a = np.array([0, 1]).reshape((2,1,1))\n>>> c1 = np.array([1, 2, 3]).reshape((1,3,1))\n>>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))\n>>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2\narray([[[ 1, 1, 1, 1, 1],\n[ 2, 2, 2, 2, 2],\n[ 3, 3, 3, 3, 3]],\n[[-1, -2, -3, -4, -5],\n[-1, -2, -3, -4, -5],\n[-1, -2, -3, -4, -5]]])\n" }, { "name": "clip", "content": "Clip (limit) the values in an array.\n\nGiven an interval, values outside the interval are clipped to\nthe interval edges. For example, if an interval of ``[0, 1]``\nis specified, values smaller than 0 become 0, and values larger\nthan 1 become 1.\n\nEquivalent to but faster than ``np.minimum(amax, np.maximum(a, amin))``.\n\nNo check is performed to ensure ``amin < amax``.\n\nParameters\n----------\na : arraylike\nArray containing elements to clip.\namin, amax : arraylike or None\nMinimum and maximum value. If ``None``, clipping is not performed on\nthe corresponding edge. Only one of `amin` and `amax` may be\n``None``. Both are broadcast against `a`.\nout : ndarray, optional\nThe results will be placed in this array. It may be the input\narray for in-place clipping. `out` must be of the right shape\nto hold the output. Its type is preserved.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\nclippedarray : ndarray\nAn array with the elements of `a`, but where values\n< `amin` are replaced with `amin`, and those > `amax`\nwith `amax`.\n\nSee Also\n--------\n:ref:`ufuncs-output-type`\n\nNotes\n-----\nWhen `amin` is greater than `amax`, `clip` returns an\narray in which all values are equal to `amax`,\nas shown in the second example.\n\nExamples\n--------\n>>> a = np.arange(10)\n>>> a\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> np.clip(a, 1, 8)\narray([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])\n>>> np.clip(a, 8, 1)\narray([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])\n>>> np.clip(a, 3, 6, out=a)\narray([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])\n>>> a\narray([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])\n>>> a = np.arange(10)\n>>> a\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)\narray([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])\n" }, { "name": "column_stack", "content": "Stack 1-D arrays as columns into a 2-D array.\n\nTake a sequence of 1-D arrays and stack them as columns\nto make a single 2-D array. 2-D arrays are stacked as-is,\njust like with `hstack`. 1-D arrays are turned into 2-D columns\nfirst.\n\nParameters\n----------\ntup : sequence of 1-D or 2-D arrays.\nArrays to stack. All of them must have the same first dimension.\n\nReturns\n-------\nstacked : 2-D array\nThe array formed by stacking the given arrays.\n\nSee Also\n--------\nstack, hstack, vstack, concatenate\n\nExamples\n--------\n>>> a = np.array((1,2,3))\n>>> b = np.array((2,3,4))\n>>> np.columnstack((a,b))\narray([[1, 2],\n[2, 3],\n[3, 4]])\n" }, { "name": "common_type", "content": "Return a scalar type which is common to the input arrays.\n\nThe return type will always be an inexact (i.e. floating point) scalar\ntype, even if all the arrays are integer arrays. If one of the inputs is\nan integer array, the minimum precision type that is returned is a\n64-bit floating point dtype.\n\nAll input arrays except int64 and uint64 can be safely cast to the\nreturned dtype without loss of information.\n\nParameters\n----------\narray1, array2, ... : ndarrays\nInput arrays.\n\nReturns\n-------\nout : data type code\nData type code.\n\nSee Also\n--------\ndtype, mintypecode\n\nExamples\n--------\n>>> np.commontype(np.arange(2, dtype=np.float32))\n\n>>> np.commontype(np.arange(2, dtype=np.float32), np.arange(2))\n\n>>> np.commontype(np.arange(4), np.array([45, 6.j]), np.array([45.0]))\n\n" }, { "name": "compare_chararrays", "content": "comparechararrays(a, b, cmpop, rstrip)\n\nPerforms element-wise comparison of two string arrays using the\ncomparison operator specified by `cmpop`.\n\nParameters\n----------\na, b : arraylike\nArrays to be compared.\ncmpop : {\"<\", \"<=\", \"==\", \">=\", \">\", \"!=\"}\nType of comparison.\nrstrip : Boolean\nIf True, the spaces at the end of Strings are removed before the comparison.\n\nReturns\n-------\nout : ndarray\nThe output array of type Boolean with the same shape as a and b.\n\nRaises\n------\nValueError\nIf `cmpop` is not valid.\nTypeError\nIf at least one of `a` or `b` is a non-string array\n\nExamples\n--------\n>>> a = np.array([\"a\", \"b\", \"cde\"])\n>>> b = np.array([\"a\", \"a\", \"dec\"])\n>>> np.comparechararrays(a, b, \">\", True)\narray([False, True, False])\n" }, { "name": "compress", "content": "Return selected slices of an array along given axis.\n\nWhen working along a given axis, a slice along that axis is returned in\n`output` for each index where `condition` evaluates to True. When\nworking on a 1-D array, `compress` is equivalent to `extract`.\n\nParameters\n----------\ncondition : 1-D array of bools\nArray that selects which entries to return. If len(condition)\nis less than the size of `a` along the given axis, then output is\ntruncated to the length of the condition array.\na : arraylike\nArray from which to extract a part.\naxis : int, optional\nAxis along which to take slices. If None (default), work on the\nflattened array.\nout : ndarray, optional\nOutput array. Its type is preserved and it must be of the right\nshape to hold the output.\n\nReturns\n-------\ncompressedarray : ndarray\nA copy of `a` without the slices along axis for which `condition`\nis false.\n\nSee Also\n--------\ntake, choose, diag, diagonal, select\nndarray.compress : Equivalent method in ndarray\nextract : Equivalent method when working on 1-D arrays\n:ref:`ufuncs-output-type`\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, 4], [5, 6]])\n>>> a\narray([[1, 2],\n[3, 4],\n[5, 6]])\n>>> np.compress([0, 1], a, axis=0)\narray([[3, 4]])\n>>> np.compress([False, True, True], a, axis=0)\narray([[3, 4],\n[5, 6]])\n>>> np.compress([False, True], a, axis=1)\narray([[2],\n[4],\n[6]])\n\nWorking on the flattened array does not return slices along an axis but\nselects elements.\n\n>>> np.compress([False, True], a)\narray([2])\n" }, { "name": "concatenate", "content": "concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting=\"samekind\")\n\nJoin a sequence of arrays along an existing axis.\n\nParameters\n----------\na1, a2, ... : sequence of arraylike\nThe arrays must have the same shape, except in the dimension\ncorresponding to `axis` (the first, by default).\naxis : int, optional\nThe axis along which the arrays will be joined. If axis is None,\narrays are flattened before use. Default is 0.\nout : ndarray, optional\nIf provided, the destination to place the result. The shape must be\ncorrect, matching that of what concatenate would have returned if no\nout argument were specified.\ndtype : str or dtype\nIf provided, the destination array will have this dtype. Cannot be\nprovided together with `out`.\n\n.. versionadded:: 1.20.0\n\ncasting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\nControls what kind of data casting may occur. Defaults to 'samekind'.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nres : ndarray\nThe concatenated array.\n\nSee Also\n--------\nma.concatenate : Concatenate function that preserves input masks.\narraysplit : Split an array into multiple sub-arrays of equal or\nnear-equal size.\nsplit : Split array into a list of multiple sub-arrays of equal size.\nhsplit : Split array into multiple sub-arrays horizontally (column wise).\nvsplit : Split array into multiple sub-arrays vertically (row wise).\ndsplit : Split array into multiple sub-arrays along the 3rd axis (depth).\nstack : Stack a sequence of arrays along a new axis.\nblock : Assemble arrays from blocks.\nhstack : Stack arrays in sequence horizontally (column wise).\nvstack : Stack arrays in sequence vertically (row wise).\ndstack : Stack arrays in sequence depth wise (along third dimension).\ncolumnstack : Stack 1-D arrays as columns into a 2-D array.\n\nNotes\n-----\nWhen one or more of the arrays to be concatenated is a MaskedArray,\nthis function will return a MaskedArray object instead of an ndarray,\nbut the input masks are *not* preserved. In cases where a MaskedArray\nis expected as input, use the ma.concatenate function from the masked\narray module instead.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, 4]])\n>>> b = np.array([[5, 6]])\n>>> np.concatenate((a, b), axis=0)\narray([[1, 2],\n[3, 4],\n[5, 6]])\n>>> np.concatenate((a, b.T), axis=1)\narray([[1, 2, 5],\n[3, 4, 6]])\n>>> np.concatenate((a, b), axis=None)\narray([1, 2, 3, 4, 5, 6])\n\nThis function will not preserve masking of MaskedArray inputs.\n\n>>> a = np.ma.arange(3)\n>>> a[1] = np.ma.masked\n>>> b = np.arange(2, 5)\n>>> a\nmaskedarray(data=[0, --, 2],\nmask=[False, True, False],\nfillvalue=999999)\n>>> b\narray([2, 3, 4])\n>>> np.concatenate([a, b])\nmaskedarray(data=[0, 1, 2, 2, 3, 4],\nmask=False,\nfillvalue=999999)\n>>> np.ma.concatenate([a, b])\nmaskedarray(data=[0, --, 2, 2, 3, 4],\nmask=[False, True, False, False, False, False],\nfillvalue=999999)\n" }, { "name": "convolve", "content": "Returns the discrete, linear convolution of two one-dimensional sequences.\n\nThe convolution operator is often seen in signal processing, where it\nmodels the effect of a linear time-invariant system on a signal [1]. In\nprobability theory, the sum of two independent random variables is\ndistributed according to the convolution of their individual\ndistributions.\n\nIf `v` is longer than `a`, the arrays are swapped before computation.\n\nParameters\n----------\na : (N,) arraylike\nFirst one-dimensional input array.\nv : (M,) arraylike\nSecond one-dimensional input array.\nmode : {'full', 'valid', 'same'}, optional\n'full':\nBy default, mode is 'full'. This returns the convolution\nat each point of overlap, with an output shape of (N+M-1,). At\nthe end-points of the convolution, the signals do not overlap\ncompletely, and boundary effects may be seen.\n\n'same':\nMode 'same' returns output of length ``max(M, N)``. Boundary\neffects are still visible.\n\n'valid':\nMode 'valid' returns output of length\n``max(M, N) - min(M, N) + 1``. The convolution product is only given\nfor points where the signals overlap completely. Values outside\nthe signal boundary have no effect.\n\nReturns\n-------\nout : ndarray\nDiscrete, linear convolution of `a` and `v`.\n\nSee Also\n--------\nscipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier\nTransform.\nscipy.linalg.toeplitz : Used to construct the convolution operator.\npolymul : Polynomial multiplication. Same output as convolve, but also\naccepts poly1d objects as input.\n\nNotes\n-----\nThe discrete convolution operation is defined as\n\n.. math:: (a * v)[n] = \\sum{m = -\\infty}^{\\infty} a[m] v[n - m]\n\nIt can be shown that a convolution :math:`x(t) * y(t)` in time/space\nis equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier\ndomain, after appropriate padding (padding is necessary to prevent\ncircular convolution). Since multiplication is more efficient (faster)\nthan convolution, the function `scipy.signal.fftconvolve` exploits the\nFFT to calculate the convolution of large data-sets.\n\nReferences\n----------\n.. [1] Wikipedia, \"Convolution\",\nhttps://en.wikipedia.org/wiki/Convolution\n\nExamples\n--------\nNote how the convolution operator flips the second array\nbefore \"sliding\" the two across one another:\n\n>>> np.convolve([1, 2, 3], [0, 1, 0.5])\narray([0. , 1. , 2.5, 4. , 1.5])\n\nOnly return the middle values of the convolution.\nContains boundary effects, where zeros are taken\ninto account:\n\n>>> np.convolve([1,2,3],[0,1,0.5], 'same')\narray([1. , 2.5, 4. ])\n\nThe two arrays are of the same length, so there\nis only one position where they completely overlap:\n\n>>> np.convolve([1,2,3],[0,1,0.5], 'valid')\narray([2.5])\n" }, { "name": "copy", "content": "Return an array copy of the given object.\n\nParameters\n----------\na : arraylike\nInput data.\norder : {'C', 'F', 'A', 'K'}, optional\nControls the memory layout of the copy. 'C' means C-order,\n'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n'C' otherwise. 'K' means match the layout of `a` as closely\nas possible. (Note that this function and :meth:`ndarray.copy` are very\nsimilar, but have different default values for their order=\narguments.)\nsubok : bool, optional\nIf True, then sub-classes will be passed-through, otherwise the\nreturned array will be forced to be a base-class array (defaults to False).\n\n.. versionadded:: 1.19.0\n\nReturns\n-------\narr : ndarray\nArray interpretation of `a`.\n\nSee Also\n--------\nndarray.copy : Preferred method for creating an array copy\n\nNotes\n-----\nThis is equivalent to:\n\n>>> np.array(a, copy=True) #doctest: +SKIP\n\nExamples\n--------\nCreate an array x, with a reference y and a copy z:\n\n>>> x = np.array([1, 2, 3])\n>>> y = x\n>>> z = np.copy(x)\n\nNote that, when we modify x, y changes, but not z:\n\n>>> x[0] = 10\n>>> x[0] == y[0]\nTrue\n>>> x[0] == z[0]\nFalse\n\nNote that np.copy is a shallow copy and will not copy object\nelements within arrays. This is mainly important for arrays\ncontaining Python objects. The new array will contain the\nsame object which may lead to surprises if that object can\nbe modified (is mutable):\n\n>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)\n>>> b = np.copy(a)\n>>> b[2][0] = 10\n>>> a\narray([1, 'm', list([10, 3, 4])], dtype=object)\n\nTo ensure all elements within an ``object`` array are copied,\nuse `copy.deepcopy`:\n\n>>> import copy\n>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)\n>>> c = copy.deepcopy(a)\n>>> c[2][0] = 10\n>>> c\narray([1, 'm', list([10, 3, 4])], dtype=object)\n>>> a\narray([1, 'm', list([2, 3, 4])], dtype=object)\n" }, { "name": "copyto", "content": "copyto(dst, src, casting='samekind', where=True)\n\nCopies values from one array to another, broadcasting as necessary.\n\nRaises a TypeError if the `casting` rule is violated, and if\n`where` is provided, it selects which elements to copy.\n\n.. versionadded:: 1.7.0\n\nParameters\n----------\ndst : ndarray\nThe array into which values are copied.\nsrc : arraylike\nThe array from which values are copied.\ncasting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\nControls what kind of data casting may occur when copying.\n\n* 'no' means the data types should not be cast at all.\n* 'equiv' means only byte-order changes are allowed.\n* 'safe' means only casts which can preserve values are allowed.\n* 'samekind' means only safe casts or casts within a kind,\nlike float64 to float32, are allowed.\n* 'unsafe' means any data conversions may be done.\nwhere : arraylike of bool, optional\nA boolean array which is broadcasted to match the dimensions\nof `dst`, and selects elements to copy from `src` to `dst`\nwherever it contains the value True.\n" }, { "name": "corrcoef", "content": "Return Pearson product-moment correlation coefficients.\n\nPlease refer to the documentation for `cov` for more detail. The\nrelationship between the correlation coefficient matrix, `R`, and the\ncovariance matrix, `C`, is\n\n.. math:: R{ij} = \\frac{ C{ij} } { \\sqrt{ C{ii} * C{jj} } }\n\nThe values of `R` are between -1 and 1, inclusive.\n\nParameters\n----------\nx : arraylike\nA 1-D or 2-D array containing multiple variables and observations.\nEach row of `x` represents a variable, and each column a single\nobservation of all those variables. Also see `rowvar` below.\ny : arraylike, optional\nAn additional set of variables and observations. `y` has the same\nshape as `x`.\nrowvar : bool, optional\nIf `rowvar` is True (default), then each row represents a\nvariable, with observations in the columns. Otherwise, the relationship\nis transposed: each column represents a variable, while the rows\ncontain observations.\nbias : NoValue, optional\nHas no effect, do not use.\n\n.. deprecated:: 1.10.0\nddof : NoValue, optional\nHas no effect, do not use.\n\n.. deprecated:: 1.10.0\ndtype : data-type, optional\nData-type of the result. By default, the return data-type will have\nat least `numpy.float64` precision.\n\n.. versionadded:: 1.20\n\nReturns\n-------\nR : ndarray\nThe correlation coefficient matrix of the variables.\n\nSee Also\n--------\ncov : Covariance matrix\n\nNotes\n-----\nDue to floating point rounding the resulting array may not be Hermitian,\nthe diagonal elements may not be 1, and the elements may not satisfy the\ninequality abs(a) <= 1. The real and imaginary parts are clipped to the\ninterval [-1, 1] in an attempt to improve on that situation but is not\nmuch help in the complex case.\n\nThis function accepts but discards arguments `bias` and `ddof`. This is\nfor backwards compatibility with previous versions of this function. These\narguments had no effect on the return values of the function and can be\nsafely ignored in this and previous versions of numpy.\n\nExamples\n--------\nIn this example we generate two random arrays, ``xarr`` and ``yarr``, and\ncompute the row-wise and column-wise Pearson correlation coefficients,\n``R``. Since ``rowvar`` is true by default, we first find the row-wise\nPearson correlation coefficients between the variables of ``xarr``.\n\n>>> import numpy as np\n>>> rng = np.random.defaultrng(seed=42)\n>>> xarr = rng.random((3, 3))\n>>> xarr\narray([[0.77395605, 0.43887844, 0.85859792],\n[0.69736803, 0.09417735, 0.97562235],\n[0.7611397 , 0.78606431, 0.12811363]])\n>>> R1 = np.corrcoef(xarr)\n>>> R1\narray([[ 1. , 0.99256089, -0.68080986],\n[ 0.99256089, 1. , -0.76492172],\n[-0.68080986, -0.76492172, 1. ]])\n\nIf we add another set of variables and observations ``yarr``, we can\ncompute the row-wise Pearson correlation coefficients between the\nvariables in ``xarr`` and ``yarr``.\n\n>>> yarr = rng.random((3, 3))\n>>> yarr\narray([[0.45038594, 0.37079802, 0.92676499],\n[0.64386512, 0.82276161, 0.4434142 ],\n[0.22723872, 0.55458479, 0.06381726]])\n>>> R2 = np.corrcoef(xarr, yarr)\n>>> R2\narray([[ 1. , 0.99256089, -0.68080986, 0.75008178, -0.934284 ,\n-0.99004057],\n[ 0.99256089, 1. , -0.76492172, 0.82502011, -0.97074098,\n-0.99981569],\n[-0.68080986, -0.76492172, 1. , -0.99507202, 0.89721355,\n0.77714685],\n[ 0.75008178, 0.82502011, -0.99507202, 1. , -0.93657855,\n-0.83571711],\n[-0.934284 , -0.97074098, 0.89721355, -0.93657855, 1. ,\n0.97517215],\n[-0.99004057, -0.99981569, 0.77714685, -0.83571711, 0.97517215,\n1. ]])\n\nFinally if we use the option ``rowvar=False``, the columns are now\nbeing treated as the variables and we will find the column-wise Pearson\ncorrelation coefficients between variables in ``xarr`` and ``yarr``.\n\n>>> R3 = np.corrcoef(xarr, yarr, rowvar=False)\n>>> R3\narray([[ 1. , 0.77598074, -0.47458546, -0.75078643, -0.9665554 ,\n0.22423734],\n[ 0.77598074, 1. , -0.92346708, -0.99923895, -0.58826587,\n-0.44069024],\n[-0.47458546, -0.92346708, 1. , 0.93773029, 0.23297648,\n0.75137473],\n[-0.75078643, -0.99923895, 0.93773029, 1. , 0.55627469,\n0.47536961],\n[-0.9665554 , -0.58826587, 0.23297648, 0.55627469, 1. ,\n-0.46666491],\n[ 0.22423734, -0.44069024, 0.75137473, 0.47536961, -0.46666491,\n1. ]])\n" }, { "name": "correlate", "content": "Cross-correlation of two 1-dimensional sequences.\n\nThis function computes the correlation as generally defined in signal\nprocessing texts::\n\nc{av}[k] = sumn a[n+k] * conj(v[n])\n\nwith a and v sequences being zero-padded where necessary and conj being\nthe conjugate.\n\nParameters\n----------\na, v : arraylike\nInput sequences.\nmode : {'valid', 'same', 'full'}, optional\nRefer to the `convolve` docstring. Note that the default\nis 'valid', unlike `convolve`, which uses 'full'.\noldbehavior : bool\n`oldbehavior` was removed in NumPy 1.10. If you need the old\nbehavior, use `multiarray.correlate`.\n\nReturns\n-------\nout : ndarray\nDiscrete cross-correlation of `a` and `v`.\n\nSee Also\n--------\nconvolve : Discrete, linear convolution of two one-dimensional sequences.\nmultiarray.correlate : Old, no conjugate, version of correlate.\nscipy.signal.correlate : uses FFT which has superior performance on large arrays.\n\nNotes\n-----\nThe definition of correlation above is not unique and sometimes correlation\nmay be defined differently. Another common definition is::\n\nc'{av}[k] = sumn a[n] conj(v[n+k])\n\nwhich is related to ``c{av}[k]`` by ``c'{av}[k] = c{av}[-k]``.\n\n`numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5) because it does\nnot use the FFT to compute the convolution; in that case, `scipy.signal.correlate` might\nbe preferable.\n\n\nExamples\n--------\n>>> np.correlate([1, 2, 3], [0, 1, 0.5])\narray([3.5])\n>>> np.correlate([1, 2, 3], [0, 1, 0.5], \"same\")\narray([2. , 3.5, 3. ])\n>>> np.correlate([1, 2, 3], [0, 1, 0.5], \"full\")\narray([0.5, 2. , 3.5, 3. , 0. ])\n\nUsing complex sequences:\n\n>>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')\narray([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])\n\nNote that you get the time reversed, complex conjugated result\nwhen the two input sequences change places, i.e.,\n``c{va}[k] = c^{*}{av}[-k]``:\n\n>>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')\narray([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])\n" }, { "name": "count_nonzero", "content": "Counts the number of non-zero values in the array ``a``.\n\nThe word \"non-zero\" is in reference to the Python 2.x\nbuilt-in method ``nonzero()`` (renamed ``bool()``\nin Python 3.x) of Python objects that tests an object's\n\"truthfulness\". For example, any number is considered\ntruthful if it is nonzero, whereas any string is considered\ntruthful if it is not the empty string. Thus, this function\n(recursively) counts how many elements in ``a`` (and in\nsub-arrays thereof) have their ``nonzero()`` or ``bool()``\nmethod evaluated to ``True``.\n\nParameters\n----------\na : arraylike\nThe array for which to count non-zeros.\naxis : int or tuple, optional\nAxis or tuple of axes along which to count non-zeros.\nDefault is None, meaning that non-zeros will be counted\nalong a flattened version of ``a``.\n\n.. versionadded:: 1.12.0\n\nkeepdims : bool, optional\nIf this is set to True, the axes that are counted are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\n.. versionadded:: 1.19.0\n\nReturns\n-------\ncount : int or array of int\nNumber of non-zero values in the array along a given axis.\nOtherwise, the total number of non-zero values in the array\nis returned.\n\nSee Also\n--------\nnonzero : Return the coordinates of all the non-zero values.\n\nExamples\n--------\n>>> np.countnonzero(np.eye(4))\n4\n>>> a = np.array([[0, 1, 7, 0],\n... [3, 0, 2, 19]])\n>>> np.countnonzero(a)\n5\n>>> np.countnonzero(a, axis=0)\narray([1, 1, 2, 1])\n>>> np.countnonzero(a, axis=1)\narray([2, 3])\n>>> np.countnonzero(a, axis=1, keepdims=True)\narray([[2],\n[3]])\n" }, { "name": "cov", "content": "Estimate a covariance matrix, given data and weights.\n\nCovariance indicates the level to which two variables vary together.\nIf we examine N-dimensional samples, :math:`X = [x1, x2, ... xN]^T`,\nthen the covariance matrix element :math:`C{ij}` is the covariance of\n:math:`xi` and :math:`xj`. The element :math:`C{ii}` is the variance\nof :math:`xi`.\n\nSee the notes for an outline of the algorithm.\n\nParameters\n----------\nm : arraylike\nA 1-D or 2-D array containing multiple variables and observations.\nEach row of `m` represents a variable, and each column a single\nobservation of all those variables. Also see `rowvar` below.\ny : arraylike, optional\nAn additional set of variables and observations. `y` has the same form\nas that of `m`.\nrowvar : bool, optional\nIf `rowvar` is True (default), then each row represents a\nvariable, with observations in the columns. Otherwise, the relationship\nis transposed: each column represents a variable, while the rows\ncontain observations.\nbias : bool, optional\nDefault normalization (False) is by ``(N - 1)``, where ``N`` is the\nnumber of observations given (unbiased estimate). If `bias` is True,\nthen normalization is by ``N``. These values can be overridden by using\nthe keyword ``ddof`` in numpy versions >= 1.5.\nddof : int, optional\nIf not ``None`` the default value implied by `bias` is overridden.\nNote that ``ddof=1`` will return the unbiased estimate, even if both\n`fweights` and `aweights` are specified, and ``ddof=0`` will return\nthe simple average. See the notes for the details. The default value\nis ``None``.\n\n.. versionadded:: 1.5\nfweights : arraylike, int, optional\n1-D array of integer frequency weights; the number of times each\nobservation vector should be repeated.\n\n.. versionadded:: 1.10\naweights : arraylike, optional\n1-D array of observation vector weights. These relative weights are\ntypically large for observations considered \"important\" and smaller for\nobservations considered less \"important\". If ``ddof=0`` the array of\nweights can be used to assign probabilities to observation vectors.\n\n.. versionadded:: 1.10\ndtype : data-type, optional\nData-type of the result. By default, the return data-type will have\nat least `numpy.float64` precision.\n\n.. versionadded:: 1.20\n\nReturns\n-------\nout : ndarray\nThe covariance matrix of the variables.\n\nSee Also\n--------\ncorrcoef : Normalized covariance matrix\n\nNotes\n-----\nAssume that the observations are in the columns of the observation\narray `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The\nsteps to compute the weighted covariance are as follows::\n\n>>> m = np.arange(10, dtype=np.float64)\n>>> f = np.arange(10) * 2\n>>> a = np.arange(10) 2.\n>>> ddof = 1\n>>> w = f * a\n>>> v1 = np.sum(w)\n>>> v2 = np.sum(w * a)\n>>> m -= np.sum(m * w, axis=None, keepdims=True) / v1\n>>> cov = np.dot(m * w, m.T) * v1 / (v12 - ddof * v2)\n\nNote that when ``a == 1``, the normalization factor\n``v1 / (v12 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``\nas it should.\n\nExamples\n--------\nConsider two variables, :math:`x0` and :math:`x1`, which\ncorrelate perfectly, but in opposite directions:\n\n>>> x = np.array([[0, 2], [1, 1], [2, 0]]).T\n>>> x\narray([[0, 1, 2],\n[2, 1, 0]])\n\nNote how :math:`x0` increases while :math:`x1` decreases. The covariance\nmatrix shows this clearly:\n\n>>> np.cov(x)\narray([[ 1., -1.],\n[-1., 1.]])\n\nNote that element :math:`C{0,1}`, which shows the correlation between\n:math:`x0` and :math:`x1`, is negative.\n\nFurther, note how `x` and `y` are combined:\n\n>>> x = [-2.1, -1, 4.3]\n>>> y = [3, 1.1, 0.12]\n>>> X = np.stack((x, y), axis=0)\n>>> np.cov(X)\narray([[11.71 , -4.286 ], # may vary\n[-4.286 , 2.144133]])\n>>> np.cov(x, y)\narray([[11.71 , -4.286 ], # may vary\n[-4.286 , 2.144133]])\n>>> np.cov(x)\narray(11.71)\n" }, { "name": "cross", "content": "Return the cross product of two (arrays of) vectors.\n\nThe cross product of `a` and `b` in :math:`R^3` is a vector perpendicular\nto both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors\nare defined by the last axis of `a` and `b` by default, and these axes\ncan have dimensions 2 or 3. Where the dimension of either `a` or `b` is\n2, the third component of the input vector is assumed to be zero and the\ncross product calculated accordingly. In cases where both input vectors\nhave dimension 2, the z-component of the cross product is returned.\n\nParameters\n----------\na : arraylike\nComponents of the first vector(s).\nb : arraylike\nComponents of the second vector(s).\naxisa : int, optional\nAxis of `a` that defines the vector(s). By default, the last axis.\naxisb : int, optional\nAxis of `b` that defines the vector(s). By default, the last axis.\naxisc : int, optional\nAxis of `c` containing the cross product vector(s). Ignored if\nboth input vectors have dimension 2, as the return is scalar.\nBy default, the last axis.\naxis : int, optional\nIf defined, the axis of `a`, `b` and `c` that defines the vector(s)\nand cross product(s). Overrides `axisa`, `axisb` and `axisc`.\n\nReturns\n-------\nc : ndarray\nVector cross product(s).\n\nRaises\n------\nValueError\nWhen the dimension of the vector(s) in `a` and/or `b` does not\nequal 2 or 3.\n\nSee Also\n--------\ninner : Inner product\nouter : Outer product.\nix : Construct index arrays.\n\nNotes\n-----\n.. versionadded:: 1.9.0\n\nSupports full broadcasting of the inputs.\n\nExamples\n--------\nVector cross-product.\n\n>>> x = [1, 2, 3]\n>>> y = [4, 5, 6]\n>>> np.cross(x, y)\narray([-3, 6, -3])\n\nOne vector with dimension 2.\n\n>>> x = [1, 2]\n>>> y = [4, 5, 6]\n>>> np.cross(x, y)\narray([12, -6, -3])\n\nEquivalently:\n\n>>> x = [1, 2, 0]\n>>> y = [4, 5, 6]\n>>> np.cross(x, y)\narray([12, -6, -3])\n\nBoth vectors with dimension 2.\n\n>>> x = [1,2]\n>>> y = [4,5]\n>>> np.cross(x, y)\narray(-3)\n\nMultiple vector cross-products. Note that the direction of the cross\nproduct vector is defined by the `right-hand rule`.\n\n>>> x = np.array([[1,2,3], [4,5,6]])\n>>> y = np.array([[4,5,6], [1,2,3]])\n>>> np.cross(x, y)\narray([[-3, 6, -3],\n[ 3, -6, 3]])\n\nThe orientation of `c` can be changed using the `axisc` keyword.\n\n>>> np.cross(x, y, axisc=0)\narray([[-3, 3],\n[ 6, -6],\n[-3, 3]])\n\nChange the vector definition of `x` and `y` using `axisa` and `axisb`.\n\n>>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])\n>>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])\n>>> np.cross(x, y)\narray([[ -6, 12, -6],\n[ 0, 0, 0],\n[ 6, -12, 6]])\n>>> np.cross(x, y, axisa=0, axisb=0)\narray([[-24, 48, -24],\n[-30, 60, -30],\n[-36, 72, -36]])\n" }, { "name": "cumprod", "content": "Return the cumulative product of elements along a given axis.\n\nParameters\n----------\na : arraylike\nInput array.\naxis : int, optional\nAxis along which the cumulative product is computed. By default\nthe input is flattened.\ndtype : dtype, optional\nType of the returned array, as well as of the accumulator in which\nthe elements are multiplied. If *dtype* is not specified, it\ndefaults to the dtype of `a`, unless `a` has an integer dtype with\na precision less than that of the default platform integer. In\nthat case, the default platform integer is used instead.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output\nbut the type of the resulting values will be cast if necessary.\n\nReturns\n-------\ncumprod : ndarray\nA new array holding the result is returned unless `out` is\nspecified, in which case a reference to out is returned.\n\nSee Also\n--------\n:ref:`ufuncs-output-type`\n\nNotes\n-----\nArithmetic is modular when using integer types, and no error is\nraised on overflow.\n\nExamples\n--------\n>>> a = np.array([1,2,3])\n>>> np.cumprod(a) # intermediate results 1, 1*2\n... # total product 1*2*3 = 6\narray([1, 2, 6])\n>>> a = np.array([[1, 2, 3], [4, 5, 6]])\n>>> np.cumprod(a, dtype=float) # specify type of output\narray([ 1., 2., 6., 24., 120., 720.])\n\nThe cumulative product for each column (i.e., over the rows) of `a`:\n\n>>> np.cumprod(a, axis=0)\narray([[ 1, 2, 3],\n[ 4, 10, 18]])\n\nThe cumulative product for each row (i.e. over the columns) of `a`:\n\n>>> np.cumprod(a,axis=1)\narray([[ 1, 2, 6],\n[ 4, 20, 120]])\n" }, { "name": "cumproduct", "content": "Return the cumulative product over the given axis.\n\nSee Also\n--------\ncumprod : equivalent function; see for details.\n" }, { "name": "cumsum", "content": "Return the cumulative sum of the elements along a given axis.\n\nParameters\n----------\na : arraylike\nInput array.\naxis : int, optional\nAxis along which the cumulative sum is computed. The default\n(None) is to compute the cumsum over the flattened array.\ndtype : dtype, optional\nType of the returned array and of the accumulator in which the\nelements are summed. If `dtype` is not specified, it defaults\nto the dtype of `a`, unless `a` has an integer dtype with a\nprecision less than that of the default platform integer. In\nthat case, the default platform integer is used.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output\nbut the type will be cast if necessary. See :ref:`ufuncs-output-type` for\nmore details.\n\nReturns\n-------\ncumsumalongaxis : ndarray.\nA new array holding the result is returned unless `out` is\nspecified, in which case a reference to `out` is returned. The\nresult has the same size as `a`, and the same shape as `a` if\n`axis` is not None or `a` is a 1-d array.\n\nSee Also\n--------\nsum : Sum array elements.\ntrapz : Integration of array values using the composite trapezoidal rule.\ndiff : Calculate the n-th discrete difference along given axis.\n\nNotes\n-----\nArithmetic is modular when using integer types, and no error is\nraised on overflow.\n\n``cumsum(a)[-1]`` may not be equal to ``sum(a)`` for floating-point\nvalues since ``sum`` may use a pairwise summation routine, reducing\nthe roundoff-error. See `sum` for more information.\n\nExamples\n--------\n>>> a = np.array([[1,2,3], [4,5,6]])\n>>> a\narray([[1, 2, 3],\n[4, 5, 6]])\n>>> np.cumsum(a)\narray([ 1, 3, 6, 10, 15, 21])\n>>> np.cumsum(a, dtype=float) # specifies type of output value(s)\narray([ 1., 3., 6., 10., 15., 21.])\n\n>>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns\narray([[1, 2, 3],\n[5, 7, 9]])\n>>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows\narray([[ 1, 3, 6],\n[ 4, 9, 15]])\n\n``cumsum(b)[-1]`` may not be equal to ``sum(b)``\n\n>>> b = np.array([1, 2e-9, 3e-9] * 1000000)\n>>> b.cumsum()[-1]\n1000000.0050045159\n>>> b.sum()\n1000000.0050000029\n" }, { "name": "datetime_as_string", "content": "datetimeasstring(arr, unit=None, timezone='naive', casting='samekind')\n\nConvert an array of datetimes into an array of strings.\n\nParameters\n----------\narr : arraylike of datetime64\nThe array of UTC timestamps to format.\nunit : str\nOne of None, 'auto', or a :ref:`datetime unit `.\ntimezone : {'naive', 'UTC', 'local'} or tzinfo\nTimezone information to use when displaying the datetime. If 'UTC', end\nwith a Z to indicate UTC time. If 'local', convert to the local timezone\nfirst, and suffix with a +-#### timezone offset. If a tzinfo object,\nthen do as with 'local', but use the specified timezone.\ncasting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}\nCasting to allow when changing between datetime units.\n\nReturns\n-------\nstrarr : ndarray\nAn array of strings the same shape as `arr`.\n\nExamples\n--------\n>>> import pytz\n>>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')\n>>> d\narray(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',\n'2002-10-27T07:30'], dtype='datetime64[m]')\n\nSetting the timezone to UTC shows the same information, but with a Z suffix\n\n>>> np.datetimeasstring(d, timezone='UTC')\narray(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',\n'2002-10-27T07:30Z'], dtype='>> np.datetimeasstring(d, timezone=pytz.timezone('US/Eastern'))\narray(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',\n'2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='>> np.datetimeasstring(d, unit='h')\narray(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],\ndtype='>> np.datetimeasstring(d, unit='s')\narray(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',\n'2002-10-27T07:30:00'], dtype='>> np.datetimeasstring(d, unit='h', casting='safe')\nTraceback (most recent call last):\n...\nTypeError: Cannot create a datetime string as units 'h' from a NumPy\ndatetime with units 'm' according to the rule 'safe'\n" }, { "name": "datetime_data", "content": "datetimedata(dtype, /)\n\nGet information about the step size of a date or time type.\n\nThe returned tuple can be passed as the second argument of `numpy.datetime64` and\n`numpy.timedelta64`.\n\nParameters\n----------\ndtype : dtype\nThe dtype object, which must be a `datetime64` or `timedelta64` type.\n\nReturns\n-------\nunit : str\nThe :ref:`datetime unit ` on which this dtype\nis based.\ncount : int\nThe number of base units in a step.\n\nExamples\n--------\n>>> dt25s = np.dtype('timedelta64[25s]')\n>>> np.datetimedata(dt25s)\n('s', 25)\n>>> np.array(10, dt25s).astype('timedelta64[s]')\narray(250, dtype='timedelta64[s]')\n\nThe result can be used to construct a datetime that uses the same units\nas a timedelta\n\n>>> np.datetime64('2010', np.datetimedata(dt25s))\nnumpy.datetime64('2010-01-01T00:00:00','25s')\n" }, { "name": "delete", "content": "Return a new array with sub-arrays along an axis deleted. For a one\ndimensional array, this returns those entries not returned by\n`arr[obj]`.\n\nParameters\n----------\narr : arraylike\nInput array.\nobj : slice, int or array of ints\nIndicate indices of sub-arrays to remove along the specified axis.\n\n.. versionchanged:: 1.19.0\nBoolean indices are now treated as a mask of elements to remove,\nrather than being cast to the integers 0 and 1.\n\naxis : int, optional\nThe axis along which to delete the subarray defined by `obj`.\nIf `axis` is None, `obj` is applied to the flattened array.\n\nReturns\n-------\nout : ndarray\nA copy of `arr` with the elements specified by `obj` removed. Note\nthat `delete` does not occur in-place. If `axis` is None, `out` is\na flattened array.\n\nSee Also\n--------\ninsert : Insert elements into an array.\nappend : Append elements at the end of an array.\n\nNotes\n-----\nOften it is preferable to use a boolean mask. For example:\n\n>>> arr = np.arange(12) + 1\n>>> mask = np.ones(len(arr), dtype=bool)\n>>> mask[[0,2,4]] = False\n>>> result = arr[mask,...]\n\nIs equivalent to `np.delete(arr, [0,2,4], axis=0)`, but allows further\nuse of `mask`.\n\nExamples\n--------\n>>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n>>> arr\narray([[ 1, 2, 3, 4],\n[ 5, 6, 7, 8],\n[ 9, 10, 11, 12]])\n>>> np.delete(arr, 1, 0)\narray([[ 1, 2, 3, 4],\n[ 9, 10, 11, 12]])\n\n>>> np.delete(arr, np.s[::2], 1)\narray([[ 2, 4],\n[ 6, 8],\n[10, 12]])\n>>> np.delete(arr, [1,3,5], None)\narray([ 1, 3, 5, 7, 8, 9, 10, 11, 12])\n" }, { "name": "deprecate", "content": "Issues a DeprecationWarning, adds warning to `oldname`'s\ndocstring, rebinds ``oldname.name`` and returns the new\nfunction object.\n\nThis function may also be used as a decorator.\n\nParameters\n----------\nfunc : function\nThe function to be deprecated.\noldname : str, optional\nThe name of the function to be deprecated. Default is None, in\nwhich case the name of `func` is used.\nnewname : str, optional\nThe new name for the function. Default is None, in which case the\ndeprecation message is that `oldname` is deprecated. If given, the\ndeprecation message is that `oldname` is deprecated and `newname`\nshould be used instead.\nmessage : str, optional\nAdditional explanation of the deprecation. Displayed in the\ndocstring after the warning.\n\nReturns\n-------\noldfunc : function\nThe deprecated function.\n\nExamples\n--------\nNote that ``olduint`` returns a value after printing Deprecation\nWarning:\n\n>>> olduint = np.deprecate(np.uint)\nDeprecationWarning: `uint64` is deprecated! # may vary\n>>> olduint(6)\n6\n" }, { "name": "deprecate_with_doc", "content": "Deprecates a function and includes the deprecation in its docstring.\n\nThis function is used as a decorator. It returns an object that can be\nused to issue a DeprecationWarning, by passing the to-be decorated\nfunction as argument, this adds warning to the to-be decorated function's\ndocstring and returns the new function object.\n\nSee Also\n--------\ndeprecate : Decorate a function such that it issues a `DeprecationWarning`\n\nParameters\n----------\nmsg : str\nAdditional explanation of the deprecation. Displayed in the\ndocstring after the warning.\n\nReturns\n-------\nobj : object\n" }, { "name": "diag", "content": "Extract a diagonal or construct a diagonal array.\n\nSee the more detailed documentation for ``numpy.diagonal`` if you use this\nfunction to extract a diagonal and wish to write to the resulting array;\nwhether it returns a copy or a view depends on what version of numpy you\nare using.\n\nParameters\n----------\nv : arraylike\nIf `v` is a 2-D array, return a copy of its `k`-th diagonal.\nIf `v` is a 1-D array, return a 2-D array with `v` on the `k`-th\ndiagonal.\nk : int, optional\nDiagonal in question. The default is 0. Use `k>0` for diagonals\nabove the main diagonal, and `k<0` for diagonals below the main\ndiagonal.\n\nReturns\n-------\nout : ndarray\nThe extracted diagonal or constructed diagonal array.\n\nSee Also\n--------\ndiagonal : Return specified diagonals.\ndiagflat : Create a 2-D array with the flattened input as a diagonal.\ntrace : Sum along diagonals.\ntriu : Upper triangle of an array.\ntril : Lower triangle of an array.\n\nExamples\n--------\n>>> x = np.arange(9).reshape((3,3))\n>>> x\narray([[0, 1, 2],\n[3, 4, 5],\n[6, 7, 8]])\n\n>>> np.diag(x)\narray([0, 4, 8])\n>>> np.diag(x, k=1)\narray([1, 5])\n>>> np.diag(x, k=-1)\narray([3, 7])\n\n>>> np.diag(np.diag(x))\narray([[0, 0, 0],\n[0, 4, 0],\n[0, 0, 8]])\n" }, { "name": "diag_indices", "content": "Return the indices to access the main diagonal of an array.\n\nThis returns a tuple of indices that can be used to access the main\ndiagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape\n(n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for\n``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``\nfor ``i = [0..n-1]``.\n\nParameters\n----------\nn : int\nThe size, along each dimension, of the arrays for which the returned\nindices can be used.\n\nndim : int, optional\nThe number of dimensions.\n\nSee Also\n--------\ndiagindicesfrom\n\nNotes\n-----\n.. versionadded:: 1.4.0\n\nExamples\n--------\nCreate a set of indices to access the diagonal of a (4, 4) array:\n\n>>> di = np.diagindices(4)\n>>> di\n(array([0, 1, 2, 3]), array([0, 1, 2, 3]))\n>>> a = np.arange(16).reshape(4, 4)\n>>> a\narray([[ 0, 1, 2, 3],\n[ 4, 5, 6, 7],\n[ 8, 9, 10, 11],\n[12, 13, 14, 15]])\n>>> a[di] = 100\n>>> a\narray([[100, 1, 2, 3],\n[ 4, 100, 6, 7],\n[ 8, 9, 100, 11],\n[ 12, 13, 14, 100]])\n\nNow, we create indices to manipulate a 3-D array:\n\n>>> d3 = np.diagindices(2, 3)\n>>> d3\n(array([0, 1]), array([0, 1]), array([0, 1]))\n\nAnd use it to set the diagonal of an array of zeros to 1:\n\n>>> a = np.zeros((2, 2, 2), dtype=int)\n>>> a[d3] = 1\n>>> a\narray([[[1, 0],\n[0, 0]],\n[[0, 0],\n[0, 1]]])\n" }, { "name": "diag_indices_from", "content": "Return the indices to access the main diagonal of an n-dimensional array.\n\nSee `diagindices` for full details.\n\nParameters\n----------\narr : array, at least 2-D\n\nSee Also\n--------\ndiagindices\n\nNotes\n-----\n.. versionadded:: 1.4.0\n" }, { "name": "diagflat", "content": "Create a two-dimensional array with the flattened input as a diagonal.\n\nParameters\n----------\nv : arraylike\nInput data, which is flattened and set as the `k`-th\ndiagonal of the output.\nk : int, optional\nDiagonal to set; 0, the default, corresponds to the \"main\" diagonal,\na positive (negative) `k` giving the number of the diagonal above\n(below) the main.\n\nReturns\n-------\nout : ndarray\nThe 2-D output array.\n\nSee Also\n--------\ndiag : MATLAB work-alike for 1-D and 2-D arrays.\ndiagonal : Return specified diagonals.\ntrace : Sum along diagonals.\n\nExamples\n--------\n>>> np.diagflat([[1,2], [3,4]])\narray([[1, 0, 0, 0],\n[0, 2, 0, 0],\n[0, 0, 3, 0],\n[0, 0, 0, 4]])\n\n>>> np.diagflat([1,2], 1)\narray([[0, 1, 0],\n[0, 0, 2],\n[0, 0, 0]])\n" }, { "name": "diagonal", "content": "Return specified diagonals.\n\nIf `a` is 2-D, returns the diagonal of `a` with the given offset,\ni.e., the collection of elements of the form ``a[i, i+offset]``. If\n`a` has more than two dimensions, then the axes specified by `axis1`\nand `axis2` are used to determine the 2-D sub-array whose diagonal is\nreturned. The shape of the resulting array can be determined by\nremoving `axis1` and `axis2` and appending an index to the right equal\nto the size of the resulting diagonals.\n\nIn versions of NumPy prior to 1.7, this function always returned a new,\nindependent array containing a copy of the values in the diagonal.\n\nIn NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,\nbut depending on this fact is deprecated. Writing to the resulting\narray continues to work as it used to, but a FutureWarning is issued.\n\nStarting in NumPy 1.9 it returns a read-only view on the original array.\nAttempting to write to the resulting array will produce an error.\n\nIn some future release, it will return a read/write view and writing to\nthe returned array will alter your original array. The returned array\nwill have the same type as the input array.\n\nIf you don't write to the array returned by this function, then you can\njust ignore all of the above.\n\nIf you depend on the current behavior, then we suggest copying the\nreturned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead\nof just ``np.diagonal(a)``. This will work with both past and future\nversions of NumPy.\n\nParameters\n----------\na : arraylike\nArray from which the diagonals are taken.\noffset : int, optional\nOffset of the diagonal from the main diagonal. Can be positive or\nnegative. Defaults to main diagonal (0).\naxis1 : int, optional\nAxis to be used as the first axis of the 2-D sub-arrays from which\nthe diagonals should be taken. Defaults to first axis (0).\naxis2 : int, optional\nAxis to be used as the second axis of the 2-D sub-arrays from\nwhich the diagonals should be taken. Defaults to second axis (1).\n\nReturns\n-------\narrayofdiagonals : ndarray\nIf `a` is 2-D, then a 1-D array containing the diagonal and of the\nsame type as `a` is returned unless `a` is a `matrix`, in which case\na 1-D array rather than a (2-D) `matrix` is returned in order to\nmaintain backward compatibility.\n\nIf ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2`\nare removed, and a new axis inserted at the end corresponding to the\ndiagonal.\n\nRaises\n------\nValueError\nIf the dimension of `a` is less than 2.\n\nSee Also\n--------\ndiag : MATLAB work-a-like for 1-D and 2-D arrays.\ndiagflat : Create diagonal arrays.\ntrace : Sum along diagonals.\n\nExamples\n--------\n>>> a = np.arange(4).reshape(2,2)\n>>> a\narray([[0, 1],\n[2, 3]])\n>>> a.diagonal()\narray([0, 3])\n>>> a.diagonal(1)\narray([1])\n\nA 3-D example:\n\n>>> a = np.arange(8).reshape(2,2,2); a\narray([[[0, 1],\n[2, 3]],\n[[4, 5],\n[6, 7]]])\n>>> a.diagonal(0, # Main diagonals of two arrays created by skipping\n... 0, # across the outer(left)-most axis last and\n... 1) # the \"middle\" (row) axis first.\narray([[0, 6],\n[1, 7]])\n\nThe sub-arrays whose main diagonals we just obtained; note that each\ncorresponds to fixing the right-most (column) axis, and that the\ndiagonals are \"packed\" in rows.\n\n>>> a[:,:,0] # main diagonal is [0 6]\narray([[0, 2],\n[4, 6]])\n>>> a[:,:,1] # main diagonal is [1 7]\narray([[1, 3],\n[5, 7]])\n\nThe anti-diagonal can be obtained by reversing the order of elements\nusing either `numpy.flipud` or `numpy.fliplr`.\n\n>>> a = np.arange(9).reshape(3, 3)\n>>> a\narray([[0, 1, 2],\n[3, 4, 5],\n[6, 7, 8]])\n>>> np.fliplr(a).diagonal() # Horizontal flip\narray([2, 4, 6])\n>>> np.flipud(a).diagonal() # Vertical flip\narray([6, 4, 2])\n\nNote that the order in which the diagonal is retrieved varies depending\non the flip function.\n" }, { "name": "diff", "content": "Calculate the n-th discrete difference along the given axis.\n\nThe first difference is given by ``out[i] = a[i+1] - a[i]`` along\nthe given axis, higher differences are calculated by using `diff`\nrecursively.\n\nParameters\n----------\na : arraylike\nInput array\nn : int, optional\nThe number of times values are differenced. If zero, the input\nis returned as-is.\naxis : int, optional\nThe axis along which the difference is taken, default is the\nlast axis.\nprepend, append : arraylike, optional\nValues to prepend or append to `a` along axis prior to\nperforming the difference. Scalar values are expanded to\narrays with length 1 in the direction of axis and the shape\nof the input array in along all other axes. Otherwise the\ndimension and shape must match `a` except along axis.\n\n.. versionadded:: 1.16.0\n\nReturns\n-------\ndiff : ndarray\nThe n-th differences. The shape of the output is the same as `a`\nexcept along `axis` where the dimension is smaller by `n`. The\ntype of the output is the same as the type of the difference\nbetween any two elements of `a`. This is the same as the type of\n`a` in most cases. A notable exception is `datetime64`, which\nresults in a `timedelta64` output array.\n\nSee Also\n--------\ngradient, ediff1d, cumsum\n\nNotes\n-----\nType is preserved for boolean arrays, so the result will contain\n`False` when consecutive elements are the same and `True` when they\ndiffer.\n\nFor unsigned integer arrays, the results will also be unsigned. This\nshould not be surprising, as the result is consistent with\ncalculating the difference directly:\n\n>>> u8arr = np.array([1, 0], dtype=np.uint8)\n>>> np.diff(u8arr)\narray([255], dtype=uint8)\n>>> u8arr[1,...] - u8arr[0,...]\n255\n\nIf this is not desirable, then the array should be cast to a larger\ninteger type first:\n\n>>> i16arr = u8arr.astype(np.int16)\n>>> np.diff(i16arr)\narray([-1], dtype=int16)\n\nExamples\n--------\n>>> x = np.array([1, 2, 4, 7, 0])\n>>> np.diff(x)\narray([ 1, 2, 3, -7])\n>>> np.diff(x, n=2)\narray([ 1, 1, -10])\n\n>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])\n>>> np.diff(x)\narray([[2, 3, 4],\n[5, 1, 2]])\n>>> np.diff(x, axis=0)\narray([[-1, 2, 0, -2]])\n\n>>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)\n>>> np.diff(x)\narray([1, 1], dtype='timedelta64[D]')\n" }, { "name": "digitize", "content": "Return the indices of the bins to which each value in input array belongs.\n\n========= ============= ============================\n`right` order of bins returned index `i` satisfies\n========= ============= ============================\n``False`` increasing ``bins[i-1] <= x < bins[i]``\n``True`` increasing ``bins[i-1] < x <= bins[i]``\n``False`` decreasing ``bins[i-1] > x >= bins[i]``\n``True`` decreasing ``bins[i-1] >= x > bins[i]``\n========= ============= ============================\n\nIf values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is\nreturned as appropriate.\n\nParameters\n----------\nx : arraylike\nInput array to be binned. Prior to NumPy 1.10.0, this array had to\nbe 1-dimensional, but can now have any shape.\nbins : arraylike\nArray of bins. It has to be 1-dimensional and monotonic.\nright : bool, optional\nIndicating whether the intervals include the right or the left bin\nedge. Default behavior is (right==False) indicating that the interval\ndoes not include the right edge. The left bin end is open in this\ncase, i.e., bins[i-1] <= x < bins[i] is the default behavior for\nmonotonically increasing bins.\n\nReturns\n-------\nindices : ndarray of ints\nOutput array of indices, of same shape as `x`.\n\nRaises\n------\nValueError\nIf `bins` is not monotonic.\nTypeError\nIf the type of the input is complex.\n\nSee Also\n--------\nbincount, histogram, unique, searchsorted\n\nNotes\n-----\nIf values in `x` are such that they fall outside the bin range,\nattempting to index `bins` with the indices that `digitize` returns\nwill result in an IndexError.\n\n.. versionadded:: 1.10.0\n\n`np.digitize` is implemented in terms of `np.searchsorted`. This means\nthat a binary search is used to bin the values, which scales much better\nfor larger number of bins than the previous linear search. It also removes\nthe requirement for the input array to be 1-dimensional.\n\nFor monotonically increasing `bins`, the following are equivalent::\n\nnp.digitize(x, bins, right=True)\nnp.searchsorted(bins, x, side='left')\n\nNote that as the order of the arguments are reversed, the side must be too.\nThe `searchsorted` call is marginally faster, as it does not do any\nmonotonicity checks. Perhaps more importantly, it supports all dtypes.\n\nExamples\n--------\n>>> x = np.array([0.2, 6.4, 3.0, 1.6])\n>>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])\n>>> inds = np.digitize(x, bins)\n>>> inds\narray([1, 4, 3, 2])\n>>> for n in range(x.size):\n... print(bins[inds[n]-1], \"<=\", x[n], \"<\", bins[inds[n]])\n...\n0.0 <= 0.2 < 1.0\n4.0 <= 6.4 < 10.0\n2.5 <= 3.0 < 4.0\n1.0 <= 1.6 < 2.5\n\n>>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.])\n>>> bins = np.array([0, 5, 10, 15, 20])\n>>> np.digitize(x,bins,right=True)\narray([1, 2, 3, 4, 4])\n>>> np.digitize(x,bins,right=False)\narray([1, 3, 3, 4, 5])\n" }, { "name": "disp", "content": "Display a message on a device.\n\nParameters\n----------\nmesg : str\nMessage to display.\ndevice : object\nDevice to write message. If None, defaults to ``sys.stdout`` which is\nvery similar to ``print``. `device` needs to have ``write()`` and\n``flush()`` methods.\nlinefeed : bool, optional\nOption whether to print a line feed or not. Defaults to True.\n\nRaises\n------\nAttributeError\nIf `device` does not have a ``write()`` or ``flush()`` method.\n\nExamples\n--------\nBesides ``sys.stdout``, a file-like object can also be used as it has\nboth required methods:\n\n>>> from io import StringIO\n>>> buf = StringIO()\n>>> np.disp(u'\"Display\" in a file', device=buf)\n>>> buf.getvalue()\n'\"Display\" in a file\\n'\n" }, { "name": "dot", "content": "dot(a, b, out=None)\n\nDot product of two arrays. Specifically,\n\n- If both `a` and `b` are 1-D arrays, it is inner product of vectors\n(without complex conjugation).\n\n- If both `a` and `b` are 2-D arrays, it is matrix multiplication,\nbut using :func:`matmul` or ``a @ b`` is preferred.\n\n- If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`\nand using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.\n\n- If `a` is an N-D array and `b` is a 1-D array, it is a sum product over\nthe last axis of `a` and `b`.\n\n- If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a\nsum product over the last axis of `a` and the second-to-last axis of `b`::\n\ndot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])\n\nParameters\n----------\na : arraylike\nFirst argument.\nb : arraylike\nSecond argument.\nout : ndarray, optional\nOutput argument. This must have the exact kind that would be returned\nif it was not used. In particular, it must have the right type, must be\nC-contiguous, and its dtype must be the dtype that would be returned\nfor `dot(a,b)`. This is a performance feature. Therefore, if these\nconditions are not met, an exception is raised, instead of attempting\nto be flexible.\n\nReturns\n-------\noutput : ndarray\nReturns the dot product of `a` and `b`. If `a` and `b` are both\nscalars or both 1-D arrays then a scalar is returned; otherwise\nan array is returned.\nIf `out` is given, then it is returned.\n\nRaises\n------\nValueError\nIf the last dimension of `a` is not the same size as\nthe second-to-last dimension of `b`.\n\nSee Also\n--------\nvdot : Complex-conjugating dot product.\ntensordot : Sum products over arbitrary axes.\neinsum : Einstein summation convention.\nmatmul : '@' operator as method with out parameter.\nlinalg.multidot : Chained dot product.\n\nExamples\n--------\n>>> np.dot(3, 4)\n12\n\nNeither argument is complex-conjugated:\n\n>>> np.dot([2j, 3j], [2j, 3j])\n(-13+0j)\n\nFor 2-D arrays it is the matrix product:\n\n>>> a = [[1, 0], [0, 1]]\n>>> b = [[4, 1], [2, 2]]\n>>> np.dot(a, b)\narray([[4, 1],\n[2, 2]])\n\n>>> a = np.arange(3*4*5*6).reshape((3,4,5,6))\n>>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))\n>>> np.dot(a, b)[2,3,2,1,2,2]\n499128\n>>> sum(a[2,3,2,:] * b[1,2,:,2])\n499128\n" }, { "name": "dsplit", "content": "Split array into multiple sub-arrays along the 3rd axis (depth).\n\nPlease refer to the `split` documentation. `dsplit` is equivalent\nto `split` with ``axis=2``, the array is always split along the third\naxis provided the array dimension is greater than or equal to 3.\n\nSee Also\n--------\nsplit : Split an array into multiple sub-arrays of equal size.\n\nExamples\n--------\n>>> x = np.arange(16.0).reshape(2, 2, 4)\n>>> x\narray([[[ 0., 1., 2., 3.],\n[ 4., 5., 6., 7.]],\n[[ 8., 9., 10., 11.],\n[12., 13., 14., 15.]]])\n>>> np.dsplit(x, 2)\n[array([[[ 0., 1.],\n[ 4., 5.]],\n[[ 8., 9.],\n[12., 13.]]]), array([[[ 2., 3.],\n[ 6., 7.]],\n[[10., 11.],\n[14., 15.]]])]\n>>> np.dsplit(x, np.array([3, 6]))\n[array([[[ 0., 1., 2.],\n[ 4., 5., 6.]],\n[[ 8., 9., 10.],\n[12., 13., 14.]]]),\narray([[[ 3.],\n[ 7.]],\n[[11.],\n[15.]]]),\narray([], shape=(2, 2, 0), dtype=float64)]\n" }, { "name": "dstack", "content": "Stack arrays in sequence depth wise (along third axis).\n\nThis is equivalent to concatenation along the third axis after 2-D arrays\nof shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape\n`(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by\n`dsplit`.\n\nThis function makes most sense for arrays with up to 3 dimensions. For\ninstance, for pixel-data with a height (first axis), width (second axis),\nand r/g/b channels (third axis). The functions `concatenate`, `stack` and\n`block` provide more general stacking and concatenation operations.\n\nParameters\n----------\ntup : sequence of arrays\nThe arrays must have the same shape along all but the third axis.\n1-D or 2-D arrays must have the same shape.\n\nReturns\n-------\nstacked : ndarray\nThe array formed by stacking the given arrays, will be at least 3-D.\n\nSee Also\n--------\nconcatenate : Join a sequence of arrays along an existing axis.\nstack : Join a sequence of arrays along a new axis.\nblock : Assemble an nd-array from nested lists of blocks.\nvstack : Stack arrays in sequence vertically (row wise).\nhstack : Stack arrays in sequence horizontally (column wise).\ncolumnstack : Stack 1-D arrays as columns into a 2-D array.\ndsplit : Split array along third axis.\n\nExamples\n--------\n>>> a = np.array((1,2,3))\n>>> b = np.array((2,3,4))\n>>> np.dstack((a,b))\narray([[[1, 2],\n[2, 3],\n[3, 4]]])\n\n>>> a = np.array([[1],[2],[3]])\n>>> b = np.array([[2],[3],[4]])\n>>> np.dstack((a,b))\narray([[[1, 2]],\n[[2, 3]],\n[[3, 4]]])\n" }, { "name": "ediff1d", "content": "The differences between consecutive elements of an array.\n\nParameters\n----------\nary : arraylike\nIf necessary, will be flattened before the differences are taken.\ntoend : arraylike, optional\nNumber(s) to append at the end of the returned differences.\ntobegin : arraylike, optional\nNumber(s) to prepend at the beginning of the returned differences.\n\nReturns\n-------\nediff1d : ndarray\nThe differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.\n\nSee Also\n--------\ndiff, gradient\n\nNotes\n-----\nWhen applied to masked arrays, this function drops the mask information\nif the `tobegin` and/or `toend` parameters are used.\n\nExamples\n--------\n>>> x = np.array([1, 2, 4, 7, 0])\n>>> np.ediff1d(x)\narray([ 1, 2, 3, -7])\n\n>>> np.ediff1d(x, tobegin=-99, toend=np.array([88, 99]))\narray([-99, 1, 2, ..., -7, 88, 99])\n\nThe returned array is always 1D.\n\n>>> y = [[1, 2, 4], [1, 6, 24]]\n>>> np.ediff1d(y)\narray([ 1, 2, -3, 5, 18])\n" }, { "name": "einsum", "content": "einsum(subscripts, *operands, out=None, dtype=None, order='K',\ncasting='safe', optimize=False)\n\nEvaluates the Einstein summation convention on the operands.\n\nUsing the Einstein summation convention, many common multi-dimensional,\nlinear algebraic array operations can be represented in a simple fashion.\nIn *implicit* mode `einsum` computes these values.\n\nIn *explicit* mode, `einsum` provides further flexibility to compute\nother array operations that might not be considered classical Einstein\nsummation operations, by disabling, or forcing summation over specified\nsubscript labels.\n\nSee the notes and examples for clarification.\n\nParameters\n----------\nsubscripts : str\nSpecifies the subscripts for summation as comma separated list of\nsubscript labels. An implicit (classical Einstein summation)\ncalculation is performed unless the explicit indicator '->' is\nincluded as well as subscript labels of the precise output form.\noperands : list of arraylike\nThese are the arrays for the operation.\nout : ndarray, optional\nIf provided, the calculation is done into this array.\ndtype : {data-type, None}, optional\nIf provided, forces the calculation to use the data type specified.\nNote that you may have to also give a more liberal `casting`\nparameter to allow the conversions. Default is None.\norder : {'C', 'F', 'A', 'K'}, optional\nControls the memory layout of the output. 'C' means it should\nbe C contiguous. 'F' means it should be Fortran contiguous,\n'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.\n'K' means it should be as close to the layout as the inputs as\nis possible, including arbitrarily permuted axes.\nDefault is 'K'.\ncasting : {'no', 'equiv', 'safe', 'samekind', 'unsafe'}, optional\nControls what kind of data casting may occur. Setting this to\n'unsafe' is not recommended, as it can adversely affect accumulations.\n\n* 'no' means the data types should not be cast at all.\n* 'equiv' means only byte-order changes are allowed.\n* 'safe' means only casts which can preserve values are allowed.\n* 'samekind' means only safe casts or casts within a kind,\nlike float64 to float32, are allowed.\n* 'unsafe' means any data conversions may be done.\n\nDefault is 'safe'.\noptimize : {False, True, 'greedy', 'optimal'}, optional\nControls if intermediate optimization should occur. No optimization\nwill occur if False and True will default to the 'greedy' algorithm.\nAlso accepts an explicit contraction list from the ``np.einsumpath``\nfunction. See ``np.einsumpath`` for more details. Defaults to False.\n\nReturns\n-------\noutput : ndarray\nThe calculation based on the Einstein summation convention.\n\nSee Also\n--------\neinsumpath, dot, inner, outer, tensordot, linalg.multidot\neinops :\nsimilar verbose interface is provided by\n`einops ` package to cover\nadditional operations: transpose, reshape/flatten, repeat/tile,\nsqueeze/unsqueeze and reductions.\nopteinsum :\n`opteinsum `\noptimizes contraction order for einsum-like expressions\nin backend-agnostic manner.\n\nNotes\n-----\n.. versionadded:: 1.6.0\n\nThe Einstein summation convention can be used to compute\nmany multi-dimensional, linear algebraic array operations. `einsum`\nprovides a succinct way of representing these.\n\nA non-exhaustive list of these operations,\nwhich can be computed by `einsum`, is shown below along with examples:\n\n* Trace of an array, :py:func:`numpy.trace`.\n* Return a diagonal, :py:func:`numpy.diag`.\n* Array axis summations, :py:func:`numpy.sum`.\n* Transpositions and permutations, :py:func:`numpy.transpose`.\n* Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`.\n* Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`.\n* Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`.\n* Tensor contractions, :py:func:`numpy.tensordot`.\n* Chained array operations, in efficient calculation order, :py:func:`numpy.einsumpath`.\n\nThe subscripts string is a comma-separated list of subscript labels,\nwhere each label refers to a dimension of the corresponding operand.\nWhenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)``\nis equivalent to :py:func:`np.inner(a,b) `. If a label\nappears only once, it is not summed, so ``np.einsum('i', a)`` produces a\nview of ``a`` with no changes. A further example ``np.einsum('ij,jk', a, b)``\ndescribes traditional matrix multiplication and is equivalent to\n:py:func:`np.matmul(a,b) `. Repeated subscript labels in one\noperand take the diagonal. For example, ``np.einsum('ii', a)`` is equivalent\nto :py:func:`np.trace(a) `.\n\nIn *implicit mode*, the chosen subscripts are important\nsince the axes of the output are reordered alphabetically. This\nmeans that ``np.einsum('ij', a)`` doesn't affect a 2D array, while\n``np.einsum('ji', a)`` takes its transpose. Additionally,\n``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while,\n``np.einsum('ij,jh', a, b)`` returns the transpose of the\nmultiplication since subscript 'h' precedes subscript 'i'.\n\nIn *explicit mode* the output can be directly controlled by\nspecifying output subscript labels. This requires the\nidentifier '->' as well as the list of output subscript labels.\nThis feature increases the flexibility of the function since\nsumming can be disabled or forced when required. The call\n``np.einsum('i->', a)`` is like :py:func:`np.sum(a, axis=-1) `,\nand ``np.einsum('ii->i', a)`` is like :py:func:`np.diag(a) `.\nThe difference is that `einsum` does not allow broadcasting by default.\nAdditionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the\norder of the output subscript labels and therefore returns matrix\nmultiplication, unlike the example above in implicit mode.\n\nTo enable and control broadcasting, use an ellipsis. Default\nNumPy-style broadcasting is done by adding an ellipsis\nto the left of each term, like ``np.einsum('...ii->...i', a)``.\nTo take the trace along the first and last axes,\nyou can do ``np.einsum('i...i', a)``, or to do a matrix-matrix\nproduct with the left-most indices instead of rightmost, one can do\n``np.einsum('ij...,jk...->ik...', a, b)``.\n\nWhen there is only one operand, no axes are summed, and no output\nparameter is provided, a view into the operand is returned instead\nof a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)``\nproduces a view (changed in version 1.10.0).\n\n`einsum` also provides an alternative way to provide the subscripts\nand operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``.\nIf the output shape is not provided in this format `einsum` will be\ncalculated in implicit mode, otherwise it will be performed explicitly.\nThe examples below have corresponding `einsum` calls with the two\nparameter methods.\n\n.. versionadded:: 1.10.0\n\nViews returned from einsum are now writeable whenever the input array\nis writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now\nhave the same effect as :py:func:`np.swapaxes(a, 0, 2) `\nand ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal\nof a 2D array.\n\n.. versionadded:: 1.12.0\n\nAdded the ``optimize`` argument which will optimize the contraction order\nof an einsum expression. For a contraction with three or more operands this\ncan greatly increase the computational efficiency at the cost of a larger\nmemory footprint during computation.\n\nTypically a 'greedy' algorithm is applied which empirical tests have shown\nreturns the optimal path in the majority of cases. In some cases 'optimal'\nwill return the superlative path through a more expensive, exhaustive search.\nFor iterative calculations it may be advisable to calculate the optimal path\nonce and reuse that path by supplying it as an argument. An example is given\nbelow.\n\nSee :py:func:`numpy.einsumpath` for more details.\n\nExamples\n--------\n>>> a = np.arange(25).reshape(5,5)\n>>> b = np.arange(5)\n>>> c = np.arange(6).reshape(2,3)\n\nTrace of a matrix:\n\n>>> np.einsum('ii', a)\n60\n>>> np.einsum(a, [0,0])\n60\n>>> np.trace(a)\n60\n\nExtract the diagonal (requires explicit form):\n\n>>> np.einsum('ii->i', a)\narray([ 0, 6, 12, 18, 24])\n>>> np.einsum(a, [0,0], [0])\narray([ 0, 6, 12, 18, 24])\n>>> np.diag(a)\narray([ 0, 6, 12, 18, 24])\n\nSum over an axis (requires explicit form):\n\n>>> np.einsum('ij->i', a)\narray([ 10, 35, 60, 85, 110])\n>>> np.einsum(a, [0,1], [0])\narray([ 10, 35, 60, 85, 110])\n>>> np.sum(a, axis=1)\narray([ 10, 35, 60, 85, 110])\n\nFor higher dimensional arrays summing a single axis can be done with ellipsis:\n\n>>> np.einsum('...j->...', a)\narray([ 10, 35, 60, 85, 110])\n>>> np.einsum(a, [Ellipsis,1], [Ellipsis])\narray([ 10, 35, 60, 85, 110])\n\nCompute a matrix transpose, or reorder any number of axes:\n\n>>> np.einsum('ji', c)\narray([[0, 3],\n[1, 4],\n[2, 5]])\n>>> np.einsum('ij->ji', c)\narray([[0, 3],\n[1, 4],\n[2, 5]])\n>>> np.einsum(c, [1,0])\narray([[0, 3],\n[1, 4],\n[2, 5]])\n>>> np.transpose(c)\narray([[0, 3],\n[1, 4],\n[2, 5]])\n\nVector inner products:\n\n>>> np.einsum('i,i', b, b)\n30\n>>> np.einsum(b, [0], b, [0])\n30\n>>> np.inner(b,b)\n30\n\nMatrix vector multiplication:\n\n>>> np.einsum('ij,j', a, b)\narray([ 30, 80, 130, 180, 230])\n>>> np.einsum(a, [0,1], b, [1])\narray([ 30, 80, 130, 180, 230])\n>>> np.dot(a, b)\narray([ 30, 80, 130, 180, 230])\n>>> np.einsum('...j,j', a, b)\narray([ 30, 80, 130, 180, 230])\n\nBroadcasting and scalar multiplication:\n\n>>> np.einsum('..., ...', 3, c)\narray([[ 0, 3, 6],\n[ 9, 12, 15]])\n>>> np.einsum(',ij', 3, c)\narray([[ 0, 3, 6],\n[ 9, 12, 15]])\n>>> np.einsum(3, [Ellipsis], c, [Ellipsis])\narray([[ 0, 3, 6],\n[ 9, 12, 15]])\n>>> np.multiply(3, c)\narray([[ 0, 3, 6],\n[ 9, 12, 15]])\n\nVector outer product:\n\n>>> np.einsum('i,j', np.arange(2)+1, b)\narray([[0, 1, 2, 3, 4],\n[0, 2, 4, 6, 8]])\n>>> np.einsum(np.arange(2)+1, [0], b, [1])\narray([[0, 1, 2, 3, 4],\n[0, 2, 4, 6, 8]])\n>>> np.outer(np.arange(2)+1, b)\narray([[0, 1, 2, 3, 4],\n[0, 2, 4, 6, 8]])\n\nTensor contraction:\n\n>>> a = np.arange(60.).reshape(3,4,5)\n>>> b = np.arange(24.).reshape(4,3,2)\n>>> np.einsum('ijk,jil->kl', a, b)\narray([[4400., 4730.],\n[4532., 4874.],\n[4664., 5018.],\n[4796., 5162.],\n[4928., 5306.]])\n>>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])\narray([[4400., 4730.],\n[4532., 4874.],\n[4664., 5018.],\n[4796., 5162.],\n[4928., 5306.]])\n>>> np.tensordot(a,b, axes=([1,0],[0,1]))\narray([[4400., 4730.],\n[4532., 4874.],\n[4664., 5018.],\n[4796., 5162.],\n[4928., 5306.]])\n\nWriteable returned arrays (since version 1.10.0):\n\n>>> a = np.zeros((3, 3))\n>>> np.einsum('ii->i', a)[:] = 1\n>>> a\narray([[1., 0., 0.],\n[0., 1., 0.],\n[0., 0., 1.]])\n\nExample of ellipsis use:\n\n>>> a = np.arange(6).reshape((3,2))\n>>> b = np.arange(12).reshape((4,3))\n>>> np.einsum('ki,jk->ij', a, b)\narray([[10, 28, 46, 64],\n[13, 40, 67, 94]])\n>>> np.einsum('ki,...k->i...', a, b)\narray([[10, 28, 46, 64],\n[13, 40, 67, 94]])\n>>> np.einsum('k...,jk', a, b)\narray([[10, 28, 46, 64],\n[13, 40, 67, 94]])\n\nChained array operations. For more complicated contractions, speed ups\nmight be achieved by repeatedly computing a 'greedy' path or pre-computing the\n'optimal' path and repeatedly applying it, using an\n`einsumpath` insertion (since version 1.12.0). Performance improvements can be\nparticularly significant with larger arrays:\n\n>>> a = np.ones(64).reshape(2,4,8)\n\nBasic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.)\n\n>>> for iteration in range(500):\n... = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)\n\nSub-optimal `einsum` (due to repeated path calculation time): ~330ms\n\n>>> for iteration in range(500):\n... = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')\n\nGreedy `einsum` (faster optimal path approximation): ~160ms\n\n>>> for iteration in range(500):\n... = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')\n\nOptimal `einsum` (best usage pattern in some use cases): ~110ms\n\n>>> path = np.einsumpath('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0]\n>>> for iteration in range(500):\n... = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)\n" }, { "name": "einsum_path", "content": "einsumpath(subscripts, *operands, optimize='greedy')\n\nEvaluates the lowest cost contraction order for an einsum expression by\nconsidering the creation of intermediate arrays.\n\nParameters\n----------\nsubscripts : str\nSpecifies the subscripts for summation.\n*operands : list of arraylike\nThese are the arrays for the operation.\noptimize : {bool, list, tuple, 'greedy', 'optimal'}\nChoose the type of path. If a tuple is provided, the second argument is\nassumed to be the maximum intermediate size created. If only a single\nargument is provided the largest input or output array size is used\nas a maximum intermediate size.\n\n* if a list is given that starts with ``einsumpath``, uses this as the\ncontraction path\n* if False no optimization is taken\n* if True defaults to the 'greedy' algorithm\n* 'optimal' An algorithm that combinatorially explores all possible\nways of contracting the listed tensors and choosest the least costly\npath. Scales exponentially with the number of terms in the\ncontraction.\n* 'greedy' An algorithm that chooses the best pair contraction\nat each step. Effectively, this algorithm searches the largest inner,\nHadamard, and then outer products at each step. Scales cubically with\nthe number of terms in the contraction. Equivalent to the 'optimal'\npath for most contractions.\n\nDefault is 'greedy'.\n\nReturns\n-------\npath : list of tuples\nA list representation of the einsum path.\nstringrepr : str\nA printable representation of the einsum path.\n\nNotes\n-----\nThe resulting path indicates which terms of the input contraction should be\ncontracted first, the result of this contraction is then appended to the\nend of the contraction list. This list can then be iterated over until all\nintermediate contractions are complete.\n\nSee Also\n--------\neinsum, linalg.multidot\n\nExamples\n--------\n\nWe can begin with a chain dot example. In this case, it is optimal to\ncontract the ``b`` and ``c`` tensors first as represented by the first\nelement of the path ``(1, 2)``. The resulting tensor is added to the end\nof the contraction and the remaining contraction ``(0, 1)`` is then\ncompleted.\n\n>>> np.random.seed(123)\n>>> a = np.random.rand(2, 2)\n>>> b = np.random.rand(2, 5)\n>>> c = np.random.rand(5, 2)\n>>> pathinfo = np.einsumpath('ij,jk,kl->il', a, b, c, optimize='greedy')\n>>> print(pathinfo[0])\n['einsumpath', (1, 2), (0, 1)]\n>>> print(pathinfo[1])\nComplete contraction: ij,jk,kl->il # may vary\nNaive scaling: 4\nOptimized scaling: 3\nNaive FLOP count: 1.600e+02\nOptimized FLOP count: 5.600e+01\nTheoretical speedup: 2.857\nLargest intermediate: 4.000e+00 elements\n-------------------------------------------------------------------------\nscaling current remaining\n-------------------------------------------------------------------------\n3 kl,jk->jl ij,jl->il\n3 jl,ij->il il->il\n\n\nA more complex index transformation example.\n\n>>> I = np.random.rand(10, 10, 10, 10)\n>>> C = np.random.rand(10, 10)\n>>> pathinfo = np.einsumpath('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,\n... optimize='greedy')\n\n>>> print(pathinfo[0])\n['einsumpath', (0, 2), (0, 3), (0, 2), (0, 1)]\n>>> print(pathinfo[1])\nComplete contraction: ea,fb,abcd,gc,hd->efgh # may vary\nNaive scaling: 8\nOptimized scaling: 5\nNaive FLOP count: 8.000e+08\nOptimized FLOP count: 8.000e+05\nTheoretical speedup: 1000.000\nLargest intermediate: 1.000e+04 elements\n--------------------------------------------------------------------------\nscaling current remaining\n--------------------------------------------------------------------------\n5 abcd,ea->bcde fb,gc,hd,bcde->efgh\n5 bcde,fb->cdef gc,hd,cdef->efgh\n5 cdef,gc->defg hd,defg->efgh\n5 defg,hd->efgh efgh->efgh\n" }, { "name": "empty", "content": "empty(shape, dtype=float, order='C', *, like=None)\n\nReturn a new array of given shape and type, without initializing entries.\n\nParameters\n----------\nshape : int or tuple of int\nShape of the empty array, e.g., ``(2, 3)`` or ``2``.\ndtype : data-type, optional\nDesired output data-type for the array, e.g, `numpy.int8`. Default is\n`numpy.float64`.\norder : {'C', 'F'}, optional, default: 'C'\nWhether to store multi-dimensional data in row-major\n(C-style) or column-major (Fortran-style) order in\nmemory.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nArray of uninitialized (arbitrary) data of the given shape, dtype, and\norder. Object arrays will be initialized to None.\n\nSee Also\n--------\nemptylike : Return an empty array with shape and type of input.\nones : Return a new array setting values to one.\nzeros : Return a new array setting values to zero.\nfull : Return a new array of given shape filled with value.\n\n\nNotes\n-----\n`empty`, unlike `zeros`, does not set the array values to zero,\nand may therefore be marginally faster. On the other hand, it requires\nthe user to manually set all the values in the array, and should be\nused with caution.\n\nExamples\n--------\n>>> np.empty([2, 2])\narray([[ -9.74499359e+001, 6.69583040e-309],\n[ 2.13182611e-314, 3.06959433e-309]]) #uninitialized\n\n>>> np.empty([2, 2], dtype=int)\narray([[-1073741821, -1067949133],\n[ 496041986, 19249760]]) #uninitialized\n" }, { "name": "empty_like", "content": "emptylike(prototype, dtype=None, order='K', subok=True, shape=None)\n\nReturn a new array with the same shape and type as a given array.\n\nParameters\n----------\nprototype : arraylike\nThe shape and data-type of `prototype` define these same attributes\nof the returned array.\ndtype : data-type, optional\nOverrides the data type of the result.\n\n.. versionadded:: 1.6.0\norder : {'C', 'F', 'A', or 'K'}, optional\nOverrides the memory layout of the result. 'C' means C-order,\n'F' means F-order, 'A' means 'F' if `prototype` is Fortran\ncontiguous, 'C' otherwise. 'K' means match the layout of `prototype`\nas closely as possible.\n\n.. versionadded:: 1.6.0\nsubok : bool, optional.\nIf True, then the newly created array will use the sub-class\ntype of `prototype`, otherwise it will be a base-class array. Defaults\nto True.\nshape : int or sequence of ints, optional.\nOverrides the shape of the result. If order='K' and the number of\ndimensions is unchanged, will try to keep order, otherwise,\norder='C' is implied.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\nout : ndarray\nArray of uninitialized (arbitrary) data with the same\nshape and type as `prototype`.\n\nSee Also\n--------\noneslike : Return an array of ones with shape and type of input.\nzeroslike : Return an array of zeros with shape and type of input.\nfulllike : Return a new array with shape of input filled with value.\nempty : Return a new uninitialized array.\n\nNotes\n-----\nThis function does *not* initialize the returned array; to do that use\n`zeroslike` or `oneslike` instead. It may be marginally faster than\nthe functions that do set the array values.\n\nExamples\n--------\n>>> a = ([1,2,3], [4,5,6]) # a is array-like\n>>> np.emptylike(a)\narray([[-1073741821, -1073741821, 3], # uninitialized\n[ 0, 0, -1073741821]])\n>>> a = np.array([[1., 2., 3.],[4.,5.,6.]])\n>>> np.emptylike(a)\narray([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], # uninitialized\n[ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]])\n" }, { "name": "expand_dims", "content": "Expand the shape of an array.\n\nInsert a new axis that will appear at the `axis` position in the expanded\narray shape.\n\nParameters\n----------\na : arraylike\nInput array.\naxis : int or tuple of ints\nPosition in the expanded axes where the new axis (or axes) is placed.\n\n.. deprecated:: 1.13.0\nPassing an axis where ``axis > a.ndim`` will be treated as\n``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will\nbe treated as ``axis == 0``. This behavior is deprecated.\n\n.. versionchanged:: 1.18.0\nA tuple of axes is now supported. Out of range axes as\ndescribed above are now forbidden and raise an `AxisError`.\n\nReturns\n-------\nresult : ndarray\nView of `a` with the number of dimensions increased.\n\nSee Also\n--------\nsqueeze : The inverse operation, removing singleton dimensions\nreshape : Insert, remove, and combine dimensions, and resize existing ones\ndoc.indexing, atleast1d, atleast2d, atleast3d\n\nExamples\n--------\n>>> x = np.array([1, 2])\n>>> x.shape\n(2,)\n\nThe following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:\n\n>>> y = np.expanddims(x, axis=0)\n>>> y\narray([[1, 2]])\n>>> y.shape\n(1, 2)\n\nThe following is equivalent to ``x[:, np.newaxis]``:\n\n>>> y = np.expanddims(x, axis=1)\n>>> y\narray([[1],\n[2]])\n>>> y.shape\n(2, 1)\n\n``axis`` may also be a tuple:\n\n>>> y = np.expanddims(x, axis=(0, 1))\n>>> y\narray([[[1, 2]]])\n\n>>> y = np.expanddims(x, axis=(2, 0))\n>>> y\narray([[[1],\n[2]]])\n\nNote that some examples may use ``None`` instead of ``np.newaxis``. These\nare the same objects:\n\n>>> np.newaxis is None\nTrue\n" }, { "name": "extract", "content": "Return the elements of an array that satisfy some condition.\n\nThis is equivalent to ``np.compress(ravel(condition), ravel(arr))``. If\n`condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``.\n\nNote that `place` does the exact opposite of `extract`.\n\nParameters\n----------\ncondition : arraylike\nAn array whose nonzero or True entries indicate the elements of `arr`\nto extract.\narr : arraylike\nInput array of the same size as `condition`.\n\nReturns\n-------\nextract : ndarray\nRank 1 array of values from `arr` where `condition` is True.\n\nSee Also\n--------\ntake, put, copyto, compress, place\n\nExamples\n--------\n>>> arr = np.arange(12).reshape((3, 4))\n>>> arr\narray([[ 0, 1, 2, 3],\n[ 4, 5, 6, 7],\n[ 8, 9, 10, 11]])\n>>> condition = np.mod(arr, 3)==0\n>>> condition\narray([[ True, False, False, True],\n[False, False, True, False],\n[False, True, False, False]])\n>>> np.extract(condition, arr)\narray([0, 3, 6, 9])\n\n\nIf `condition` is boolean:\n\n>>> arr[condition]\narray([0, 3, 6, 9])\n" }, { "name": "eye", "content": "Return a 2-D array with ones on the diagonal and zeros elsewhere.\n\nParameters\n----------\nN : int\nNumber of rows in the output.\nM : int, optional\nNumber of columns in the output. If None, defaults to `N`.\nk : int, optional\nIndex of the diagonal: 0 (the default) refers to the main diagonal,\na positive value refers to an upper diagonal, and a negative value\nto a lower diagonal.\ndtype : data-type, optional\nData-type of the returned array.\norder : {'C', 'F'}, optional\nWhether the output should be stored in row-major (C-style) or\ncolumn-major (Fortran-style) order in memory.\n\n.. versionadded:: 1.14.0\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nI : ndarray of shape (N,M)\nAn array where all elements are equal to zero, except for the `k`-th\ndiagonal, whose values are equal to one.\n\nSee Also\n--------\nidentity : (almost) equivalent function\ndiag : diagonal 2-D array from a 1-D array specified by the user.\n\nExamples\n--------\n>>> np.eye(2, dtype=int)\narray([[1, 0],\n[0, 1]])\n>>> np.eye(3, k=1)\narray([[0., 1., 0.],\n[0., 0., 1.],\n[0., 0., 0.]])\n\nfastCopyAndTranspose = fastCopyAndTranspose(...)\nfastCopyAndTranspose(a)\n" }, { "name": "fill_diagonal", "content": "Fill the main diagonal of the given array of any dimensionality.\n\nFor an array `a` with ``a.ndim >= 2``, the diagonal is the list of\nlocations with indices ``a[i, ..., i]`` all identical. This function\nmodifies the input array in-place, it does not return a value.\n\nParameters\n----------\na : array, at least 2-D.\nArray whose diagonal is to be filled, it gets modified in-place.\n\nval : scalar or arraylike\nValue(s) to write on the diagonal. If `val` is scalar, the value is\nwritten along the diagonal. If array-like, the flattened `val` is\nwritten along the diagonal, repeating if necessary to fill all\ndiagonal entries.\n\nwrap : bool\nFor tall matrices in NumPy version up to 1.6.2, the\ndiagonal \"wrapped\" after N columns. You can have this behavior\nwith this option. This affects only tall matrices.\n\nSee also\n--------\ndiagindices, diagindicesfrom\n\nNotes\n-----\n.. versionadded:: 1.4.0\n\nThis functionality can be obtained via `diagindices`, but internally\nthis version uses a much faster implementation that never constructs the\nindices and uses simple slicing.\n\nExamples\n--------\n>>> a = np.zeros((3, 3), int)\n>>> np.filldiagonal(a, 5)\n>>> a\narray([[5, 0, 0],\n[0, 5, 0],\n[0, 0, 5]])\n\nThe same function can operate on a 4-D array:\n\n>>> a = np.zeros((3, 3, 3, 3), int)\n>>> np.filldiagonal(a, 4)\n\nWe only show a few blocks for clarity:\n\n>>> a[0, 0]\narray([[4, 0, 0],\n[0, 0, 0],\n[0, 0, 0]])\n>>> a[1, 1]\narray([[0, 0, 0],\n[0, 4, 0],\n[0, 0, 0]])\n>>> a[2, 2]\narray([[0, 0, 0],\n[0, 0, 0],\n[0, 0, 4]])\n\nThe wrap option affects only tall matrices:\n\n>>> # tall matrices no wrap\n>>> a = np.zeros((5, 3), int)\n>>> np.filldiagonal(a, 4)\n>>> a\narray([[4, 0, 0],\n[0, 4, 0],\n[0, 0, 4],\n[0, 0, 0],\n[0, 0, 0]])\n\n>>> # tall matrices wrap\n>>> a = np.zeros((5, 3), int)\n>>> np.filldiagonal(a, 4, wrap=True)\n>>> a\narray([[4, 0, 0],\n[0, 4, 0],\n[0, 0, 4],\n[0, 0, 0],\n[4, 0, 0]])\n\n>>> # wide matrices\n>>> a = np.zeros((3, 5), int)\n>>> np.filldiagonal(a, 4, wrap=True)\n>>> a\narray([[4, 0, 0, 0, 0],\n[0, 4, 0, 0, 0],\n[0, 0, 4, 0, 0]])\n\nThe anti-diagonal can be filled by reversing the order of elements\nusing either `numpy.flipud` or `numpy.fliplr`.\n\n>>> a = np.zeros((3, 3), int);\n>>> np.filldiagonal(np.fliplr(a), [1,2,3]) # Horizontal flip\n>>> a\narray([[0, 0, 1],\n[0, 2, 0],\n[3, 0, 0]])\n>>> np.filldiagonal(np.flipud(a), [1,2,3]) # Vertical flip\n>>> a\narray([[0, 0, 3],\n[0, 2, 0],\n[1, 0, 0]])\n\nNote that the order in which the diagonal is filled varies depending\non the flip function.\n" }, { "name": "find_common_type", "content": "Determine common type following standard coercion rules.\n\nParameters\n----------\narraytypes : sequence\nA list of dtypes or dtype convertible objects representing arrays.\nscalartypes : sequence\nA list of dtypes or dtype convertible objects representing scalars.\n\nReturns\n-------\ndatatype : dtype\nThe common data type, which is the maximum of `arraytypes` ignoring\n`scalartypes`, unless the maximum of `scalartypes` is of a\ndifferent kind (`dtype.kind`). If the kind is not understood, then\nNone is returned.\n\nSee Also\n--------\ndtype, commontype, cancast, mintypecode\n\nExamples\n--------\n>>> np.findcommontype([], [np.int64, np.float32, complex])\ndtype('complex128')\n>>> np.findcommontype([np.int64, np.float32], [])\ndtype('float64')\n\nThe standard casting rules ensure that a scalar cannot up-cast an\narray unless the scalar is of a fundamentally different kind of data\n(i.e. under a different hierarchy in the data type hierarchy) then\nthe array:\n\n>>> np.findcommontype([np.float32], [np.int64, np.float64])\ndtype('float32')\n\nComplex is of a different type, so it up-casts the float in the\n`arraytypes` argument:\n\n>>> np.findcommontype([np.float32], [complex])\ndtype('complex128')\n\nType specifier strings are convertible to dtypes and can therefore\nbe used instead of dtypes:\n\n>>> np.findcommontype(['f4', 'f4', 'i4'], ['c8'])\ndtype('complex128')\n" }, { "name": "fix", "content": "Round to nearest integer towards zero.\n\nRound an array of floats element-wise to nearest integer towards zero.\nThe rounded values are returned as floats.\n\nParameters\n----------\nx : arraylike\nAn array of floats to be rounded\nout : ndarray, optional\nA location into which the result is stored. If provided, it must have\na shape that the input broadcasts to. If not provided or None, a\nfreshly-allocated array is returned.\n\nReturns\n-------\nout : ndarray of floats\nA float array with the same dimensions as the input.\nIf second argument is not supplied then a float array is returned\nwith the rounded values.\n\nIf a second argument is supplied the result is stored there.\nThe return value `out` is then a reference to that array.\n\nSee Also\n--------\nrint, trunc, floor, ceil\naround : Round to given number of decimals\n\nExamples\n--------\n>>> np.fix(3.14)\n3.0\n>>> np.fix(3)\n3.0\n>>> np.fix([2.1, 2.9, -2.1, -2.9])\narray([ 2., 2., -2., -2.])\n" }, { "name": "flatnonzero", "content": "Return indices that are non-zero in the flattened version of a.\n\nThis is equivalent to np.nonzero(np.ravel(a))[0].\n\nParameters\n----------\na : arraylike\nInput data.\n\nReturns\n-------\nres : ndarray\nOutput array, containing the indices of the elements of `a.ravel()`\nthat are non-zero.\n\nSee Also\n--------\nnonzero : Return the indices of the non-zero elements of the input array.\nravel : Return a 1-D array containing the elements of the input array.\n\nExamples\n--------\n>>> x = np.arange(-2, 3)\n>>> x\narray([-2, -1, 0, 1, 2])\n>>> np.flatnonzero(x)\narray([0, 1, 3, 4])\n\nUse the indices of the non-zero elements as an index array to extract\nthese elements:\n\n>>> x.ravel()[np.flatnonzero(x)]\narray([-2, -1, 1, 2])\n" }, { "name": "flip", "content": "Reverse the order of elements in an array along the given axis.\n\nThe shape of the array is preserved, but the elements are reordered.\n\n.. versionadded:: 1.12.0\n\nParameters\n----------\nm : arraylike\nInput array.\naxis : None or int or tuple of ints, optional\nAxis or axes along which to flip over. The default,\naxis=None, will flip over all of the axes of the input array.\nIf axis is negative it counts from the last to the first axis.\n\nIf axis is a tuple of ints, flipping is performed on all of the axes\nspecified in the tuple.\n\n.. versionchanged:: 1.15.0\nNone and tuples of axes are supported\n\nReturns\n-------\nout : arraylike\nA view of `m` with the entries of axis reversed. Since a view is\nreturned, this operation is done in constant time.\n\nSee Also\n--------\nflipud : Flip an array vertically (axis=0).\nfliplr : Flip an array horizontally (axis=1).\n\nNotes\n-----\nflip(m, 0) is equivalent to flipud(m).\n\nflip(m, 1) is equivalent to fliplr(m).\n\nflip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.\n\nflip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all\npositions.\n\nflip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at\nposition 0 and position 1.\n\nExamples\n--------\n>>> A = np.arange(8).reshape((2,2,2))\n>>> A\narray([[[0, 1],\n[2, 3]],\n[[4, 5],\n[6, 7]]])\n>>> np.flip(A, 0)\narray([[[4, 5],\n[6, 7]],\n[[0, 1],\n[2, 3]]])\n>>> np.flip(A, 1)\narray([[[2, 3],\n[0, 1]],\n[[6, 7],\n[4, 5]]])\n>>> np.flip(A)\narray([[[7, 6],\n[5, 4]],\n[[3, 2],\n[1, 0]]])\n>>> np.flip(A, (0, 2))\narray([[[5, 4],\n[7, 6]],\n[[1, 0],\n[3, 2]]])\n>>> A = np.random.randn(3,4,5)\n>>> np.all(np.flip(A,2) == A[:,:,::-1,...])\nTrue\n" }, { "name": "fliplr", "content": "Reverse the order of elements along axis 1 (left/right).\n\nFor a 2-D array, this flips the entries in each row in the left/right\ndirection. Columns are preserved, but appear in a different order than\nbefore.\n\nParameters\n----------\nm : arraylike\nInput array, must be at least 2-D.\n\nReturns\n-------\nf : ndarray\nA view of `m` with the columns reversed. Since a view\nis returned, this operation is :math:`\\mathcal O(1)`.\n\nSee Also\n--------\nflipud : Flip array in the up/down direction.\nflip : Flip array in one or more dimesions.\nrot90 : Rotate array counterclockwise.\n\nNotes\n-----\nEquivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``.\nRequires the array to be at least 2-D.\n\nExamples\n--------\n>>> A = np.diag([1.,2.,3.])\n>>> A\narray([[1., 0., 0.],\n[0., 2., 0.],\n[0., 0., 3.]])\n>>> np.fliplr(A)\narray([[0., 0., 1.],\n[0., 2., 0.],\n[3., 0., 0.]])\n\n>>> A = np.random.randn(2,3,5)\n>>> np.all(np.fliplr(A) == A[:,::-1,...])\nTrue\n" }, { "name": "flipud", "content": "Reverse the order of elements along axis 0 (up/down).\n\nFor a 2-D array, this flips the entries in each column in the up/down\ndirection. Rows are preserved, but appear in a different order than before.\n\nParameters\n----------\nm : arraylike\nInput array.\n\nReturns\n-------\nout : arraylike\nA view of `m` with the rows reversed. Since a view is\nreturned, this operation is :math:`\\mathcal O(1)`.\n\nSee Also\n--------\nfliplr : Flip array in the left/right direction.\nflip : Flip array in one or more dimesions.\nrot90 : Rotate array counterclockwise.\n\nNotes\n-----\nEquivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``.\nRequires the array to be at least 1-D.\n\nExamples\n--------\n>>> A = np.diag([1.0, 2, 3])\n>>> A\narray([[1., 0., 0.],\n[0., 2., 0.],\n[0., 0., 3.]])\n>>> np.flipud(A)\narray([[0., 0., 3.],\n[0., 2., 0.],\n[1., 0., 0.]])\n\n>>> A = np.random.randn(2,3,5)\n>>> np.all(np.flipud(A) == A[::-1,...])\nTrue\n\n>>> np.flipud([1,2])\narray([2, 1])\n" }, { "name": "format_float_positional", "content": "Format a floating-point scalar as a decimal string in positional notation.\n\nProvides control over rounding, trimming and padding. Uses and assumes\nIEEE unbiased rounding. Uses the \"Dragon4\" algorithm.\n\nParameters\n----------\nx : python float or numpy floating scalar\nValue to format.\nprecision : non-negative integer or None, optional\nMaximum number of digits to print. May be None if `unique` is\n`True`, but must be an integer if unique is `False`.\nunique : boolean, optional\nIf `True`, use a digit-generation strategy which gives the shortest\nrepresentation which uniquely identifies the floating-point number from\nother values of the same type, by judicious rounding. If `precision`\nis given fewer digits than necessary can be printed, or if `mindigits`\nis given more can be printed, in which cases the last digit is rounded\nwith unbiased rounding.\nIf `False`, digits are generated as if printing an infinite-precision\nvalue and stopping after `precision` digits, rounding the remaining\nvalue with unbiased rounding\nfractional : boolean, optional\nIf `True`, the cutoffs of `precision` and `mindigits` refer to the\ntotal number of digits after the decimal point, including leading\nzeros.\nIf `False`, `precision` and `mindigits` refer to the total number of\nsignificant digits, before or after the decimal point, ignoring leading\nzeros.\ntrim : one of 'k', '.', '0', '-', optional\nControls post-processing trimming of trailing digits, as follows:\n\n* 'k' : keep trailing zeros, keep decimal point (no trimming)\n* '.' : trim all trailing zeros, leave decimal point\n* '0' : trim all but the zero before the decimal point. Insert the\nzero if it is missing.\n* '-' : trim trailing zeros and any trailing decimal point\nsign : boolean, optional\nWhether to show the sign for positive values.\npadleft : non-negative integer, optional\nPad the left side of the string with whitespace until at least that\nmany characters are to the left of the decimal point.\npadright : non-negative integer, optional\nPad the right side of the string with whitespace until at least that\nmany characters are to the right of the decimal point.\nmindigits : non-negative integer or None, optional\nMinimum number of digits to print. Only has an effect if `unique=True`\nin which case additional digits past those necessary to uniquely\nidentify the value may be printed, rounding the last additional digit.\n\n-- versionadded:: 1.21.0\n\nReturns\n-------\nrep : string\nThe string representation of the floating point value\n\nSee Also\n--------\nformatfloatscientific\n\nExamples\n--------\n>>> np.formatfloatpositional(np.float32(np.pi))\n'3.1415927'\n>>> np.formatfloatpositional(np.float16(np.pi))\n'3.14'\n>>> np.formatfloatpositional(np.float16(0.3))\n'0.3'\n>>> np.formatfloatpositional(np.float16(0.3), unique=False, precision=10)\n'0.3000488281'\n" }, { "name": "format_float_scientific", "content": "Format a floating-point scalar as a decimal string in scientific notation.\n\nProvides control over rounding, trimming and padding. Uses and assumes\nIEEE unbiased rounding. Uses the \"Dragon4\" algorithm.\n\nParameters\n----------\nx : python float or numpy floating scalar\nValue to format.\nprecision : non-negative integer or None, optional\nMaximum number of digits to print. May be None if `unique` is\n`True`, but must be an integer if unique is `False`.\nunique : boolean, optional\nIf `True`, use a digit-generation strategy which gives the shortest\nrepresentation which uniquely identifies the floating-point number from\nother values of the same type, by judicious rounding. If `precision`\nis given fewer digits than necessary can be printed. If `mindigits`\nis given more can be printed, in which cases the last digit is rounded\nwith unbiased rounding.\nIf `False`, digits are generated as if printing an infinite-precision\nvalue and stopping after `precision` digits, rounding the remaining\nvalue with unbiased rounding\ntrim : one of 'k', '.', '0', '-', optional\nControls post-processing trimming of trailing digits, as follows:\n\n* 'k' : keep trailing zeros, keep decimal point (no trimming)\n* '.' : trim all trailing zeros, leave decimal point\n* '0' : trim all but the zero before the decimal point. Insert the\nzero if it is missing.\n* '-' : trim trailing zeros and any trailing decimal point\nsign : boolean, optional\nWhether to show the sign for positive values.\npadleft : non-negative integer, optional\nPad the left side of the string with whitespace until at least that\nmany characters are to the left of the decimal point.\nexpdigits : non-negative integer, optional\nPad the exponent with zeros until it contains at least this many digits.\nIf omitted, the exponent will be at least 2 digits.\nmindigits : non-negative integer or None, optional\nMinimum number of digits to print. This only has an effect for\n`unique=True`. In that case more digits than necessary to uniquely\nidentify the value may be printed and rounded unbiased.\n\n-- versionadded:: 1.21.0\n\nReturns\n-------\nrep : string\nThe string representation of the floating point value\n\nSee Also\n--------\nformatfloatpositional\n\nExamples\n--------\n>>> np.formatfloatscientific(np.float32(np.pi))\n'3.1415927e+00'\n>>> s = np.float32(1.23e24)\n>>> np.formatfloatscientific(s, unique=False, precision=15)\n'1.230000071797338e+24'\n>>> np.formatfloatscientific(s, expdigits=4)\n'1.23e+0024'\n" }, { "name": "frombuffer", "content": "frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None)\n\nInterpret a buffer as a 1-dimensional array.\n\nParameters\n----------\nbuffer : bufferlike\nAn object that exposes the buffer interface.\ndtype : data-type, optional\nData-type of the returned array; default: float.\ncount : int, optional\nNumber of items to read. ``-1`` means all data in the buffer.\noffset : int, optional\nStart reading the buffer from this offset (in bytes); default: 0.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nNotes\n-----\nIf the buffer has data that is not in machine byte-order, this should\nbe specified as part of the data-type, e.g.::\n\n>>> dt = np.dtype(int)\n>>> dt = dt.newbyteorder('>')\n>>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP\n\nThe data of the resulting array will not be byteswapped, but will be\ninterpreted correctly.\n\nExamples\n--------\n>>> s = b'hello world'\n>>> np.frombuffer(s, dtype='S1', count=5, offset=6)\narray([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')\n\n>>> np.frombuffer(b'\\x01\\x02', dtype=np.uint8)\narray([1, 2], dtype=uint8)\n>>> np.frombuffer(b'\\x01\\x02\\x03\\x04\\x05', dtype=np.uint8, count=3)\narray([1, 2, 3], dtype=uint8)\n" }, { "name": "fromfile", "content": "fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None)\n\nConstruct an array from data in a text or binary file.\n\nA highly efficient way of reading binary data with a known data-type,\nas well as parsing simply formatted text files. Data written using the\n`tofile` method can be read using this function.\n\nParameters\n----------\nfile : file or str or Path\nOpen file object or filename.\n\n.. versionchanged:: 1.17.0\n`pathlib.Path` objects are now accepted.\n\ndtype : data-type\nData type of the returned array.\nFor binary files, it is used to determine the size and byte-order\nof the items in the file.\nMost builtin numeric types are supported and extension types may be supported.\n\n.. versionadded:: 1.18.0\nComplex dtypes.\n\ncount : int\nNumber of items to read. ``-1`` means all items (i.e., the complete\nfile).\nsep : str\nSeparator between items if file is a text file.\nEmpty (\"\") separator means the file should be treated as binary.\nSpaces (\" \") in the separator match zero or more whitespace characters.\nA separator consisting only of spaces must match at least one\nwhitespace.\noffset : int\nThe offset (in bytes) from the file's current position. Defaults to 0.\nOnly permitted for binary files.\n\n.. versionadded:: 1.17.0\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nSee also\n--------\nload, save\nndarray.tofile\nloadtxt : More flexible way of loading data from a text file.\n\nNotes\n-----\nDo not rely on the combination of `tofile` and `fromfile` for\ndata storage, as the binary files generated are not platform\nindependent. In particular, no byte-order or data-type information is\nsaved. Data can be stored in the platform independent ``.npy`` format\nusing `save` and `load` instead.\n\nExamples\n--------\nConstruct an ndarray:\n\n>>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),\n... ('temp', float)])\n>>> x = np.zeros((1,), dtype=dt)\n>>> x['time']['min'] = 10; x['temp'] = 98.25\n>>> x\narray([((10, 0), 98.25)],\ndtype=[('time', [('min', '>> import tempfile\n>>> fname = tempfile.mkstemp()[1]\n>>> x.tofile(fname)\n\nRead the raw data from disk:\n\n>>> np.fromfile(fname, dtype=dt)\narray([((10, 0), 98.25)],\ndtype=[('time', [('min', '>> np.save(fname, x)\n>>> np.load(fname + '.npy')\narray([((10, 0), 98.25)],\ndtype=[('time', [('min', '>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)\narray([[ True, False, False],\n[False, True, False],\n[False, False, True]])\n\n>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)\narray([[0, 1, 2],\n[1, 2, 3],\n[2, 3, 4]])\n" }, { "name": "fromiter", "content": "fromiter(iter, dtype, count=-1, *, like=None)\n\nCreate a new 1-dimensional array from an iterable object.\n\nParameters\n----------\niter : iterable object\nAn iterable object providing data for the array.\ndtype : data-type\nThe data-type of the returned array.\ncount : int, optional\nThe number of items to read from *iterable*. The default is -1,\nwhich means all data is read.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nThe output array.\n\nNotes\n-----\nSpecify `count` to improve performance. It allows ``fromiter`` to\npre-allocate the output array, instead of resizing it on demand.\n\nExamples\n--------\n>>> iterable = (x*x for x in range(5))\n>>> np.fromiter(iterable, float)\narray([ 0., 1., 4., 9., 16.])\n" }, { "name": "frompyfunc", "content": "frompyfunc(func, nin, nout, *[, identity])\n\nTakes an arbitrary Python function and returns a NumPy ufunc.\n\nCan be used, for example, to add broadcasting to a built-in Python\nfunction (see Examples section).\n\nParameters\n----------\nfunc : Python function object\nAn arbitrary Python function.\nnin : int\nThe number of input arguments.\nnout : int\nThe number of objects returned by `func`.\nidentity : object, optional\nThe value to use for the `~numpy.ufunc.identity` attribute of the resulting\nobject. If specified, this is equivalent to setting the underlying\nC ``identity`` field to ``PyUFuncIdentityValue``.\nIf omitted, the identity is set to ``PyUFuncNone``. Note that this is\nnot equivalent to setting the identity to ``None``, which implies the\noperation is reorderable.\n\nReturns\n-------\nout : ufunc\nReturns a NumPy universal function (``ufunc``) object.\n\nSee Also\n--------\nvectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.\n\nNotes\n-----\nThe returned ufunc always returns PyObject arrays.\n\nExamples\n--------\nUse frompyfunc to add broadcasting to the Python function ``oct``:\n\n>>> octarray = np.frompyfunc(oct, 1, 1)\n>>> octarray(np.array((10, 30, 100)))\narray(['0o12', '0o36', '0o144'], dtype=object)\n>>> np.array((oct(10), oct(30), oct(100))) # for comparison\narray(['0o12', '0o36', '0o144'], dtype='>> f = open('test.dat', 'w')\n>>> = f.write(\"1312 foo\\n1534 bar\\n444 qux\")\n>>> f.close()\n\n>>> regexp = r\"(\\d+)\\s+(...)\" # match [digits, whitespace, anything]\n>>> output = np.fromregex('test.dat', regexp,\n... [('num', np.int64), ('key', 'S3')])\n>>> output\narray([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],\ndtype=[('num', '>> output['num']\narray([1312, 1534, 444])\n" }, { "name": "fromstring", "content": "fromstring(string, dtype=float, count=-1, sep='', *, like=None)\n\nA new 1-D array initialized from text data in a string.\n\nParameters\n----------\nstring : str\nA string containing the data.\ndtype : data-type, optional\nThe data type of the array; default: float. For binary input data,\nthe data must be in exactly this format. Most builtin numeric types are\nsupported and extension types may be supported.\n\n.. versionadded:: 1.18.0\nComplex dtypes.\n\ncount : int, optional\nRead this number of `dtype` elements from the data. If this is\nnegative (the default), the count will be determined from the\nlength of the data.\nsep : str, optional\nThe string separating numbers in the data; extra whitespace between\nelements is also ignored.\n\n.. deprecated:: 1.14\nPassing ``sep=''``, the default, is deprecated since it will\ntrigger the deprecated binary mode of this function. This mode\ninterprets `string` as binary bytes, rather than ASCII text with\ndecimal numbers, an operation which is better spelt\n``frombuffer(string, dtype, count)``. If `string` contains unicode\ntext, the binary mode of `fromstring` will first encode it into\nbytes using either utf-8 (python 3) or the default encoding\n(python 2), neither of which produce sane results.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\narr : ndarray\nThe constructed array.\n\nRaises\n------\nValueError\nIf the string is not the correct size to satisfy the requested\n`dtype` and `count`.\n\nSee Also\n--------\nfrombuffer, fromfile, fromiter\n\nExamples\n--------\n>>> np.fromstring('1 2', dtype=int, sep=' ')\narray([1, 2])\n>>> np.fromstring('1, 2', dtype=int, sep=',')\narray([1, 2])\n" }, { "name": "full", "content": "Return a new array of given shape and type, filled with `fillvalue`.\n\nParameters\n----------\nshape : int or sequence of ints\nShape of the new array, e.g., ``(2, 3)`` or ``2``.\nfillvalue : scalar or arraylike\nFill value.\ndtype : data-type, optional\nThe desired data-type for the array The default, None, means\n``np.array(fillvalue).dtype``.\norder : {'C', 'F'}, optional\nWhether to store multidimensional data in C- or Fortran-contiguous\n(row- or column-wise) order in memory.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nArray of `fillvalue` with the given shape, dtype, and order.\n\nSee Also\n--------\nfulllike : Return a new array with shape of input filled with value.\nempty : Return a new uninitialized array.\nones : Return a new array setting values to one.\nzeros : Return a new array setting values to zero.\n\nExamples\n--------\n>>> np.full((2, 2), np.inf)\narray([[inf, inf],\n[inf, inf]])\n>>> np.full((2, 2), 10)\narray([[10, 10],\n[10, 10]])\n\n>>> np.full((2, 2), [1, 2])\narray([[1, 2],\n[1, 2]])\n" }, { "name": "full_like", "content": "Return a full array with the same shape and type as a given array.\n\nParameters\n----------\na : arraylike\nThe shape and data-type of `a` define these same attributes of\nthe returned array.\nfillvalue : scalar\nFill value.\ndtype : data-type, optional\nOverrides the data type of the result.\norder : {'C', 'F', 'A', or 'K'}, optional\nOverrides the memory layout of the result. 'C' means C-order,\n'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n'C' otherwise. 'K' means match the layout of `a` as closely\nas possible.\nsubok : bool, optional.\nIf True, then the newly created array will use the sub-class\ntype of `a`, otherwise it will be a base-class array. Defaults\nto True.\nshape : int or sequence of ints, optional.\nOverrides the shape of the result. If order='K' and the number of\ndimensions is unchanged, will try to keep order, otherwise,\norder='C' is implied.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\nout : ndarray\nArray of `fillvalue` with the same shape and type as `a`.\n\nSee Also\n--------\nemptylike : Return an empty array with shape and type of input.\noneslike : Return an array of ones with shape and type of input.\nzeroslike : Return an array of zeros with shape and type of input.\nfull : Return a new array of given shape filled with value.\n\nExamples\n--------\n>>> x = np.arange(6, dtype=int)\n>>> np.fulllike(x, 1)\narray([1, 1, 1, 1, 1, 1])\n>>> np.fulllike(x, 0.1)\narray([0, 0, 0, 0, 0, 0])\n>>> np.fulllike(x, 0.1, dtype=np.double)\narray([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])\n>>> np.fulllike(x, np.nan, dtype=np.double)\narray([nan, nan, nan, nan, nan, nan])\n\n>>> y = np.arange(6, dtype=np.double)\n>>> np.fulllike(y, 0.1)\narray([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])\n" }, { "name": "genfromtxt", "content": "Load data from a text file, with missing values handled as specified.\n\nEach line past the first `skipheader` lines is split at the `delimiter`\ncharacter, and characters following the `comments` character are discarded.\n\nParameters\n----------\nfname : file, str, pathlib.Path, list of str, generator\nFile, filename, list, or generator to read. If the filename\nextension is `.gz` or `.bz2`, the file is first decompressed. Note\nthat generators must return byte strings. The strings\nin a list or produced by a generator are treated as lines.\ndtype : dtype, optional\nData type of the resulting array.\nIf None, the dtypes will be determined by the contents of each\ncolumn, individually.\ncomments : str, optional\nThe character used to indicate the start of a comment.\nAll the characters occurring on a line after a comment are discarded.\ndelimiter : str, int, or sequence, optional\nThe string used to separate values. By default, any consecutive\nwhitespaces act as delimiter. An integer or sequence of integers\ncan also be provided as width(s) of each field.\nskiprows : int, optional\n`skiprows` was removed in numpy 1.10. Please use `skipheader` instead.\nskipheader : int, optional\nThe number of lines to skip at the beginning of the file.\nskipfooter : int, optional\nThe number of lines to skip at the end of the file.\nconverters : variable, optional\nThe set of functions that convert the data of a column to a value.\nThe converters can also be used to provide a default value\nfor missing data: ``converters = {3: lambda s: float(s or 0)}``.\nmissing : variable, optional\n`missing` was removed in numpy 1.10. Please use `missingvalues`\ninstead.\nmissingvalues : variable, optional\nThe set of strings corresponding to missing data.\nfillingvalues : variable, optional\nThe set of values to be used as default when the data are missing.\nusecols : sequence, optional\nWhich columns to read, with 0 being the first. For example,\n``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.\nnames : {None, True, str, sequence}, optional\nIf `names` is True, the field names are read from the first line after\nthe first `skipheader` lines. This line can optionally be preceeded\nby a comment delimiter. If `names` is a sequence or a single-string of\ncomma-separated names, the names will be used to define the field names\nin a structured dtype. If `names` is None, the names of the dtype\nfields will be used, if any.\nexcludelist : sequence, optional\nA list of names to exclude. This list is appended to the default list\n['return','file','print']. Excluded names are appended with an\nunderscore: for example, `file` would become `file`.\ndeletechars : str, optional\nA string combining invalid characters that must be deleted from the\nnames.\ndefaultfmt : str, optional\nA format used to define default field names, such as \"f%i\" or \"f%02i\".\nautostrip : bool, optional\nWhether to automatically strip white spaces from the variables.\nreplacespace : char, optional\nCharacter(s) used in replacement of white spaces in the variable\nnames. By default, use a ''.\ncasesensitive : {True, False, 'upper', 'lower'}, optional\nIf True, field names are case sensitive.\nIf False or 'upper', field names are converted to upper case.\nIf 'lower', field names are converted to lower case.\nunpack : bool, optional\nIf True, the returned array is transposed, so that arguments may be\nunpacked using ``x, y, z = genfromtxt(...)``. When used with a\nstructured data-type, arrays are returned for each field.\nDefault is False.\nusemask : bool, optional\nIf True, return a masked array.\nIf False, return a regular array.\nloose : bool, optional\nIf True, do not raise errors for invalid values.\ninvalidraise : bool, optional\nIf True, an exception is raised if an inconsistency is detected in the\nnumber of columns.\nIf False, a warning is emitted and the offending lines are skipped.\nmaxrows : int, optional\nThe maximum number of rows to read. Must not be used with skipfooter\nat the same time. If given, the value must be at least 1. Default is\nto read the entire file.\n\n.. versionadded:: 1.10.0\nencoding : str, optional\nEncoding used to decode the inputfile. Does not apply when `fname` is\na file object. The special value 'bytes' enables backward compatibility\nworkarounds that ensure that you receive byte arrays when possible\nand passes latin1 encoded strings to converters. Override this value to\nreceive unicode arrays and pass strings as input to converters. If set\nto None the system default is used. The default value is 'bytes'.\n\n.. versionadded:: 1.14.0\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nData read from the text file. If `usemask` is True, this is a\nmasked array.\n\nSee Also\n--------\nnumpy.loadtxt : equivalent function when no data is missing.\n\nNotes\n-----\n* When spaces are used as delimiters, or when no delimiter has been given\nas input, there should not be any missing data between two fields.\n* When the variables are named (either by a flexible dtype or with `names`),\nthere must not be any header in the file (else a ValueError\nexception is raised).\n* Individual values are not stripped of spaces by default.\nWhen using a custom converter, make sure the function does remove spaces.\n\nReferences\n----------\n.. [1] NumPy User Guide, section `I/O with NumPy\n`.\n\nExamples\n--------\n>>> from io import StringIO\n>>> import numpy as np\n\nComma delimited file with mixed dtype\n\n>>> s = StringIO(u\"1,1.3,abcde\")\n>>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),\n... ('mystring','S5')], delimiter=\",\")\n>>> data\narray((1, 1.3, b'abcde'),\ndtype=[('myint', '>> = s.seek(0) # needed for StringIO example only\n>>> data = np.genfromtxt(s, dtype=None,\n... names = ['myint','myfloat','mystring'], delimiter=\",\")\n>>> data\narray((1, 1.3, b'abcde'),\ndtype=[('myint', '>> = s.seek(0)\n>>> data = np.genfromtxt(s, dtype=\"i8,f8,S5\",\n... names=['myint','myfloat','mystring'], delimiter=\",\")\n>>> data\narray((1, 1.3, b'abcde'),\ndtype=[('myint', '>> s = StringIO(u\"11.3abcde\")\n>>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],\n... delimiter=[1,3,5])\n>>> data\narray((1, 1.3, b'abcde'),\ndtype=[('intvar', '>> f = StringIO('''\n... text,# of chars\n... hello world,11\n... numpy,5''')\n>>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')\narray([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],\ndtype=[('f0', 'S12'), ('f1', 'S12')])\n" }, { "name": "geomspace", "content": "Return numbers spaced evenly on a log scale (a geometric progression).\n\nThis is similar to `logspace`, but with endpoints specified directly.\nEach output sample is a constant multiple of the previous.\n\n.. versionchanged:: 1.16.0\nNon-scalar `start` and `stop` are now supported.\n\nParameters\n----------\nstart : arraylike\nThe starting value of the sequence.\nstop : arraylike\nThe final value of the sequence, unless `endpoint` is False.\nIn that case, ``num + 1`` values are spaced over the\ninterval in log-space, of which all but the last (a sequence of\nlength `num`) are returned.\nnum : integer, optional\nNumber of samples to generate. Default is 50.\nendpoint : boolean, optional\nIf true, `stop` is the last sample. Otherwise, it is not included.\nDefault is True.\ndtype : dtype\nThe type of the output array. If `dtype` is not given, the data type\nis inferred from `start` and `stop`. The inferred dtype will never be\nan integer; `float` is chosen even if the arguments would produce an\narray of integers.\naxis : int, optional\nThe axis in the result to store the samples. Relevant only if start\nor stop are array-like. By default (0), the samples will be along a\nnew axis inserted at the beginning. Use -1 to get an axis at the end.\n\n.. versionadded:: 1.16.0\n\nReturns\n-------\nsamples : ndarray\n`num` samples, equally spaced on a log scale.\n\nSee Also\n--------\nlogspace : Similar to geomspace, but with endpoints specified using log\nand base.\nlinspace : Similar to geomspace, but with arithmetic instead of geometric\nprogression.\narange : Similar to linspace, with the step size specified instead of the\nnumber of samples.\n\nNotes\n-----\nIf the inputs or dtype are complex, the output will follow a logarithmic\nspiral in the complex plane. (There are an infinite number of spirals\npassing through two points; the output will follow the shortest such path.)\n\nExamples\n--------\n>>> np.geomspace(1, 1000, num=4)\narray([ 1., 10., 100., 1000.])\n>>> np.geomspace(1, 1000, num=3, endpoint=False)\narray([ 1., 10., 100.])\n>>> np.geomspace(1, 1000, num=4, endpoint=False)\narray([ 1. , 5.62341325, 31.6227766 , 177.827941 ])\n>>> np.geomspace(1, 256, num=9)\narray([ 1., 2., 4., 8., 16., 32., 64., 128., 256.])\n\nNote that the above may not produce exact integers:\n\n>>> np.geomspace(1, 256, num=9, dtype=int)\narray([ 1, 2, 4, 7, 16, 32, 63, 127, 256])\n>>> np.around(np.geomspace(1, 256, num=9)).astype(int)\narray([ 1, 2, 4, 8, 16, 32, 64, 128, 256])\n\nNegative, decreasing, and complex inputs are allowed:\n\n>>> np.geomspace(1000, 1, num=4)\narray([1000., 100., 10., 1.])\n>>> np.geomspace(-1000, -1, num=4)\narray([-1000., -100., -10., -1.])\n>>> np.geomspace(1j, 1000j, num=4) # Straight line\narray([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j])\n>>> np.geomspace(-1+0j, 1+0j, num=5) # Circle\narray([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,\n6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j,\n1.00000000e+00+0.00000000e+00j])\n\nGraphical illustration of `endpoint` parameter:\n\n>>> import matplotlib.pyplot as plt\n>>> N = 10\n>>> y = np.zeros(N)\n>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')\n[]\n>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')\n[]\n>>> plt.axis([0.5, 2000, 0, 3])\n[0.5, 2000, 0, 3]\n>>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')\n>>> plt.show()\n" }, { "name": "get_array_wrap", "content": "Find the wrapper for the array with the highest priority.\n\nIn case of ties, leftmost wins. If no wrapper is found, return None\n" }, { "name": "get_include", "content": "Return the directory that contains the NumPy \\*.h header files.\n\nExtension modules that need to compile against NumPy should use this\nfunction to locate the appropriate include directory.\n\nNotes\n-----\nWhen using ``distutils``, for example in ``setup.py``.\n::\n\nimport numpy as np\n...\nExtension('extensionname', ...\nincludedirs=[np.getinclude()])\n...\n" }, { "name": "get_printoptions", "content": "Return the current print options.\n\nReturns\n-------\nprintopts : dict\nDictionary of current print options with keys\n\n- precision : int\n- threshold : int\n- edgeitems : int\n- linewidth : int\n- suppress : bool\n- nanstr : str\n- infstr : str\n- formatter : dict of callables\n- sign : str\n\nFor a full description of these options, see `setprintoptions`.\n\nSee Also\n--------\nsetprintoptions, printoptions, setstringfunction\n" }, { "name": "getbufsize", "content": "Return the size of the buffer used in ufuncs.\n\nReturns\n-------\ngetbufsize : int\nSize of ufunc buffer in bytes.\n" }, { "name": "geterr", "content": "Get the current way of handling floating-point errors.\n\nReturns\n-------\nres : dict\nA dictionary with keys \"divide\", \"over\", \"under\", and \"invalid\",\nwhose values are from the strings \"ignore\", \"print\", \"log\", \"warn\",\n\"raise\", and \"call\". The keys represent possible floating-point\nexceptions, and the values define how these exceptions are handled.\n\nSee Also\n--------\ngeterrcall, seterr, seterrcall\n\nNotes\n-----\nFor complete documentation of the types of floating-point exceptions and\ntreatment options, see `seterr`.\n\nExamples\n--------\n>>> np.geterr()\n{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}\n>>> np.arange(3.) / np.arange(3.)\narray([nan, 1., 1.])\n\n>>> oldsettings = np.seterr(all='warn', over='raise')\n>>> np.geterr()\n{'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'}\n>>> np.arange(3.) / np.arange(3.)\narray([nan, 1., 1.])\n" }, { "name": "geterrcall", "content": "Return the current callback function used on floating-point errors.\n\nWhen the error handling for a floating-point error (one of \"divide\",\n\"over\", \"under\", or \"invalid\") is set to 'call' or 'log', the function\nthat is called or the log instance that is written to is returned by\n`geterrcall`. This function or log instance has been set with\n`seterrcall`.\n\nReturns\n-------\nerrobj : callable, log instance or None\nThe current error handler. If no handler was set through `seterrcall`,\n``None`` is returned.\n\nSee Also\n--------\nseterrcall, seterr, geterr\n\nNotes\n-----\nFor complete documentation of the types of floating-point exceptions and\ntreatment options, see `seterr`.\n\nExamples\n--------\n>>> np.geterrcall() # we did not yet set a handler, returns None\n\n>>> oldsettings = np.seterr(all='call')\n>>> def errhandler(type, flag):\n... print(\"Floating point error (%s), with flag %s\" % (type, flag))\n>>> oldhandler = np.seterrcall(errhandler)\n>>> np.array([1, 2, 3]) / 0.0\nFloating point error (divide by zero), with flag 1\narray([inf, inf, inf])\n\n>>> curhandler = np.geterrcall()\n>>> curhandler is errhandler\nTrue\n" }, { "name": "geterrobj", "content": "geterrobj()\n\nReturn the current object that defines floating-point error handling.\n\nThe error object contains all information that defines the error handling\nbehavior in NumPy. `geterrobj` is used internally by the other\nfunctions that get and set error handling behavior (`geterr`, `seterr`,\n`geterrcall`, `seterrcall`).\n\nReturns\n-------\nerrobj : list\nThe error object, a list containing three elements:\n[internal numpy buffer size, error mask, error callback function].\n\nThe error mask is a single integer that holds the treatment information\non all four floating point errors. The information for each error type\nis contained in three bits of the integer. If we print it in base 8, we\ncan see what treatment is set for \"invalid\", \"under\", \"over\", and\n\"divide\" (in that order). The printed string can be interpreted with\n\n* 0 : 'ignore'\n* 1 : 'warn'\n* 2 : 'raise'\n* 3 : 'call'\n* 4 : 'print'\n* 5 : 'log'\n\nSee Also\n--------\nseterrobj, seterr, geterr, seterrcall, geterrcall\ngetbufsize, setbufsize\n\nNotes\n-----\nFor complete documentation of the types of floating-point exceptions and\ntreatment options, see `seterr`.\n\nExamples\n--------\n>>> np.geterrobj() # first get the defaults\n[8192, 521, None]\n\n>>> def errhandler(type, flag):\n... print(\"Floating point error (%s), with flag %s\" % (type, flag))\n...\n>>> oldbufsize = np.setbufsize(20000)\n>>> olderr = np.seterr(divide='raise')\n>>> oldhandler = np.seterrcall(errhandler)\n>>> np.geterrobj()\n[8192, 521, ]\n\n>>> olderr = np.seterr(all='ignore')\n>>> np.baserepr(np.geterrobj()[1], 8)\n'0'\n>>> olderr = np.seterr(divide='warn', over='log', under='call',\n... invalid='print')\n>>> np.baserepr(np.geterrobj()[1], 8)\n'4351'\n" }, { "name": "gradient", "content": "Return the gradient of an N-dimensional array.\n\nThe gradient is computed using second order accurate central differences\nin the interior points and either first or second order accurate one-sides\n(forward or backwards) differences at the boundaries.\nThe returned gradient hence has the same shape as the input array.\n\nParameters\n----------\nf : arraylike\nAn N-dimensional array containing samples of a scalar function.\nvarargs : list of scalar or array, optional\nSpacing between f values. Default unitary spacing for all dimensions.\nSpacing can be specified using:\n\n1. single scalar to specify a sample distance for all dimensions.\n2. N scalars to specify a constant sample distance for each dimension.\ni.e. `dx`, `dy`, `dz`, ...\n3. N arrays to specify the coordinates of the values along each\ndimension of F. The length of the array must match the size of\nthe corresponding dimension\n4. Any combination of N scalars/arrays with the meaning of 2. and 3.\n\nIf `axis` is given, the number of varargs must equal the number of axes.\nDefault: 1.\n\nedgeorder : {1, 2}, optional\nGradient is calculated using N-th order accurate differences\nat the boundaries. Default: 1.\n\n.. versionadded:: 1.9.1\n\naxis : None or int or tuple of ints, optional\nGradient is calculated only along the given axis or axes\nThe default (axis = None) is to calculate the gradient for all the axes\nof the input array. axis may be negative, in which case it counts from\nthe last to the first axis.\n\n.. versionadded:: 1.11.0\n\nReturns\n-------\ngradient : ndarray or list of ndarray\nA list of ndarrays (or a single ndarray if there is only one dimension)\ncorresponding to the derivatives of f with respect to each dimension.\nEach derivative has the same shape as f.\n\nExamples\n--------\n>>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)\n>>> np.gradient(f)\narray([1. , 1.5, 2.5, 3.5, 4.5, 5. ])\n>>> np.gradient(f, 2)\narray([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ])\n\nSpacing can be also specified with an array that represents the coordinates\nof the values F along the dimensions.\nFor instance a uniform spacing:\n\n>>> x = np.arange(f.size)\n>>> np.gradient(f, x)\narray([1. , 1.5, 2.5, 3.5, 4.5, 5. ])\n\nOr a non uniform one:\n\n>>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)\n>>> np.gradient(f, x)\narray([1. , 3. , 3.5, 6.7, 6.9, 2.5])\n\nFor two dimensional arrays, the return will be two arrays ordered by\naxis. In this example the first array stands for the gradient in\nrows and the second one in columns direction:\n\n>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))\n[array([[ 2., 2., -1.],\n[ 2., 2., -1.]]), array([[1. , 2.5, 4. ],\n[1. , 1. , 1. ]])]\n\nIn this example the spacing is also specified:\nuniform for axis=0 and non uniform for axis=1\n\n>>> dx = 2.\n>>> y = [1., 1.5, 3.5]\n>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)\n[array([[ 1. , 1. , -0.5],\n[ 1. , 1. , -0.5]]), array([[2. , 2. , 2. ],\n[2. , 1.7, 0.5]])]\n\nIt is possible to specify how boundaries are treated using `edgeorder`\n\n>>> x = np.array([0, 1, 2, 3, 4])\n>>> f = x2\n>>> np.gradient(f, edgeorder=1)\narray([1., 2., 4., 6., 7.])\n>>> np.gradient(f, edgeorder=2)\narray([0., 2., 4., 6., 8.])\n\nThe `axis` keyword can be used to specify a subset of axes of which the\ngradient is calculated\n\n>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)\narray([[ 2., 2., -1.],\n[ 2., 2., -1.]])\n\nNotes\n-----\nAssuming that :math:`f\\in C^{3}` (i.e., :math:`f` has at least 3 continuous\nderivatives) and let :math:`h{*}` be a non-homogeneous stepsize, we\nminimize the \"consistency error\" :math:`\\eta{i}` between the true gradient\nand its estimate from a linear combination of the neighboring grid-points:\n\n.. math::\n\n\\eta{i} = f{i}^{\\left(1\\right)} -\n\\left[ \\alpha f\\left(x{i}\\right) +\n\\beta f\\left(x{i} + h{d}\\right) +\n\\gamma f\\left(x{i}-h{s}\\right)\n\\right]\n\nBy substituting :math:`f(x{i} + h{d})` and :math:`f(x{i} - h{s})`\nwith their Taylor series expansion, this translates into solving\nthe following the linear system:\n\n.. math::\n\n\\left\\{\n\\begin{array}{r}\n\\alpha+\\beta+\\gamma=0 \\\\\n\\beta h{d}-\\gamma h{s}=1 \\\\\n\\beta h{d}^{2}+\\gamma h{s}^{2}=0\n\\end{array}\n\\right.\n\nThe resulting approximation of :math:`f{i}^{(1)}` is the following:\n\n.. math::\n\n\\hat f{i}^{(1)} =\n\\frac{\nh{s}^{2}f\\left(x{i} + h{d}\\right)\n+ \\left(h{d}^{2} - h{s}^{2}\\right)f\\left(x{i}\\right)\n- h{d}^{2}f\\left(x{i}-h{s}\\right)}\n{ h{s}h{d}\\left(h{d} + h{s}\\right)}\n+ \\mathcal{O}\\left(\\frac{h{d}h{s}^{2}\n+ h{s}h{d}^{2}}{h{d}\n+ h{s}}\\right)\n\nIt is worth noting that if :math:`h{s}=h{d}`\n(i.e., data are evenly spaced)\nwe find the standard second order approximation:\n\n.. math::\n\n\\hat f{i}^{(1)}=\n\\frac{f\\left(x{i+1}\\right) - f\\left(x{i-1}\\right)}{2h}\n+ \\mathcal{O}\\left(h^{2}\\right)\n\nWith a similar procedure the forward/backward approximations used for\nboundaries can be derived.\n\nReferences\n----------\n.. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics\n(Texts in Applied Mathematics). New York: Springer.\n.. [2] Durran D. R. (1999) Numerical Methods for Wave Equations\nin Geophysical Fluid Dynamics. New York: Springer.\n.. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on\nArbitrarily Spaced Grids,\nMathematics of Computation 51, no. 184 : 699-706.\n`PDF `.\n" }, { "name": "hamming", "content": "Return the Hamming window.\n\nThe Hamming window is a taper formed by using a weighted cosine.\n\nParameters\n----------\nM : int\nNumber of points in the output window. If zero or less, an\nempty array is returned.\n\nReturns\n-------\nout : ndarray\nThe window, with the maximum value normalized to one (the value\none appears only if the number of samples is odd).\n\nSee Also\n--------\nbartlett, blackman, hanning, kaiser\n\nNotes\n-----\nThe Hamming window is defined as\n\n.. math:: w(n) = 0.54 - 0.46cos\\left(\\frac{2\\pi{n}}{M-1}\\right)\n\\qquad 0 \\leq n \\leq M-1\n\nThe Hamming was named for R. W. Hamming, an associate of J. W. Tukey\nand is described in Blackman and Tukey. It was recommended for\nsmoothing the truncated autocovariance function in the time domain.\nMost references to the Hamming window come from the signal processing\nliterature, where it is used as one of many windowing functions for\nsmoothing values. It is also known as an apodization (which means\n\"removing the foot\", i.e. smoothing discontinuities at the beginning\nand end of the sampled signal) or tapering function.\n\nReferences\n----------\n.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power\nspectra, Dover Publications, New York.\n.. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The\nUniversity of Alberta Press, 1975, pp. 109-110.\n.. [3] Wikipedia, \"Window function\",\nhttps://en.wikipedia.org/wiki/Windowfunction\n.. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,\n\"Numerical Recipes\", Cambridge University Press, 1986, page 425.\n\nExamples\n--------\n>>> np.hamming(12)\narray([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary\n0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909,\n0.15302337, 0.08 ])\n\nPlot the window and the frequency response:\n\n>>> import matplotlib.pyplot as plt\n>>> from numpy.fft import fft, fftshift\n>>> window = np.hamming(51)\n>>> plt.plot(window)\n[]\n>>> plt.title(\"Hamming window\")\nText(0.5, 1.0, 'Hamming window')\n>>> plt.ylabel(\"Amplitude\")\nText(0, 0.5, 'Amplitude')\n>>> plt.xlabel(\"Sample\")\nText(0.5, 0, 'Sample')\n>>> plt.show()\n\n>>> plt.figure()\n
\n>>> A = fft(window, 2048) / 25.5\n>>> mag = np.abs(fftshift(A))\n>>> freq = np.linspace(-0.5, 0.5, len(A))\n>>> response = 20 * np.log10(mag)\n>>> response = np.clip(response, -100, 100)\n>>> plt.plot(freq, response)\n[]\n>>> plt.title(\"Frequency response of Hamming window\")\nText(0.5, 1.0, 'Frequency response of Hamming window')\n>>> plt.ylabel(\"Magnitude [dB]\")\nText(0, 0.5, 'Magnitude [dB]')\n>>> plt.xlabel(\"Normalized frequency [cycles per sample]\")\nText(0.5, 0, 'Normalized frequency [cycles per sample]')\n>>> plt.axis('tight')\n...\n>>> plt.show()\n" }, { "name": "hanning", "content": "Return the Hanning window.\n\nThe Hanning window is a taper formed by using a weighted cosine.\n\nParameters\n----------\nM : int\nNumber of points in the output window. If zero or less, an\nempty array is returned.\n\nReturns\n-------\nout : ndarray, shape(M,)\nThe window, with the maximum value normalized to one (the value\none appears only if `M` is odd).\n\nSee Also\n--------\nbartlett, blackman, hamming, kaiser\n\nNotes\n-----\nThe Hanning window is defined as\n\n.. math:: w(n) = 0.5 - 0.5cos\\left(\\frac{2\\pi{n}}{M-1}\\right)\n\\qquad 0 \\leq n \\leq M-1\n\nThe Hanning was named for Julius von Hann, an Austrian meteorologist.\nIt is also known as the Cosine Bell. Some authors prefer that it be\ncalled a Hann window, to help avoid confusion with the very similar\nHamming window.\n\nMost references to the Hanning window come from the signal processing\nliterature, where it is used as one of many windowing functions for\nsmoothing values. It is also known as an apodization (which means\n\"removing the foot\", i.e. smoothing discontinuities at the beginning\nand end of the sampled signal) or tapering function.\n\nReferences\n----------\n.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power\nspectra, Dover Publications, New York.\n.. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",\nThe University of Alberta Press, 1975, pp. 106-108.\n.. [3] Wikipedia, \"Window function\",\nhttps://en.wikipedia.org/wiki/Windowfunction\n.. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,\n\"Numerical Recipes\", Cambridge University Press, 1986, page 425.\n\nExamples\n--------\n>>> np.hanning(12)\narray([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037,\n0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,\n0.07937323, 0. ])\n\nPlot the window and its frequency response:\n\n>>> import matplotlib.pyplot as plt\n>>> from numpy.fft import fft, fftshift\n>>> window = np.hanning(51)\n>>> plt.plot(window)\n[]\n>>> plt.title(\"Hann window\")\nText(0.5, 1.0, 'Hann window')\n>>> plt.ylabel(\"Amplitude\")\nText(0, 0.5, 'Amplitude')\n>>> plt.xlabel(\"Sample\")\nText(0.5, 0, 'Sample')\n>>> plt.show()\n\n>>> plt.figure()\n
\n>>> A = fft(window, 2048) / 25.5\n>>> mag = np.abs(fftshift(A))\n>>> freq = np.linspace(-0.5, 0.5, len(A))\n>>> with np.errstate(divide='ignore', invalid='ignore'):\n... response = 20 * np.log10(mag)\n...\n>>> response = np.clip(response, -100, 100)\n>>> plt.plot(freq, response)\n[]\n>>> plt.title(\"Frequency response of the Hann window\")\nText(0.5, 1.0, 'Frequency response of the Hann window')\n>>> plt.ylabel(\"Magnitude [dB]\")\nText(0, 0.5, 'Magnitude [dB]')\n>>> plt.xlabel(\"Normalized frequency [cycles per sample]\")\nText(0.5, 0, 'Normalized frequency [cycles per sample]')\n>>> plt.axis('tight')\n...\n>>> plt.show()\n" }, { "name": "histogram", "content": "Compute the histogram of a dataset.\n\nParameters\n----------\na : arraylike\nInput data. The histogram is computed over the flattened array.\nbins : int or sequence of scalars or str, optional\nIf `bins` is an int, it defines the number of equal-width\nbins in the given range (10, by default). If `bins` is a\nsequence, it defines a monotonically increasing array of bin edges,\nincluding the rightmost edge, allowing for non-uniform bin widths.\n\n.. versionadded:: 1.11.0\n\nIf `bins` is a string, it defines the method used to calculate the\noptimal bin width, as defined by `histogrambinedges`.\n\nrange : (float, float), optional\nThe lower and upper range of the bins. If not provided, range\nis simply ``(a.min(), a.max())``. Values outside the range are\nignored. The first element of the range must be less than or\nequal to the second. `range` affects the automatic bin\ncomputation as well. While bin width is computed to be optimal\nbased on the actual data within `range`, the bin count will fill\nthe entire range including portions containing no data.\nnormed : bool, optional\n\n.. deprecated:: 1.6.0\n\nThis is equivalent to the `density` argument, but produces incorrect\nresults for unequal bin widths. It should not be used.\n\n.. versionchanged:: 1.15.0\nDeprecationWarnings are actually emitted.\n\nweights : arraylike, optional\nAn array of weights, of the same shape as `a`. Each value in\n`a` only contributes its associated weight towards the bin count\n(instead of 1). If `density` is True, the weights are\nnormalized, so that the integral of the density over the range\nremains 1.\ndensity : bool, optional\nIf ``False``, the result will contain the number of samples in\neach bin. If ``True``, the result is the value of the\nprobability *density* function at the bin, normalized such that\nthe *integral* over the range is 1. Note that the sum of the\nhistogram values will not be equal to 1 unless bins of unity\nwidth are chosen; it is not a probability *mass* function.\n\nOverrides the ``normed`` keyword if given.\n\nReturns\n-------\nhist : array\nThe values of the histogram. See `density` and `weights` for a\ndescription of the possible semantics.\nbinedges : array of dtype float\nReturn the bin edges ``(length(hist)+1)``.\n\n\nSee Also\n--------\nhistogramdd, bincount, searchsorted, digitize, histogrambinedges\n\nNotes\n-----\nAll but the last (righthand-most) bin is half-open. In other words,\nif `bins` is::\n\n[1, 2, 3, 4]\n\nthen the first bin is ``[1, 2)`` (including 1, but excluding 2) and\nthe second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which\n*includes* 4.\n\n\nExamples\n--------\n>>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])\n(array([0, 2, 1]), array([0, 1, 2, 3]))\n>>> np.histogram(np.arange(4), bins=np.arange(5), density=True)\n(array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))\n>>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])\n(array([1, 4, 1]), array([0, 1, 2, 3]))\n\n>>> a = np.arange(5)\n>>> hist, binedges = np.histogram(a, density=True)\n>>> hist\narray([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])\n>>> hist.sum()\n2.4999999999999996\n>>> np.sum(hist * np.diff(binedges))\n1.0\n\n.. versionadded:: 1.11.0\n\nAutomated Bin Selection Methods example, using 2 peak random data\nwith 2000 points:\n\n>>> import matplotlib.pyplot as plt\n>>> rng = np.random.RandomState(10) # deterministic random data\n>>> a = np.hstack((rng.normal(size=1000),\n... rng.normal(loc=5, scale=2, size=1000)))\n>>> = plt.hist(a, bins='auto') # arguments are passed to np.histogram\n>>> plt.title(\"Histogram with 'auto' bins\")\nText(0.5, 1.0, \"Histogram with 'auto' bins\")\n>>> plt.show()\n" }, { "name": "histogram2d", "content": "Compute the bi-dimensional histogram of two data samples.\n\nParameters\n----------\nx : arraylike, shape (N,)\nAn array containing the x coordinates of the points to be\nhistogrammed.\ny : arraylike, shape (N,)\nAn array containing the y coordinates of the points to be\nhistogrammed.\nbins : int or arraylike or [int, int] or [array, array], optional\nThe bin specification:\n\n* If int, the number of bins for the two dimensions (nx=ny=bins).\n* If arraylike, the bin edges for the two dimensions\n(xedges=yedges=bins).\n* If [int, int], the number of bins in each dimension\n(nx, ny = bins).\n* If [array, array], the bin edges in each dimension\n(xedges, yedges = bins).\n* A combination [int, array] or [array, int], where int\nis the number of bins and array is the bin edges.\n\nrange : arraylike, shape(2,2), optional\nThe leftmost and rightmost edges of the bins along each dimension\n(if not specified explicitly in the `bins` parameters):\n``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range\nwill be considered outliers and not tallied in the histogram.\ndensity : bool, optional\nIf False, the default, returns the number of samples in each bin.\nIf True, returns the probability *density* function at the bin,\n``bincount / samplecount / binarea``.\nnormed : bool, optional\nAn alias for the density argument that behaves identically. To avoid\nconfusion with the broken normed argument to `histogram`, `density`\nshould be preferred.\nweights : arraylike, shape(N,), optional\nAn array of values ``wi`` weighing each sample ``(xi, yi)``.\nWeights are normalized to 1 if `normed` is True. If `normed` is\nFalse, the values of the returned histogram are equal to the sum of\nthe weights belonging to the samples falling into each bin.\n\nReturns\n-------\nH : ndarray, shape(nx, ny)\nThe bi-dimensional histogram of samples `x` and `y`. Values in `x`\nare histogrammed along the first dimension and values in `y` are\nhistogrammed along the second dimension.\nxedges : ndarray, shape(nx+1,)\nThe bin edges along the first dimension.\nyedges : ndarray, shape(ny+1,)\nThe bin edges along the second dimension.\n\nSee Also\n--------\nhistogram : 1D histogram\nhistogramdd : Multidimensional histogram\n\nNotes\n-----\nWhen `normed` is True, then the returned histogram is the sample\ndensity, defined such that the sum over bins of the product\n``binvalue * binarea`` is 1.\n\nPlease note that the histogram does not follow the Cartesian convention\nwhere `x` values are on the abscissa and `y` values on the ordinate\naxis. Rather, `x` is histogrammed along the first dimension of the\narray (vertical), and `y` along the second dimension of the array\n(horizontal). This ensures compatibility with `histogramdd`.\n\nExamples\n--------\n>>> from matplotlib.image import NonUniformImage\n>>> import matplotlib.pyplot as plt\n\nConstruct a 2-D histogram with variable bin width. First define the bin\nedges:\n\n>>> xedges = [0, 1, 3, 5]\n>>> yedges = [0, 2, 3, 4, 6]\n\nNext we create a histogram H with random bin content:\n\n>>> x = np.random.normal(2, 1, 100)\n>>> y = np.random.normal(1, 1, 100)\n>>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))\n>>> # Histogram does not follow Cartesian convention (see Notes),\n>>> # therefore transpose H for visualization purposes.\n>>> H = H.T\n\n:func:`imshow ` can only display square bins:\n\n>>> fig = plt.figure(figsize=(7, 3))\n>>> ax = fig.addsubplot(131, title='imshow: square bins')\n>>> plt.imshow(H, interpolation='nearest', origin='lower',\n... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])\n\n\n:func:`pcolormesh ` can display actual edges:\n\n>>> ax = fig.addsubplot(132, title='pcolormesh: actual edges',\n... aspect='equal')\n>>> X, Y = np.meshgrid(xedges, yedges)\n>>> ax.pcolormesh(X, Y, H)\n\n\n:class:`NonUniformImage ` can be used to\ndisplay actual bin edges with interpolation:\n\n>>> ax = fig.addsubplot(133, title='NonUniformImage: interpolated',\n... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])\n>>> im = NonUniformImage(ax, interpolation='bilinear')\n>>> xcenters = (xedges[:-1] + xedges[1:]) / 2\n>>> ycenters = (yedges[:-1] + yedges[1:]) / 2\n>>> im.setdata(xcenters, ycenters, H)\n>>> ax.images.append(im)\n>>> plt.show()\n" }, { "name": "histogram_bin_edges", "content": "Function to calculate only the edges of the bins used by the `histogram`\nfunction.\n\nParameters\n----------\na : arraylike\nInput data. The histogram is computed over the flattened array.\nbins : int or sequence of scalars or str, optional\nIf `bins` is an int, it defines the number of equal-width\nbins in the given range (10, by default). If `bins` is a\nsequence, it defines the bin edges, including the rightmost\nedge, allowing for non-uniform bin widths.\n\nIf `bins` is a string from the list below, `histogrambinedges` will use\nthe method chosen to calculate the optimal bin width and\nconsequently the number of bins (see `Notes` for more detail on\nthe estimators) from the data that falls within the requested\nrange. While the bin width will be optimal for the actual data\nin the range, the number of bins will be computed to fill the\nentire range, including the empty portions. For visualisation,\nusing the 'auto' option is suggested. Weighted data is not\nsupported for automated bin size selection.\n\n'auto'\nMaximum of the 'sturges' and 'fd' estimators. Provides good\nall around performance.\n\n'fd' (Freedman Diaconis Estimator)\nRobust (resilient to outliers) estimator that takes into\naccount data variability and data size.\n\n'doane'\nAn improved version of Sturges' estimator that works better\nwith non-normal datasets.\n\n'scott'\nLess robust estimator that that takes into account data\nvariability and data size.\n\n'stone'\nEstimator based on leave-one-out cross-validation estimate of\nthe integrated squared error. Can be regarded as a generalization\nof Scott's rule.\n\n'rice'\nEstimator does not take variability into account, only data\nsize. Commonly overestimates number of bins required.\n\n'sturges'\nR's default method, only accounts for data size. Only\noptimal for gaussian data and underestimates number of bins\nfor large non-gaussian datasets.\n\n'sqrt'\nSquare root (of data size) estimator, used by Excel and\nother programs for its speed and simplicity.\n\nrange : (float, float), optional\nThe lower and upper range of the bins. If not provided, range\nis simply ``(a.min(), a.max())``. Values outside the range are\nignored. The first element of the range must be less than or\nequal to the second. `range` affects the automatic bin\ncomputation as well. While bin width is computed to be optimal\nbased on the actual data within `range`, the bin count will fill\nthe entire range including portions containing no data.\n\nweights : arraylike, optional\nAn array of weights, of the same shape as `a`. Each value in\n`a` only contributes its associated weight towards the bin count\n(instead of 1). This is currently not used by any of the bin estimators,\nbut may be in the future.\n\nReturns\n-------\nbinedges : array of dtype float\nThe edges to pass into `histogram`\n\nSee Also\n--------\nhistogram\n\nNotes\n-----\nThe methods to estimate the optimal number of bins are well founded\nin literature, and are inspired by the choices R provides for\nhistogram visualisation. Note that having the number of bins\nproportional to :math:`n^{1/3}` is asymptotically optimal, which is\nwhy it appears in most estimators. These are simply plug-in methods\nthat give good starting points for number of bins. In the equations\nbelow, :math:`h` is the binwidth and :math:`nh` is the number of\nbins. All estimators that compute bin counts are recast to bin width\nusing the `ptp` of the data. The final bin count is obtained from\n``np.round(np.ceil(range / h))``. The final bin width is often less\nthan what is returned by the estimators below.\n\n'auto' (maximum of the 'sturges' and 'fd' estimators)\nA compromise to get a good value. For small datasets the Sturges\nvalue will usually be chosen, while larger datasets will usually\ndefault to FD. Avoids the overly conservative behaviour of FD\nand Sturges for small and large datasets respectively.\nSwitchover point is usually :math:`a.size \\approx 1000`.\n\n'fd' (Freedman Diaconis Estimator)\n.. math:: h = 2 \\frac{IQR}{n^{1/3}}\n\nThe binwidth is proportional to the interquartile range (IQR)\nand inversely proportional to cube root of a.size. Can be too\nconservative for small datasets, but is quite good for large\ndatasets. The IQR is very robust to outliers.\n\n'scott'\n.. math:: h = \\sigma \\sqrt[3]{\\frac{24 * \\sqrt{\\pi}}{n}}\n\nThe binwidth is proportional to the standard deviation of the\ndata and inversely proportional to cube root of ``x.size``. Can\nbe too conservative for small datasets, but is quite good for\nlarge datasets. The standard deviation is not very robust to\noutliers. Values are very similar to the Freedman-Diaconis\nestimator in the absence of outliers.\n\n'rice'\n.. math:: nh = 2n^{1/3}\n\nThe number of bins is only proportional to cube root of\n``a.size``. It tends to overestimate the number of bins and it\ndoes not take into account data variability.\n\n'sturges'\n.. math:: nh = \\log {2}n+1\n\nThe number of bins is the base 2 log of ``a.size``. This\nestimator assumes normality of data and is too conservative for\nlarger, non-normal datasets. This is the default method in R's\n``hist`` method.\n\n'doane'\n.. math:: nh = 1 + \\log{2}(n) +\n\\log{2}(1 + \\frac{|g1|}{\\sigma{g1}})\n\ng1 = mean[(\\frac{x - \\mu}{\\sigma})^3]\n\n\\sigma{g1} = \\sqrt{\\frac{6(n - 2)}{(n + 1)(n + 3)}}\n\nAn improved version of Sturges' formula that produces better\nestimates for non-normal datasets. This estimator attempts to\naccount for the skew of the data.\n\n'sqrt'\n.. math:: nh = \\sqrt n\n\nThe simplest and fastest estimator. Only takes into account the\ndata size.\n\nExamples\n--------\n>>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5])\n>>> np.histogrambinedges(arr, bins='auto', range=(0, 1))\narray([0. , 0.25, 0.5 , 0.75, 1. ])\n>>> np.histogrambinedges(arr, bins=2)\narray([0. , 2.5, 5. ])\n\nFor consistency with histogram, an array of pre-computed bins is\npassed through unmodified:\n\n>>> np.histogrambinedges(arr, [1, 2])\narray([1, 2])\n\nThis function allows one set of bins to be computed, and reused across\nmultiple histograms:\n\n>>> sharedbins = np.histogrambinedges(arr, bins='auto')\n>>> sharedbins\narray([0., 1., 2., 3., 4., 5.])\n\n>>> groupid = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1])\n>>> hist0, = np.histogram(arr[groupid == 0], bins=sharedbins)\n>>> hist1, = np.histogram(arr[groupid == 1], bins=sharedbins)\n\n>>> hist0; hist1\narray([1, 1, 0, 1, 0])\narray([2, 0, 1, 1, 2])\n\nWhich gives more easily comparable results than using separate bins for\neach histogram:\n\n>>> hist0, bins0 = np.histogram(arr[groupid == 0], bins='auto')\n>>> hist1, bins1 = np.histogram(arr[groupid == 1], bins='auto')\n>>> hist0; hist1\narray([1, 1, 1])\narray([2, 1, 1, 2])\n>>> bins0; bins1\narray([0., 1., 2., 3.])\narray([0. , 1.25, 2.5 , 3.75, 5. ])\n" }, { "name": "histogramdd", "content": "Compute the multidimensional histogram of some data.\n\nParameters\n----------\nsample : (N, D) array, or (D, N) arraylike\nThe data to be histogrammed.\n\nNote the unusual interpretation of sample when an arraylike:\n\n* When an array, each row is a coordinate in a D-dimensional space -\nsuch as ``histogramdd(np.array([p1, p2, p3]))``.\n* When an arraylike, each element is the list of values for single\ncoordinate - such as ``histogramdd((X, Y, Z))``.\n\nThe first form should be preferred.\n\nbins : sequence or int, optional\nThe bin specification:\n\n* A sequence of arrays describing the monotonically increasing bin\nedges along each dimension.\n* The number of bins for each dimension (nx, ny, ... =bins)\n* The number of bins for all dimensions (nx=ny=...=bins).\n\nrange : sequence, optional\nA sequence of length D, each an optional (lower, upper) tuple giving\nthe outer bin edges to be used if the edges are not given explicitly in\n`bins`.\nAn entry of None in the sequence results in the minimum and maximum\nvalues being used for the corresponding dimension.\nThe default, None, is equivalent to passing a tuple of D None values.\ndensity : bool, optional\nIf False, the default, returns the number of samples in each bin.\nIf True, returns the probability *density* function at the bin,\n``bincount / samplecount / binvolume``.\nnormed : bool, optional\nAn alias for the density argument that behaves identically. To avoid\nconfusion with the broken normed argument to `histogram`, `density`\nshould be preferred.\nweights : (N,) arraylike, optional\nAn array of values `wi` weighing each sample `(xi, yi, zi, ...)`.\nWeights are normalized to 1 if normed is True. If normed is False,\nthe values of the returned histogram are equal to the sum of the\nweights belonging to the samples falling into each bin.\n\nReturns\n-------\nH : ndarray\nThe multidimensional histogram of sample x. See normed and weights\nfor the different possible semantics.\nedges : list\nA list of D arrays describing the bin edges for each dimension.\n\nSee Also\n--------\nhistogram: 1-D histogram\nhistogram2d: 2-D histogram\n\nExamples\n--------\n>>> r = np.random.randn(100,3)\n>>> H, edges = np.histogramdd(r, bins = (5, 8, 4))\n>>> H.shape, edges[0].size, edges[1].size, edges[2].size\n((5, 8, 4), 6, 9, 5)\n" }, { "name": "hsplit", "content": "Split an array into multiple sub-arrays horizontally (column-wise).\n\nPlease refer to the `split` documentation. `hsplit` is equivalent\nto `split` with ``axis=1``, the array is always split along the second\naxis regardless of the array dimension.\n\nSee Also\n--------\nsplit : Split an array into multiple sub-arrays of equal size.\n\nExamples\n--------\n>>> x = np.arange(16.0).reshape(4, 4)\n>>> x\narray([[ 0., 1., 2., 3.],\n[ 4., 5., 6., 7.],\n[ 8., 9., 10., 11.],\n[12., 13., 14., 15.]])\n>>> np.hsplit(x, 2)\n[array([[ 0., 1.],\n[ 4., 5.],\n[ 8., 9.],\n[12., 13.]]),\narray([[ 2., 3.],\n[ 6., 7.],\n[10., 11.],\n[14., 15.]])]\n>>> np.hsplit(x, np.array([3, 6]))\n[array([[ 0., 1., 2.],\n[ 4., 5., 6.],\n[ 8., 9., 10.],\n[12., 13., 14.]]),\narray([[ 3.],\n[ 7.],\n[11.],\n[15.]]),\narray([], shape=(4, 0), dtype=float64)]\n\nWith a higher dimensional array the split is still along the second axis.\n\n>>> x = np.arange(8.0).reshape(2, 2, 2)\n>>> x\narray([[[0., 1.],\n[2., 3.]],\n[[4., 5.],\n[6., 7.]]])\n>>> np.hsplit(x, 2)\n[array([[[0., 1.]],\n[[4., 5.]]]),\narray([[[2., 3.]],\n[[6., 7.]]])]\n" }, { "name": "hstack", "content": "Stack arrays in sequence horizontally (column wise).\n\nThis is equivalent to concatenation along the second axis, except for 1-D\narrays where it concatenates along the first axis. Rebuilds arrays divided\nby `hsplit`.\n\nThis function makes most sense for arrays with up to 3 dimensions. For\ninstance, for pixel-data with a height (first axis), width (second axis),\nand r/g/b channels (third axis). The functions `concatenate`, `stack` and\n`block` provide more general stacking and concatenation operations.\n\nParameters\n----------\ntup : sequence of ndarrays\nThe arrays must have the same shape along all but the second axis,\nexcept 1-D arrays which can be any length.\n\nReturns\n-------\nstacked : ndarray\nThe array formed by stacking the given arrays.\n\nSee Also\n--------\nconcatenate : Join a sequence of arrays along an existing axis.\nstack : Join a sequence of arrays along a new axis.\nblock : Assemble an nd-array from nested lists of blocks.\nvstack : Stack arrays in sequence vertically (row wise).\ndstack : Stack arrays in sequence depth wise (along third axis).\ncolumnstack : Stack 1-D arrays as columns into a 2-D array.\nhsplit : Split an array into multiple sub-arrays horizontally (column-wise).\n\nExamples\n--------\n>>> a = np.array((1,2,3))\n>>> b = np.array((4,5,6))\n>>> np.hstack((a,b))\narray([1, 2, 3, 4, 5, 6])\n>>> a = np.array([[1],[2],[3]])\n>>> b = np.array([[4],[5],[6]])\n>>> np.hstack((a,b))\narray([[1, 4],\n[2, 5],\n[3, 6]])\n" }, { "name": "i0", "content": "Modified Bessel function of the first kind, order 0.\n\nUsually denoted :math:`I0`.\n\nParameters\n----------\nx : arraylike of float\nArgument of the Bessel function.\n\nReturns\n-------\nout : ndarray, shape = x.shape, dtype = float\nThe modified Bessel function evaluated at each of the elements of `x`.\n\nSee Also\n--------\nscipy.special.i0, scipy.special.iv, scipy.special.ive\n\nNotes\n-----\nThe scipy implementation is recommended over this function: it is a\nproper ufunc written in C, and more than an order of magnitude faster.\n\nWe use the algorithm published by Clenshaw [1] and referenced by\nAbramowitz and Stegun [2], for which the function domain is\npartitioned into the two intervals [0,8] and (8,inf), and Chebyshev\npolynomial expansions are employed in each interval. Relative error on\nthe domain [0,30] using IEEE arithmetic is documented [3] as having a\npeak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).\n\nReferences\n----------\n.. [1] C. W. Clenshaw, \"Chebyshev series for mathematical functions\", in\n*National Physical Laboratory Mathematical Tables*, vol. 5, London:\nHer Majesty's Stationery Office, 1962.\n.. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical\nFunctions*, 10th printing, New York: Dover, 1964, pp. 379.\nhttp://www.math.sfu.ca/~cbm/aands/page379.htm\n.. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero\n\nExamples\n--------\n>>> np.i0(0.)\narray(1.0)\n>>> np.i0([0, 1, 2, 3])\narray([1. , 1.26606588, 2.2795853 , 4.88079259])\n" }, { "name": "identity", "content": "Return the identity array.\n\nThe identity array is a square array with ones on\nthe main diagonal.\n\nParameters\n----------\nn : int\nNumber of rows (and columns) in `n` x `n` output.\ndtype : data-type, optional\nData-type of the output. Defaults to ``float``.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\n`n` x `n` array with its main diagonal set to one,\nand all other elements 0.\n\nExamples\n--------\n>>> np.identity(3)\narray([[1., 0., 0.],\n[0., 1., 0.],\n[0., 0., 1.]])\n" }, { "name": "imag", "content": "Return the imaginary part of the complex argument.\n\nParameters\n----------\nval : arraylike\nInput array.\n\nReturns\n-------\nout : ndarray or scalar\nThe imaginary component of the complex argument. If `val` is real,\nthe type of `val` is used for the output. If `val` has complex\nelements, the returned type is float.\n\nSee Also\n--------\nreal, angle, realifclose\n\nExamples\n--------\n>>> a = np.array([1+2j, 3+4j, 5+6j])\n>>> a.imag\narray([2., 4., 6.])\n>>> a.imag = np.array([8, 10, 12])\n>>> a\narray([1. +8.j, 3.+10.j, 5.+12.j])\n>>> np.imag(1 + 1j)\n1.0\n" }, { "name": "in1d", "content": "Test whether each element of a 1-D array is also present in a second array.\n\nReturns a boolean array the same length as `ar1` that is True\nwhere an element of `ar1` is in `ar2` and False otherwise.\n\nWe recommend using :func:`isin` instead of `in1d` for new code.\n\nParameters\n----------\nar1 : (M,) arraylike\nInput array.\nar2 : arraylike\nThe values against which to test each value of `ar1`.\nassumeunique : bool, optional\nIf True, the input arrays are both assumed to be unique, which\ncan speed up the calculation. Default is False.\ninvert : bool, optional\nIf True, the values in the returned array are inverted (that is,\nFalse where an element of `ar1` is in `ar2` and True otherwise).\nDefault is False. ``np.in1d(a, b, invert=True)`` is equivalent\nto (but is faster than) ``np.invert(in1d(a, b))``.\n\n.. versionadded:: 1.8.0\n\nReturns\n-------\nin1d : (M,) ndarray, bool\nThe values `ar1[in1d]` are in `ar2`.\n\nSee Also\n--------\nisin : Version of this function that preserves the\nshape of ar1.\nnumpy.lib.arraysetops : Module with a number of other functions for\nperforming set operations on arrays.\n\nNotes\n-----\n`in1d` can be considered as an element-wise function version of the\npython keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly\nequivalent to ``np.array([item in b for item in a])``.\nHowever, this idea fails if `ar2` is a set, or similar (non-sequence)\ncontainer: As ``ar2`` is converted to an array, in those cases\n``asarray(ar2)`` is an object array rather than the expected array of\ncontained values.\n\n.. versionadded:: 1.4.0\n\nExamples\n--------\n>>> test = np.array([0, 1, 2, 5, 0])\n>>> states = [0, 2]\n>>> mask = np.in1d(test, states)\n>>> mask\narray([ True, False, True, False, True])\n>>> test[mask]\narray([0, 2, 0])\n>>> mask = np.in1d(test, states, invert=True)\n>>> mask\narray([False, True, False, True, False])\n>>> test[mask]\narray([1, 5])\n" }, { "name": "indices", "content": "Return an array representing the indices of a grid.\n\nCompute an array where the subarrays contain index values 0, 1, ...\nvarying only along the corresponding axis.\n\nParameters\n----------\ndimensions : sequence of ints\nThe shape of the grid.\ndtype : dtype, optional\nData type of the result.\nsparse : boolean, optional\nReturn a sparse representation of the grid instead of a dense\nrepresentation. Default is False.\n\n.. versionadded:: 1.17\n\nReturns\n-------\ngrid : one ndarray or tuple of ndarrays\nIf sparse is False:\nReturns one array of grid indices,\n``grid.shape = (len(dimensions),) + tuple(dimensions)``.\nIf sparse is True:\nReturns a tuple of arrays, with\n``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with\ndimensions[i] in the ith place\n\nSee Also\n--------\nmgrid, ogrid, meshgrid\n\nNotes\n-----\nThe output shape in the dense case is obtained by prepending the number\nof dimensions in front of the tuple of dimensions, i.e. if `dimensions`\nis a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is\n``(N, r0, ..., rN-1)``.\n\nThe subarrays ``grid[k]`` contains the N-D array of indices along the\n``k-th`` axis. Explicitly::\n\ngrid[k, i0, i1, ..., iN-1] = ik\n\nExamples\n--------\n>>> grid = np.indices((2, 3))\n>>> grid.shape\n(2, 2, 3)\n>>> grid[0] # row indices\narray([[0, 0, 0],\n[1, 1, 1]])\n>>> grid[1] # column indices\narray([[0, 1, 2],\n[0, 1, 2]])\n\nThe indices can be used as an index into an array.\n\n>>> x = np.arange(20).reshape(5, 4)\n>>> row, col = np.indices((2, 3))\n>>> x[row, col]\narray([[0, 1, 2],\n[4, 5, 6]])\n\nNote that it would be more straightforward in the above example to\nextract the required elements directly with ``x[:2, :3]``.\n\nIf sparse is set to true, the grid will be returned in a sparse\nrepresentation.\n\n>>> i, j = np.indices((2, 3), sparse=True)\n>>> i.shape\n(2, 1)\n>>> j.shape\n(1, 3)\n>>> i # row indices\narray([[0],\n[1]])\n>>> j # column indices\narray([[0, 1, 2]])\n" }, { "name": "info", "content": "Get help information for a function, class, or module.\n\nParameters\n----------\nobject : object or str, optional\nInput object or name to get information about. If `object` is a\nnumpy object, its docstring is given. If it is a string, available\nmodules are searched for matching objects. If None, information\nabout `info` itself is returned.\nmaxwidth : int, optional\nPrinting width.\noutput : file like object, optional\nFile like object that the output is written to, default is\n``stdout``. The object has to be opened in 'w' or 'a' mode.\ntoplevel : str, optional\nStart search at this level.\n\nSee Also\n--------\nsource, lookfor\n\nNotes\n-----\nWhen used interactively with an object, ``np.info(obj)`` is equivalent\nto ``help(obj)`` on the Python prompt or ``obj?`` on the IPython\nprompt.\n\nExamples\n--------\n>>> np.info(np.polyval) # doctest: +SKIP\npolyval(p, x)\nEvaluate the polynomial p at x.\n...\n\nWhen using a string for `object` it is possible to get multiple results.\n\n>>> np.info('fft') # doctest: +SKIP\n* Found in numpy *\nCore FFT routines\n...\n* Found in numpy.fft *\nfft(a, n=None, axis=-1)\n...\n* Repeat reference found in numpy.fft.fftpack *\n* Total of 3 references found. *\n" }, { "name": "inner", "content": "inner(a, b)\n\nInner product of two arrays.\n\nOrdinary inner product of vectors for 1-D arrays (without complex\nconjugation), in higher dimensions a sum product over the last axes.\n\nParameters\n----------\na, b : arraylike\nIf `a` and `b` are nonscalar, their last dimensions must match.\n\nReturns\n-------\nout : ndarray\nIf `a` and `b` are both\nscalars or both 1-D arrays then a scalar is returned; otherwise\nan array is returned.\n``out.shape = (*a.shape[:-1], *b.shape[:-1])``\n\nRaises\n------\nValueError\nIf both `a` and `b` are nonscalar and their last dimensions have\ndifferent sizes.\n\nSee Also\n--------\ntensordot : Sum products over arbitrary axes.\ndot : Generalised matrix product, using second last dimension of `b`.\neinsum : Einstein summation convention.\n\nNotes\n-----\nFor vectors (1-D arrays) it computes the ordinary inner-product::\n\nnp.inner(a, b) = sum(a[:]*b[:])\n\nMore generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`::\n\nnp.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))\n\nor explicitly::\n\nnp.inner(a, b)[i0,...,ir-2,j0,...,js-2]\n= sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])\n\nIn addition `a` or `b` may be scalars, in which case::\n\nnp.inner(a,b) = a*b\n\nExamples\n--------\nOrdinary inner product for vectors:\n\n>>> a = np.array([1,2,3])\n>>> b = np.array([0,1,0])\n>>> np.inner(a, b)\n2\n\nSome multidimensional examples:\n\n>>> a = np.arange(24).reshape((2,3,4))\n>>> b = np.arange(4)\n>>> c = np.inner(a, b)\n>>> c.shape\n(2, 3)\n>>> c\narray([[ 14, 38, 62],\n[ 86, 110, 134]])\n\n>>> a = np.arange(2).reshape((1,1,2))\n>>> b = np.arange(6).reshape((3,2))\n>>> c = np.inner(a, b)\n>>> c.shape\n(1, 1, 3)\n>>> c\narray([[[1, 3, 5]]])\n\nAn example where `b` is a scalar:\n\n>>> np.inner(np.eye(2), 7)\narray([[7., 0.],\n[0., 7.]])\n" }, { "name": "insert", "content": "Insert values along the given axis before the given indices.\n\nParameters\n----------\narr : arraylike\nInput array.\nobj : int, slice or sequence of ints\nObject that defines the index or indices before which `values` is\ninserted.\n\n.. versionadded:: 1.8.0\n\nSupport for multiple insertions when `obj` is a single scalar or a\nsequence with one element (similar to calling insert multiple\ntimes).\nvalues : arraylike\nValues to insert into `arr`. If the type of `values` is different\nfrom that of `arr`, `values` is converted to the type of `arr`.\n`values` should be shaped so that ``arr[...,obj,...] = values``\nis legal.\naxis : int, optional\nAxis along which to insert `values`. If `axis` is None then `arr`\nis flattened first.\n\nReturns\n-------\nout : ndarray\nA copy of `arr` with `values` inserted. Note that `insert`\ndoes not occur in-place: a new array is returned. If\n`axis` is None, `out` is a flattened array.\n\nSee Also\n--------\nappend : Append elements at the end of an array.\nconcatenate : Join a sequence of arrays along an existing axis.\ndelete : Delete elements from an array.\n\nNotes\n-----\nNote that for higher dimensional inserts `obj=0` behaves very different\nfrom `obj=[0]` just like `arr[:,0,:] = values` is different from\n`arr[:,[0],:] = values`.\n\nExamples\n--------\n>>> a = np.array([[1, 1], [2, 2], [3, 3]])\n>>> a\narray([[1, 1],\n[2, 2],\n[3, 3]])\n>>> np.insert(a, 1, 5)\narray([1, 5, 1, ..., 2, 3, 3])\n>>> np.insert(a, 1, 5, axis=1)\narray([[1, 5, 1],\n[2, 5, 2],\n[3, 5, 3]])\n\nDifference between sequence and scalars:\n\n>>> np.insert(a, [1], [[1],[2],[3]], axis=1)\narray([[1, 1, 1],\n[2, 2, 2],\n[3, 3, 3]])\n>>> np.arrayequal(np.insert(a, 1, [1, 2, 3], axis=1),\n... np.insert(a, [1], [[1],[2],[3]], axis=1))\nTrue\n\n>>> b = a.flatten()\n>>> b\narray([1, 1, 2, 2, 3, 3])\n>>> np.insert(b, [2, 2], [5, 6])\narray([1, 1, 5, ..., 2, 3, 3])\n\n>>> np.insert(b, slice(2, 4), [5, 6])\narray([1, 1, 5, ..., 2, 3, 3])\n\n>>> np.insert(b, [2, 2], [7.13, False]) # type casting\narray([1, 1, 7, ..., 2, 3, 3])\n\n>>> x = np.arange(8).reshape(2, 4)\n>>> idx = (1, 3)\n>>> np.insert(x, idx, 999, axis=1)\narray([[ 0, 999, 1, 2, 999, 3],\n[ 4, 999, 5, 6, 999, 7]])\n" }, { "name": "interp", "content": "One-dimensional linear interpolation for monotonically increasing sample points.\n\nReturns the one-dimensional piecewise linear interpolant to a function\nwith given discrete data points (`xp`, `fp`), evaluated at `x`.\n\nParameters\n----------\nx : arraylike\nThe x-coordinates at which to evaluate the interpolated values.\n\nxp : 1-D sequence of floats\nThe x-coordinates of the data points, must be increasing if argument\n`period` is not specified. Otherwise, `xp` is internally sorted after\nnormalizing the periodic boundaries with ``xp = xp % period``.\n\nfp : 1-D sequence of float or complex\nThe y-coordinates of the data points, same length as `xp`.\n\nleft : optional float or complex corresponding to fp\nValue to return for `x < xp[0]`, default is `fp[0]`.\n\nright : optional float or complex corresponding to fp\nValue to return for `x > xp[-1]`, default is `fp[-1]`.\n\nperiod : None or float, optional\nA period for the x-coordinates. This parameter allows the proper\ninterpolation of angular x-coordinates. Parameters `left` and `right`\nare ignored if `period` is specified.\n\n.. versionadded:: 1.10.0\n\nReturns\n-------\ny : float or complex (corresponding to fp) or ndarray\nThe interpolated values, same shape as `x`.\n\nRaises\n------\nValueError\nIf `xp` and `fp` have different length\nIf `xp` or `fp` are not 1-D sequences\nIf `period == 0`\n\nSee Also\n--------\nscipy.interpolate\n\nWarnings\n--------\nThe x-coordinate sequence is expected to be increasing, but this is not\nexplicitly enforced. However, if the sequence `xp` is non-increasing,\ninterpolation results are meaningless.\n\nNote that, since NaN is unsortable, `xp` also cannot contain NaNs.\n\nA simple check for `xp` being strictly increasing is::\n\nnp.all(np.diff(xp) > 0)\n\nExamples\n--------\n>>> xp = [1, 2, 3]\n>>> fp = [3, 2, 0]\n>>> np.interp(2.5, xp, fp)\n1.0\n>>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)\narray([3. , 3. , 2.5 , 0.56, 0. ])\n>>> UNDEF = -99.0\n>>> np.interp(3.14, xp, fp, right=UNDEF)\n-99.0\n\nPlot an interpolant to the sine function:\n\n>>> x = np.linspace(0, 2*np.pi, 10)\n>>> y = np.sin(x)\n>>> xvals = np.linspace(0, 2*np.pi, 50)\n>>> yinterp = np.interp(xvals, x, y)\n>>> import matplotlib.pyplot as plt\n>>> plt.plot(x, y, 'o')\n[]\n>>> plt.plot(xvals, yinterp, '-x')\n[]\n>>> plt.show()\n\nInterpolation with periodic x-coordinates:\n\n>>> x = [-180, -170, -185, 185, -10, -5, 0, 365]\n>>> xp = [190, -190, 350, -350]\n>>> fp = [5, 10, 3, 4]\n>>> np.interp(x, xp, fp, period=360)\narray([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75])\n\nComplex interpolation:\n\n>>> x = [1.5, 4.0]\n>>> xp = [2,3,5]\n>>> fp = [1.0j, 0, 2+3j]\n>>> np.interp(x, xp, fp)\narray([0.+1.j , 1.+1.5j])\n" }, { "name": "intersect1d", "content": "Find the intersection of two arrays.\n\nReturn the sorted, unique values that are in both of the input arrays.\n\nParameters\n----------\nar1, ar2 : arraylike\nInput arrays. Will be flattened if not already 1D.\nassumeunique : bool\nIf True, the input arrays are both assumed to be unique, which\ncan speed up the calculation. If True but ``ar1`` or ``ar2`` are not\nunique, incorrect results and out-of-bounds indices could result.\nDefault is False.\nreturnindices : bool\nIf True, the indices which correspond to the intersection of the two\narrays are returned. The first instance of a value is used if there are\nmultiple. Default is False.\n\n.. versionadded:: 1.15.0\n\nReturns\n-------\nintersect1d : ndarray\nSorted 1D array of common and unique elements.\ncomm1 : ndarray\nThe indices of the first occurrences of the common values in `ar1`.\nOnly provided if `returnindices` is True.\ncomm2 : ndarray\nThe indices of the first occurrences of the common values in `ar2`.\nOnly provided if `returnindices` is True.\n\n\nSee Also\n--------\nnumpy.lib.arraysetops : Module with a number of other functions for\nperforming set operations on arrays.\n\nExamples\n--------\n>>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])\narray([1, 3])\n\nTo intersect more than two arrays, use functools.reduce:\n\n>>> from functools import reduce\n>>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))\narray([3])\n\nTo return the indices of the values common to the input arrays\nalong with the intersected values:\n\n>>> x = np.array([1, 1, 2, 3, 4])\n>>> y = np.array([2, 1, 4, 6])\n>>> xy, xind, yind = np.intersect1d(x, y, returnindices=True)\n>>> xind, yind\n(array([0, 2, 4]), array([1, 0, 2]))\n>>> xy, x[xind], y[yind]\n(array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))\n" }, { "name": "is_busday", "content": "isbusday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)\n\nCalculates which of the given dates are valid days, and which are not.\n\n.. versionadded:: 1.7.0\n\nParameters\n----------\ndates : arraylike of datetime64[D]\nThe array of dates to process.\nweekmask : str or arraylike of bool, optional\nA seven-element array indicating which of Monday through Sunday are\nvalid days. May be specified as a length-seven list or array, like\n[1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string\nlike \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for\nweekdays, optionally separated by white space. Valid abbreviations\nare: Mon Tue Wed Thu Fri Sat Sun\nholidays : arraylike of datetime64[D], optional\nAn array of dates to consider as invalid dates. They may be\nspecified in any order, and NaT (not-a-time) dates are ignored.\nThis list is saved in a normalized form that is suited for\nfast calculations of valid days.\nbusdaycal : busdaycalendar, optional\nA `busdaycalendar` object which specifies the valid days. If this\nparameter is provided, neither weekmask nor holidays may be\nprovided.\nout : array of bool, optional\nIf provided, this array is filled with the result.\n\nReturns\n-------\nout : array of bool\nAn array with the same shape as ``dates``, containing True for\neach valid day, and False for each invalid day.\n\nSee Also\n--------\nbusdaycalendar : An object that specifies a custom set of valid days.\nbusdayoffset : Applies an offset counted in valid days.\nbusdaycount : Counts how many valid days are in a half-open date range.\n\nExamples\n--------\n>>> # The weekdays are Friday, Saturday, and Monday\n... np.isbusday(['2011-07-01', '2011-07-02', '2011-07-18'],\n... holidays=['2011-07-01', '2011-07-04', '2011-07-17'])\narray([False, False, True])\n" }, { "name": "isclose", "content": "Returns a boolean array where two arrays are element-wise equal within a\ntolerance.\n\nThe tolerance values are positive, typically very small numbers. The\nrelative difference (`rtol` * abs(`b`)) and the absolute difference\n`atol` are added together to compare against the absolute difference\nbetween `a` and `b`.\n\n.. warning:: The default `atol` is not appropriate for comparing numbers\nthat are much smaller than one (see Notes).\n\nParameters\n----------\na, b : arraylike\nInput arrays to compare.\nrtol : float\nThe relative tolerance parameter (see Notes).\natol : float\nThe absolute tolerance parameter (see Notes).\nequalnan : bool\nWhether to compare NaN's as equal. If True, NaN's in `a` will be\nconsidered equal to NaN's in `b` in the output array.\n\nReturns\n-------\ny : arraylike\nReturns a boolean array of where `a` and `b` are equal within the\ngiven tolerance. If both `a` and `b` are scalars, returns a single\nboolean value.\n\nSee Also\n--------\nallclose\nmath.isclose\n\nNotes\n-----\n.. versionadded:: 1.7.0\n\nFor finite values, isclose uses the following equation to test whether\ntwo floating point values are equivalent.\n\nabsolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))\n\nUnlike the built-in `math.isclose`, the above equation is not symmetric\nin `a` and `b` -- it assumes `b` is the reference value -- so that\n`isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,\nthe default value of atol is not zero, and is used to determine what\nsmall values should be considered close to zero. The default value is\nappropriate for expected values of order unity: if the expected values\nare significantly smaller than one, it can result in false positives.\n`atol` should be carefully selected for the use case at hand. A zero value\nfor `atol` will result in `False` if either `a` or `b` is zero.\n\n`isclose` is not defined for non-numeric data types.\n\nExamples\n--------\n>>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])\narray([ True, False])\n>>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])\narray([ True, True])\n>>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])\narray([False, True])\n>>> np.isclose([1.0, np.nan], [1.0, np.nan])\narray([ True, False])\n>>> np.isclose([1.0, np.nan], [1.0, np.nan], equalnan=True)\narray([ True, True])\n>>> np.isclose([1e-8, 1e-7], [0.0, 0.0])\narray([ True, False])\n>>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)\narray([False, False])\n>>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])\narray([ True, True])\n>>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)\narray([False, True])\n" }, { "name": "iscomplex", "content": "Returns a bool array, where True if input element is complex.\n\nWhat is tested is whether the input has a non-zero imaginary part, not if\nthe input type is complex.\n\nParameters\n----------\nx : arraylike\nInput array.\n\nReturns\n-------\nout : ndarray of bools\nOutput array.\n\nSee Also\n--------\nisreal\niscomplexobj : Return True if x is a complex type or an array of complex\nnumbers.\n\nExamples\n--------\n>>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])\narray([ True, False, False, False, False, True])\n" }, { "name": "iscomplexobj", "content": "Check for a complex type or an array of complex numbers.\n\nThe type of the input is checked, not the value. Even if the input\nhas an imaginary part equal to zero, `iscomplexobj` evaluates to True.\n\nParameters\n----------\nx : any\nThe input can be of any type and shape.\n\nReturns\n-------\niscomplexobj : bool\nThe return value, True if `x` is of a complex type or has at least\none complex element.\n\nSee Also\n--------\nisrealobj, iscomplex\n\nExamples\n--------\n>>> np.iscomplexobj(1)\nFalse\n>>> np.iscomplexobj(1+0j)\nTrue\n>>> np.iscomplexobj([3, 1+0j, True])\nTrue\n" }, { "name": "isfortran", "content": "Check if the array is Fortran contiguous but *not* C contiguous.\n\nThis function is obsolete and, because of changes due to relaxed stride\nchecking, its return value for the same array may differ for versions\nof NumPy >= 1.10.0 and previous versions. If you only want to check if an\narray is Fortran contiguous use ``a.flags.fcontiguous`` instead.\n\nParameters\n----------\na : ndarray\nInput array.\n\nReturns\n-------\nisfortran : bool\nReturns True if the array is Fortran contiguous but *not* C contiguous.\n\n\nExamples\n--------\n\nnp.array allows to specify whether the array is written in C-contiguous\norder (last index varies the fastest), or FORTRAN-contiguous order in\nmemory (first index varies the fastest).\n\n>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')\n>>> a\narray([[1, 2, 3],\n[4, 5, 6]])\n>>> np.isfortran(a)\nFalse\n\n>>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')\n>>> b\narray([[1, 2, 3],\n[4, 5, 6]])\n>>> np.isfortran(b)\nTrue\n\n\nThe transpose of a C-ordered array is a FORTRAN-ordered array.\n\n>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')\n>>> a\narray([[1, 2, 3],\n[4, 5, 6]])\n>>> np.isfortran(a)\nFalse\n>>> b = a.T\n>>> b\narray([[1, 4],\n[2, 5],\n[3, 6]])\n>>> np.isfortran(b)\nTrue\n\nC-ordered arrays evaluate as False even if they are also FORTRAN-ordered.\n\n>>> np.isfortran(np.array([1, 2], order='F'))\nFalse\n" }, { "name": "isin", "content": "Calculates `element in testelements`, broadcasting over `element` only.\nReturns a boolean array of the same shape as `element` that is True\nwhere an element of `element` is in `testelements` and False otherwise.\n\nParameters\n----------\nelement : arraylike\nInput array.\ntestelements : arraylike\nThe values against which to test each value of `element`.\nThis argument is flattened if it is an array or arraylike.\nSee notes for behavior with non-array-like parameters.\nassumeunique : bool, optional\nIf True, the input arrays are both assumed to be unique, which\ncan speed up the calculation. Default is False.\ninvert : bool, optional\nIf True, the values in the returned array are inverted, as if\ncalculating `element not in testelements`. Default is False.\n``np.isin(a, b, invert=True)`` is equivalent to (but faster\nthan) ``np.invert(np.isin(a, b))``.\n\nReturns\n-------\nisin : ndarray, bool\nHas the same shape as `element`. The values `element[isin]`\nare in `testelements`.\n\nSee Also\n--------\nin1d : Flattened version of this function.\nnumpy.lib.arraysetops : Module with a number of other functions for\nperforming set operations on arrays.\n\nNotes\n-----\n\n`isin` is an element-wise function version of the python keyword `in`.\n``isin(a, b)`` is roughly equivalent to\n``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.\n\n`element` and `testelements` are converted to arrays if they are not\nalready. If `testelements` is a set (or other non-sequence collection)\nit will be converted to an object array with one element, rather than an\narray of the values contained in `testelements`. This is a consequence\nof the `array` constructor's way of handling non-sequence collections.\nConverting the set to a list usually gives the desired behavior.\n\n.. versionadded:: 1.13.0\n\nExamples\n--------\n>>> element = 2*np.arange(4).reshape((2, 2))\n>>> element\narray([[0, 2],\n[4, 6]])\n>>> testelements = [1, 2, 4, 8]\n>>> mask = np.isin(element, testelements)\n>>> mask\narray([[False, True],\n[ True, False]])\n>>> element[mask]\narray([2, 4])\n\nThe indices of the matched values can be obtained with `nonzero`:\n\n>>> np.nonzero(mask)\n(array([0, 1]), array([1, 0]))\n\nThe test can also be inverted:\n\n>>> mask = np.isin(element, testelements, invert=True)\n>>> mask\narray([[ True, False],\n[False, True]])\n>>> element[mask]\narray([0, 6])\n\nBecause of how `array` handles sets, the following does not\nwork as expected:\n\n>>> testset = {1, 2, 4, 8}\n>>> np.isin(element, testset)\narray([[False, False],\n[False, False]])\n\nCasting the set to a list gives the expected result:\n\n>>> np.isin(element, list(testset))\narray([[False, True],\n[ True, False]])\n" }, { "name": "isneginf", "content": "Test element-wise for negative infinity, return result as bool array.\n\nParameters\n----------\nx : arraylike\nThe input array.\nout : arraylike, optional\nA location into which the result is stored. If provided, it must have a\nshape that the input broadcasts to. If not provided or None, a\nfreshly-allocated boolean array is returned.\n\nReturns\n-------\nout : ndarray\nA boolean array with the same dimensions as the input.\nIf second argument is not supplied then a numpy boolean array is\nreturned with values True where the corresponding element of the\ninput is negative infinity and values False where the element of\nthe input is not negative infinity.\n\nIf a second argument is supplied the result is stored there. If the\ntype of that array is a numeric type the result is represented as\nzeros and ones, if the type is boolean then as False and True. The\nreturn value `out` is then a reference to that array.\n\nSee Also\n--------\nisinf, isposinf, isnan, isfinite\n\nNotes\n-----\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754).\n\nErrors result if the second argument is also supplied when x is a scalar\ninput, if first and second arguments have different shapes, or if the\nfirst argument has complex values.\n\nExamples\n--------\n>>> np.isneginf(np.NINF)\nTrue\n>>> np.isneginf(np.inf)\nFalse\n>>> np.isneginf(np.PINF)\nFalse\n>>> np.isneginf([-np.inf, 0., np.inf])\narray([ True, False, False])\n\n>>> x = np.array([-np.inf, 0., np.inf])\n>>> y = np.array([2, 2, 2])\n>>> np.isneginf(x, y)\narray([1, 0, 0])\n>>> y\narray([1, 0, 0])\n" }, { "name": "isposinf", "content": "Test element-wise for positive infinity, return result as bool array.\n\nParameters\n----------\nx : arraylike\nThe input array.\nout : arraylike, optional\nA location into which the result is stored. If provided, it must have a\nshape that the input broadcasts to. If not provided or None, a\nfreshly-allocated boolean array is returned.\n\nReturns\n-------\nout : ndarray\nA boolean array with the same dimensions as the input.\nIf second argument is not supplied then a boolean array is returned\nwith values True where the corresponding element of the input is\npositive infinity and values False where the element of the input is\nnot positive infinity.\n\nIf a second argument is supplied the result is stored there. If the\ntype of that array is a numeric type the result is represented as zeros\nand ones, if the type is boolean then as False and True.\nThe return value `out` is then a reference to that array.\n\nSee Also\n--------\nisinf, isneginf, isfinite, isnan\n\nNotes\n-----\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754).\n\nErrors result if the second argument is also supplied when x is a scalar\ninput, if first and second arguments have different shapes, or if the\nfirst argument has complex values\n\nExamples\n--------\n>>> np.isposinf(np.PINF)\nTrue\n>>> np.isposinf(np.inf)\nTrue\n>>> np.isposinf(np.NINF)\nFalse\n>>> np.isposinf([-np.inf, 0., np.inf])\narray([False, False, True])\n\n>>> x = np.array([-np.inf, 0., np.inf])\n>>> y = np.array([2, 2, 2])\n>>> np.isposinf(x, y)\narray([0, 0, 1])\n>>> y\narray([0, 0, 1])\n" }, { "name": "isreal", "content": "Returns a bool array, where True if input element is real.\n\nIf element has complex type with zero complex part, the return value\nfor that element is True.\n\nParameters\n----------\nx : arraylike\nInput array.\n\nReturns\n-------\nout : ndarray, bool\nBoolean array of same shape as `x`.\n\nNotes\n-----\n`isreal` may behave unexpectedly for string or object arrays (see examples)\n\nSee Also\n--------\niscomplex\nisrealobj : Return True if x is not a complex type.\n\nExamples\n--------\n>>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)\n>>> np.isreal(a)\narray([False, True, True, True, True, False])\n\nThe function does not work on string arrays.\n\n>>> a = np.array([2j, \"a\"], dtype=\"U\")\n>>> np.isreal(a) # Warns about non-elementwise comparison\nFalse\n\nReturns True for all elements in input array of ``dtype=object`` even if\nany of the elements is complex.\n\n>>> a = np.array([1, \"2\", 3+4j], dtype=object)\n>>> np.isreal(a)\narray([ True, True, True])\n\nisreal should not be used with object arrays\n\n>>> a = np.array([1+2j, 2+1j], dtype=object)\n>>> np.isreal(a)\narray([ True, True])\n" }, { "name": "isrealobj", "content": "Return True if x is a not complex type or an array of complex numbers.\n\nThe type of the input is checked, not the value. So even if the input\nhas an imaginary part equal to zero, `isrealobj` evaluates to False\nif the data type is complex.\n\nParameters\n----------\nx : any\nThe input can be of any type and shape.\n\nReturns\n-------\ny : bool\nThe return value, False if `x` is of a complex type.\n\nSee Also\n--------\niscomplexobj, isreal\n\nNotes\n-----\nThe function is only meant for arrays with numerical values but it\naccepts all other objects. Since it assumes array input, the return\nvalue of other objects may be True.\n\n>>> np.isrealobj('A string')\nTrue\n>>> np.isrealobj(False)\nTrue\n>>> np.isrealobj(None)\nTrue\n\nExamples\n--------\n>>> np.isrealobj(1)\nTrue\n>>> np.isrealobj(1+0j)\nFalse\n>>> np.isrealobj([3, 1+0j, True])\nFalse\n" }, { "name": "isscalar", "content": "Returns True if the type of `element` is a scalar type.\n\nParameters\n----------\nelement : any\nInput argument, can be of any type and shape.\n\nReturns\n-------\nval : bool\nTrue if `element` is a scalar type, False if it is not.\n\nSee Also\n--------\nndim : Get the number of dimensions of an array\n\nNotes\n-----\nIf you need a stricter way to identify a *numerical* scalar, use\n``isinstance(x, numbers.Number)``, as that returns ``False`` for most\nnon-numerical elements such as strings.\n\nIn most cases ``np.ndim(x) == 0`` should be used instead of this function,\nas that will also return true for 0d arrays. This is how numpy overloads\nfunctions in the style of the ``dx`` arguments to `gradient` and the ``bins``\nargument to `histogram`. Some key differences:\n\n+--------------------------------------+---------------+-------------------+\n| x |``isscalar(x)``|``np.ndim(x) == 0``|\n+======================================+===============+===================+\n| PEP 3141 numeric objects (including | ``True`` | ``True`` |\n| builtins) | | |\n+--------------------------------------+---------------+-------------------+\n| builtin string and buffer objects | ``True`` | ``True`` |\n+--------------------------------------+---------------+-------------------+\n| other builtin objects, like | ``False`` | ``True`` |\n| `pathlib.Path`, `Exception`, | | |\n| the result of `re.compile` | | |\n+--------------------------------------+---------------+-------------------+\n| third-party objects like | ``False`` | ``True`` |\n| `matplotlib.figure.Figure` | | |\n+--------------------------------------+---------------+-------------------+\n| zero-dimensional numpy arrays | ``False`` | ``True`` |\n+--------------------------------------+---------------+-------------------+\n| other numpy arrays | ``False`` | ``False`` |\n+--------------------------------------+---------------+-------------------+\n| `list`, `tuple`, and other sequence | ``False`` | ``False`` |\n| objects | | |\n+--------------------------------------+---------------+-------------------+\n\nExamples\n--------\n>>> np.isscalar(3.1)\nTrue\n>>> np.isscalar(np.array(3.1))\nFalse\n>>> np.isscalar([3.1])\nFalse\n>>> np.isscalar(False)\nTrue\n>>> np.isscalar('numpy')\nTrue\n\nNumPy supports PEP 3141 numbers:\n\n>>> from fractions import Fraction\n>>> np.isscalar(Fraction(5, 17))\nTrue\n>>> from numbers import Number\n>>> np.isscalar(Number())\nTrue\n" }, { "name": "issctype", "content": "Determines whether the given object represents a scalar data-type.\n\nParameters\n----------\nrep : any\nIf `rep` is an instance of a scalar dtype, True is returned. If not,\nFalse is returned.\n\nReturns\n-------\nout : bool\nBoolean result of check whether `rep` is a scalar dtype.\n\nSee Also\n--------\nissubsctype, issubdtype, obj2sctype, sctype2char\n\nExamples\n--------\n>>> np.issctype(np.int32)\nTrue\n>>> np.issctype(list)\nFalse\n>>> np.issctype(1.1)\nFalse\n\nStrings are also a scalar type:\n\n>>> np.issctype(np.dtype('str'))\nTrue\n" }, { "name": "issubclass_", "content": "Determine if a class is a subclass of a second class.\n\n`issubclass` is equivalent to the Python built-in ``issubclass``,\nexcept that it returns False instead of raising a TypeError if one\nof the arguments is not a class.\n\nParameters\n----------\narg1 : class\nInput class. True is returned if `arg1` is a subclass of `arg2`.\narg2 : class or tuple of classes.\nInput class. If a tuple of classes, True is returned if `arg1` is a\nsubclass of any of the tuple elements.\n\nReturns\n-------\nout : bool\nWhether `arg1` is a subclass of `arg2` or not.\n\nSee Also\n--------\nissubsctype, issubdtype, issctype\n\nExamples\n--------\n>>> np.issubclass(np.int32, int)\nFalse\n>>> np.issubclass(np.int32, float)\nFalse\n>>> np.issubclass(np.float64, float)\nTrue\n" }, { "name": "issubdtype", "content": "Returns True if first argument is a typecode lower/equal in type hierarchy.\n\nThis is like the builtin :func:`issubclass`, but for `dtype`\\ s.\n\nParameters\n----------\narg1, arg2 : dtypelike\n`dtype` or object coercible to one\n\nReturns\n-------\nout : bool\n\nSee Also\n--------\n:ref:`arrays.scalars` : Overview of the numpy type hierarchy.\nissubsctype, issubclass\n\nExamples\n--------\n`issubdtype` can be used to check the type of arrays:\n\n>>> ints = np.array([1, 2, 3], dtype=np.int32)\n>>> np.issubdtype(ints.dtype, np.integer)\nTrue\n>>> np.issubdtype(ints.dtype, np.floating)\nFalse\n\n>>> floats = np.array([1, 2, 3], dtype=np.float32)\n>>> np.issubdtype(floats.dtype, np.integer)\nFalse\n>>> np.issubdtype(floats.dtype, np.floating)\nTrue\n\nSimilar types of different sizes are not subdtypes of each other:\n\n>>> np.issubdtype(np.float64, np.float32)\nFalse\n>>> np.issubdtype(np.float32, np.float64)\nFalse\n\nbut both are subtypes of `floating`:\n\n>>> np.issubdtype(np.float64, np.floating)\nTrue\n>>> np.issubdtype(np.float32, np.floating)\nTrue\n\nFor convenience, dtype-like objects are allowed too:\n\n>>> np.issubdtype('S1', np.string)\nTrue\n>>> np.issubdtype('i4', np.signedinteger)\nTrue\n" }, { "name": "issubsctype", "content": "Determine if the first argument is a subclass of the second argument.\n\nParameters\n----------\narg1, arg2 : dtype or dtype specifier\nData-types.\n\nReturns\n-------\nout : bool\nThe result.\n\nSee Also\n--------\nissctype, issubdtype, obj2sctype\n\nExamples\n--------\n>>> np.issubsctype('S8', str)\nFalse\n>>> np.issubsctype(np.array([1]), int)\nTrue\n>>> np.issubsctype(np.array([1]), float)\nFalse\n" }, { "name": "iterable", "content": "Check whether or not an object can be iterated over.\n\nParameters\n----------\ny : object\nInput object.\n\nReturns\n-------\nb : bool\nReturn ``True`` if the object has an iterator method or is a\nsequence and ``False`` otherwise.\n\n\nExamples\n--------\n>>> np.iterable([1, 2, 3])\nTrue\n>>> np.iterable(2)\nFalse\n" }, { "name": "ix_", "content": "Construct an open mesh from multiple sequences.\n\nThis function takes N 1-D sequences and returns N outputs with N\ndimensions each, such that the shape is 1 in all but one dimension\nand the dimension with the non-unit shape value cycles through all\nN dimensions.\n\nUsing `ix` one can quickly construct index arrays that will index\nthe cross product. ``a[np.ix([1,3],[2,5])]`` returns the array\n``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.\n\nParameters\n----------\nargs : 1-D sequences\nEach sequence should be of integer or boolean type.\nBoolean sequences will be interpreted as boolean masks for the\ncorresponding dimension (equivalent to passing in\n``np.nonzero(booleansequence)``).\n\nReturns\n-------\nout : tuple of ndarrays\nN arrays with N dimensions each, with N the number of input\nsequences. Together these arrays form an open mesh.\n\nSee Also\n--------\nogrid, mgrid, meshgrid\n\nExamples\n--------\n>>> a = np.arange(10).reshape(2, 5)\n>>> a\narray([[0, 1, 2, 3, 4],\n[5, 6, 7, 8, 9]])\n>>> ixgrid = np.ix([0, 1], [2, 4])\n>>> ixgrid\n(array([[0],\n[1]]), array([[2, 4]]))\n>>> ixgrid[0].shape, ixgrid[1].shape\n((2, 1), (1, 2))\n>>> a[ixgrid]\narray([[2, 4],\n[7, 9]])\n\n>>> ixgrid = np.ix([True, True], [2, 4])\n>>> a[ixgrid]\narray([[2, 4],\n[7, 9]])\n>>> ixgrid = np.ix([True, True], [False, False, True, False, True])\n>>> a[ixgrid]\narray([[2, 4],\n[7, 9]])\n" }, { "name": "kaiser", "content": "Return the Kaiser window.\n\nThe Kaiser window is a taper formed by using a Bessel function.\n\nParameters\n----------\nM : int\nNumber of points in the output window. If zero or less, an\nempty array is returned.\nbeta : float\nShape parameter for window.\n\nReturns\n-------\nout : array\nThe window, with the maximum value normalized to one (the value\none appears only if the number of samples is odd).\n\nSee Also\n--------\nbartlett, blackman, hamming, hanning\n\nNotes\n-----\nThe Kaiser window is defined as\n\n.. math:: w(n) = I0\\left( \\beta \\sqrt{1-\\frac{4n^2}{(M-1)^2}}\n\\right)/I0(\\beta)\n\nwith\n\n.. math:: \\quad -\\frac{M-1}{2} \\leq n \\leq \\frac{M-1}{2},\n\nwhere :math:`I0` is the modified zeroth-order Bessel function.\n\nThe Kaiser was named for Jim Kaiser, who discovered a simple\napproximation to the DPSS window based on Bessel functions. The Kaiser\nwindow is a very good approximation to the Digital Prolate Spheroidal\nSequence, or Slepian window, which is the transform which maximizes the\nenergy in the main lobe of the window relative to total energy.\n\nThe Kaiser can approximate many other windows by varying the beta\nparameter.\n\n==== =======================\nbeta Window shape\n==== =======================\n0 Rectangular\n5 Similar to a Hamming\n6 Similar to a Hanning\n8.6 Similar to a Blackman\n==== =======================\n\nA beta value of 14 is probably a good starting point. Note that as beta\ngets large, the window narrows, and so the number of samples needs to be\nlarge enough to sample the increasingly narrow spike, otherwise NaNs will\nget returned.\n\nMost references to the Kaiser window come from the signal processing\nliterature, where it is used as one of many windowing functions for\nsmoothing values. It is also known as an apodization (which means\n\"removing the foot\", i.e. smoothing discontinuities at the beginning\nand end of the sampled signal) or tapering function.\n\nReferences\n----------\n.. [1] J. F. Kaiser, \"Digital Filters\" - Ch 7 in \"Systems analysis by\ndigital computer\", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.\nJohn Wiley and Sons, New York, (1966).\n.. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The\nUniversity of Alberta Press, 1975, pp. 177-178.\n.. [3] Wikipedia, \"Window function\",\nhttps://en.wikipedia.org/wiki/Windowfunction\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> np.kaiser(12, 14)\narray([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary\n2.29737120e-01, 5.99885316e-01, 9.45674898e-01,\n9.45674898e-01, 5.99885316e-01, 2.29737120e-01,\n4.65200189e-02, 3.46009194e-03, 7.72686684e-06])\n\n\nPlot the window and the frequency response:\n\n>>> from numpy.fft import fft, fftshift\n>>> window = np.kaiser(51, 14)\n>>> plt.plot(window)\n[]\n>>> plt.title(\"Kaiser window\")\nText(0.5, 1.0, 'Kaiser window')\n>>> plt.ylabel(\"Amplitude\")\nText(0, 0.5, 'Amplitude')\n>>> plt.xlabel(\"Sample\")\nText(0.5, 0, 'Sample')\n>>> plt.show()\n\n>>> plt.figure()\n
\n>>> A = fft(window, 2048) / 25.5\n>>> mag = np.abs(fftshift(A))\n>>> freq = np.linspace(-0.5, 0.5, len(A))\n>>> response = 20 * np.log10(mag)\n>>> response = np.clip(response, -100, 100)\n>>> plt.plot(freq, response)\n[]\n>>> plt.title(\"Frequency response of Kaiser window\")\nText(0.5, 1.0, 'Frequency response of Kaiser window')\n>>> plt.ylabel(\"Magnitude [dB]\")\nText(0, 0.5, 'Magnitude [dB]')\n>>> plt.xlabel(\"Normalized frequency [cycles per sample]\")\nText(0.5, 0, 'Normalized frequency [cycles per sample]')\n>>> plt.axis('tight')\n(-0.5, 0.5, -100.0, ...) # may vary\n>>> plt.show()\n" }, { "name": "kron", "content": "Kronecker product of two arrays.\n\nComputes the Kronecker product, a composite array made of blocks of the\nsecond array scaled by the first.\n\nParameters\n----------\na, b : arraylike\n\nReturns\n-------\nout : ndarray\n\nSee Also\n--------\nouter : The outer product\n\nNotes\n-----\nThe function assumes that the number of dimensions of `a` and `b`\nare the same, if necessary prepending the smallest with ones.\nIf ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``,\nthe Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``.\nThe elements are products of elements from `a` and `b`, organized\nexplicitly by::\n\nkron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]\n\nwhere::\n\nkt = it * st + jt, t = 0,...,N\n\nIn the common 2-D case (N=1), the block structure can be visualized::\n\n[[ a[0,0]*b, a[0,1]*b, ... , a[0,-1]*b ],\n[ ... ... ],\n[ a[-1,0]*b, a[-1,1]*b, ... , a[-1,-1]*b ]]\n\n\nExamples\n--------\n>>> np.kron([1,10,100], [5,6,7])\narray([ 5, 6, 7, ..., 500, 600, 700])\n>>> np.kron([5,6,7], [1,10,100])\narray([ 5, 50, 500, ..., 7, 70, 700])\n\n>>> np.kron(np.eye(2), np.ones((2,2)))\narray([[1., 1., 0., 0.],\n[1., 1., 0., 0.],\n[0., 0., 1., 1.],\n[0., 0., 1., 1.]])\n\n>>> a = np.arange(100).reshape((2,5,2,5))\n>>> b = np.arange(24).reshape((2,3,4))\n>>> c = np.kron(a,b)\n>>> c.shape\n(2, 10, 6, 20)\n>>> I = (1,3,0,2)\n>>> J = (0,2,1)\n>>> J1 = (0,) + J # extend to ndim=4\n>>> S1 = (1,) + b.shape\n>>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))\n>>> c[K] == a[I]*b[J]\nTrue\n" }, { "name": "lexsort", "content": "lexsort(keys, axis=-1)\n\nPerform an indirect stable sort using a sequence of keys.\n\nGiven multiple sorting keys, which can be interpreted as columns in a\nspreadsheet, lexsort returns an array of integer indices that describes\nthe sort order by multiple columns. The last key in the sequence is used\nfor the primary sort order, the second-to-last key for the secondary sort\norder, and so on. The keys argument must be a sequence of objects that\ncan be converted to arrays of the same shape. If a 2D array is provided\nfor the keys argument, its rows are interpreted as the sorting keys and\nsorting is according to the last row, second last row etc.\n\nParameters\n----------\nkeys : (k, N) array or tuple containing k (N,)-shaped sequences\nThe `k` different \"columns\" to be sorted. The last column (or row if\n`keys` is a 2D array) is the primary sort key.\naxis : int, optional\nAxis to be indirectly sorted. By default, sort over the last axis.\n\nReturns\n-------\nindices : (N,) ndarray of ints\nArray of indices that sort the keys along the specified axis.\n\nSee Also\n--------\nargsort : Indirect sort.\nndarray.sort : In-place sort.\nsort : Return a sorted copy of an array.\n\nExamples\n--------\nSort names: first by surname, then by name.\n\n>>> surnames = ('Hertz', 'Galilei', 'Hertz')\n>>> firstnames = ('Heinrich', 'Galileo', 'Gustav')\n>>> ind = np.lexsort((firstnames, surnames))\n>>> ind\narray([1, 2, 0])\n\n>>> [surnames[i] + \", \" + firstnames[i] for i in ind]\n['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']\n\nSort two columns of numbers:\n\n>>> a = [1,5,1,4,3,4,4] # First column\n>>> b = [9,4,0,4,0,2,1] # Second column\n>>> ind = np.lexsort((b,a)) # Sort by a, then by b\n>>> ind\narray([2, 0, 4, 6, 5, 3, 1])\n\n>>> [(a[i],b[i]) for i in ind]\n[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]\n\nNote that sorting is first according to the elements of ``a``.\nSecondary sorting is according to the elements of ``b``.\n\nA normal ``argsort`` would have yielded:\n\n>>> [(a[i],b[i]) for i in np.argsort(a)]\n[(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]\n\nStructured arrays are sorted lexically by ``argsort``:\n\n>>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],\n... dtype=np.dtype([('x', int), ('y', int)]))\n\n>>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))\narray([2, 0, 4, 6, 5, 3, 1])\n" }, { "name": "linspace", "content": "Return evenly spaced numbers over a specified interval.\n\nReturns `num` evenly spaced samples, calculated over the\ninterval [`start`, `stop`].\n\nThe endpoint of the interval can optionally be excluded.\n\n.. versionchanged:: 1.16.0\nNon-scalar `start` and `stop` are now supported.\n\n.. versionchanged:: 1.20.0\nValues are rounded towards ``-inf`` instead of ``0`` when an\ninteger ``dtype`` is specified. The old behavior can\nstill be obtained with ``np.linspace(start, stop, num).astype(int)``\n\nParameters\n----------\nstart : arraylike\nThe starting value of the sequence.\nstop : arraylike\nThe end value of the sequence, unless `endpoint` is set to False.\nIn that case, the sequence consists of all but the last of ``num + 1``\nevenly spaced samples, so that `stop` is excluded. Note that the step\nsize changes when `endpoint` is False.\nnum : int, optional\nNumber of samples to generate. Default is 50. Must be non-negative.\nendpoint : bool, optional\nIf True, `stop` is the last sample. Otherwise, it is not included.\nDefault is True.\nretstep : bool, optional\nIf True, return (`samples`, `step`), where `step` is the spacing\nbetween samples.\ndtype : dtype, optional\nThe type of the output array. If `dtype` is not given, the data type\nis inferred from `start` and `stop`. The inferred dtype will never be\nan integer; `float` is chosen even if the arguments would produce an\narray of integers.\n\n.. versionadded:: 1.9.0\n\naxis : int, optional\nThe axis in the result to store the samples. Relevant only if start\nor stop are array-like. By default (0), the samples will be along a\nnew axis inserted at the beginning. Use -1 to get an axis at the end.\n\n.. versionadded:: 1.16.0\n\nReturns\n-------\nsamples : ndarray\nThere are `num` equally spaced samples in the closed interval\n``[start, stop]`` or the half-open interval ``[start, stop)``\n(depending on whether `endpoint` is True or False).\nstep : float, optional\nOnly returned if `retstep` is True\n\nSize of spacing between samples.\n\n\nSee Also\n--------\narange : Similar to `linspace`, but uses a step size (instead of the\nnumber of samples).\ngeomspace : Similar to `linspace`, but with numbers spaced evenly on a log\nscale (a geometric progression).\nlogspace : Similar to `geomspace`, but with the end points specified as\nlogarithms.\n\nExamples\n--------\n>>> np.linspace(2.0, 3.0, num=5)\narray([2. , 2.25, 2.5 , 2.75, 3. ])\n>>> np.linspace(2.0, 3.0, num=5, endpoint=False)\narray([2. , 2.2, 2.4, 2.6, 2.8])\n>>> np.linspace(2.0, 3.0, num=5, retstep=True)\n(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)\n\nGraphical illustration:\n\n>>> import matplotlib.pyplot as plt\n>>> N = 8\n>>> y = np.zeros(N)\n>>> x1 = np.linspace(0, 10, N, endpoint=True)\n>>> x2 = np.linspace(0, 10, N, endpoint=False)\n>>> plt.plot(x1, y, 'o')\n[]\n>>> plt.plot(x2, y + 0.5, 'o')\n[]\n>>> plt.ylim([-0.5, 1])\n(-0.5, 1)\n>>> plt.show()\n" }, { "name": "load", "content": "Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.\n\n.. warning:: Loading files that contain object arrays uses the ``pickle``\nmodule, which is not secure against erroneous or maliciously\nconstructed data. Consider passing ``allowpickle=False`` to\nload data that is known not to contain object arrays for the\nsafer handling of untrusted sources.\n\nParameters\n----------\nfile : file-like object, string, or pathlib.Path\nThe file to read. File-like objects must support the\n``seek()`` and ``read()`` methods. Pickled files require that the\nfile-like object support the ``readline()`` method as well.\nmmapmode : {None, 'r+', 'r', 'w+', 'c'}, optional\nIf not None, then memory-map the file, using the given mode (see\n`numpy.memmap` for a detailed description of the modes). A\nmemory-mapped array is kept on disk. However, it can be accessed\nand sliced like any ndarray. Memory mapping is especially useful\nfor accessing small fragments of large files without reading the\nentire file into memory.\nallowpickle : bool, optional\nAllow loading pickled object arrays stored in npy files. Reasons for\ndisallowing pickles include security, as loading pickled data can\nexecute arbitrary code. If pickles are disallowed, loading object\narrays will fail. Default: False\n\n.. versionchanged:: 1.16.3\nMade default False in response to CVE-2019-6446.\n\nfiximports : bool, optional\nOnly useful when loading Python 2 generated pickled files on Python 3,\nwhich includes npy/npz files containing object arrays. If `fiximports`\nis True, pickle will try to map the old Python 2 names to the new names\nused in Python 3.\nencoding : str, optional\nWhat encoding to use when reading Python 2 strings. Only useful when\nloading Python 2 generated pickled files in Python 3, which includes\nnpy/npz files containing object arrays. Values other than 'latin1',\n'ASCII', and 'bytes' are not allowed, as they can corrupt numerical\ndata. Default: 'ASCII'\n\nReturns\n-------\nresult : array, tuple, dict, etc.\nData stored in the file. For ``.npz`` files, the returned instance\nof NpzFile class must be closed to avoid leaking file descriptors.\n\nRaises\n------\nIOError\nIf the input file does not exist or cannot be read.\nValueError\nThe file contains an object array, but allowpickle=False given.\n\nSee Also\n--------\nsave, savez, savezcompressed, loadtxt\nmemmap : Create a memory-map to an array stored in a file on disk.\nlib.format.openmemmap : Create or load a memory-mapped ``.npy`` file.\n\nNotes\n-----\n- If the file contains pickle data, then whatever object is stored\nin the pickle is returned.\n- If the file is a ``.npy`` file, then a single array is returned.\n- If the file is a ``.npz`` file, then a dictionary-like object is\nreturned, containing ``{filename: array}`` key-value pairs, one for\neach file in the archive.\n- If the file is a ``.npz`` file, the returned value supports the\ncontext manager protocol in a similar fashion to the open function::\n\nwith load('foo.npz') as data:\na = data['a']\n\nThe underlying file descriptor is closed when exiting the 'with'\nblock.\n\nExamples\n--------\nStore data to disk, and load it again:\n\n>>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))\n>>> np.load('/tmp/123.npy')\narray([[1, 2, 3],\n[4, 5, 6]])\n\nStore compressed data to disk, and load it again:\n\n>>> a=np.array([[1, 2, 3], [4, 5, 6]])\n>>> b=np.array([1, 2])\n>>> np.savez('/tmp/123.npz', a=a, b=b)\n>>> data = np.load('/tmp/123.npz')\n>>> data['a']\narray([[1, 2, 3],\n[4, 5, 6]])\n>>> data['b']\narray([1, 2])\n>>> data.close()\n\nMem-map the stored array, and then access the second row\ndirectly from disk:\n\n>>> X = np.load('/tmp/123.npy', mmapmode='r')\n>>> X[1, :]\nmemmap([4, 5, 6])\n" }, { "name": "loads", "content": "" }, { "name": "loadtxt", "content": "Load data from a text file.\n\nEach row in the text file must have the same number of values.\n\nParameters\n----------\nfname : file, str, or pathlib.Path\nFile, filename, or generator to read. If the filename extension is\n``.gz`` or ``.bz2``, the file is first decompressed. Note that\ngenerators should return byte strings.\ndtype : data-type, optional\nData-type of the resulting array; default: float. If this is a\nstructured data-type, the resulting array will be 1-dimensional, and\neach row will be interpreted as an element of the array. In this\ncase, the number of columns used must match the number of fields in\nthe data-type.\ncomments : str or sequence of str, optional\nThe characters or list of characters used to indicate the start of a\ncomment. None implies no comments. For backwards compatibility, byte\nstrings will be decoded as 'latin1'. The default is '#'.\ndelimiter : str, optional\nThe string used to separate values. For backwards compatibility, byte\nstrings will be decoded as 'latin1'. The default is whitespace.\nconverters : dict, optional\nA dictionary mapping column number to a function that will parse the\ncolumn string into the desired value. E.g., if column 0 is a date\nstring: ``converters = {0: datestr2num}``. Converters can also be\nused to provide a default value for missing data (but see also\n`genfromtxt`): ``converters = {3: lambda s: float(s.strip() or 0)}``.\nDefault: None.\nskiprows : int, optional\nSkip the first `skiprows` lines, including comments; default: 0.\nusecols : int or sequence, optional\nWhich columns to read, with 0 being the first. For example,\n``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.\nThe default, None, results in all columns being read.\n\n.. versionchanged:: 1.11.0\nWhen a single column has to be read it is possible to use\nan integer instead of a tuple. E.g ``usecols = 3`` reads the\nfourth column the same way as ``usecols = (3,)`` would.\nunpack : bool, optional\nIf True, the returned array is transposed, so that arguments may be\nunpacked using ``x, y, z = loadtxt(...)``. When used with a\nstructured data-type, arrays are returned for each field.\nDefault is False.\nndmin : int, optional\nThe returned array will have at least `ndmin` dimensions.\nOtherwise mono-dimensional axes will be squeezed.\nLegal values: 0 (default), 1 or 2.\n\n.. versionadded:: 1.6.0\nencoding : str, optional\nEncoding used to decode the inputfile. Does not apply to input streams.\nThe special value 'bytes' enables backward compatibility workarounds\nthat ensures you receive byte arrays as results if possible and passes\n'latin1' encoded strings to converters. Override this value to receive\nunicode arrays and pass strings as input to converters. If set to None\nthe system default is used. The default value is 'bytes'.\n\n.. versionadded:: 1.14.0\nmaxrows : int, optional\nRead `maxrows` lines of content after `skiprows` lines. The default\nis to read all the lines.\n\n.. versionadded:: 1.16.0\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nData read from the text file.\n\nSee Also\n--------\nload, fromstring, fromregex\ngenfromtxt : Load data with missing values handled as specified.\nscipy.io.loadmat : reads MATLAB data files\n\nNotes\n-----\nThis function aims to be a fast reader for simply formatted files. The\n`genfromtxt` function provides more sophisticated handling of, e.g.,\nlines with missing values.\n\n.. versionadded:: 1.10.0\n\nThe strings produced by the Python float.hex method can be used as\ninput for floats.\n\nExamples\n--------\n>>> from io import StringIO # StringIO behaves like a file object\n>>> c = StringIO(\"0 1\\n2 3\")\n>>> np.loadtxt(c)\narray([[0., 1.],\n[2., 3.]])\n\n>>> d = StringIO(\"M 21 72\\nF 35 58\")\n>>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),\n... 'formats': ('S1', 'i4', 'f4')})\narray([(b'M', 21, 72.), (b'F', 35, 58.)],\ndtype=[('gender', 'S1'), ('age', '>> c = StringIO(\"1,0,2\\n3,0,4\")\n>>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)\n>>> x\narray([1., 3.])\n>>> y\narray([2., 4.])\n\nThis example shows how `converters` can be used to convert a field\nwith a trailing minus sign into a negative number.\n\n>>> s = StringIO('10.01 31.25-\\n19.22 64.31\\n17.57- 63.94')\n>>> def conv(fld):\n... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)\n...\n>>> np.loadtxt(s, converters={0: conv, 1: conv})\narray([[ 10.01, -31.25],\n[ 19.22, 64.31],\n[-17.57, 63.94]])\n" }, { "name": "logspace", "content": "Return numbers spaced evenly on a log scale.\n\nIn linear space, the sequence starts at ``base start``\n(`base` to the power of `start`) and ends with ``base stop``\n(see `endpoint` below).\n\n.. versionchanged:: 1.16.0\nNon-scalar `start` and `stop` are now supported.\n\nParameters\n----------\nstart : arraylike\n``base start`` is the starting value of the sequence.\nstop : arraylike\n``base stop`` is the final value of the sequence, unless `endpoint`\nis False. In that case, ``num + 1`` values are spaced over the\ninterval in log-space, of which all but the last (a sequence of\nlength `num`) are returned.\nnum : integer, optional\nNumber of samples to generate. Default is 50.\nendpoint : boolean, optional\nIf true, `stop` is the last sample. Otherwise, it is not included.\nDefault is True.\nbase : arraylike, optional\nThe base of the log space. The step size between the elements in\n``ln(samples) / ln(base)`` (or ``logbase(samples)``) is uniform.\nDefault is 10.0.\ndtype : dtype\nThe type of the output array. If `dtype` is not given, the data type\nis inferred from `start` and `stop`. The inferred type will never be\nan integer; `float` is chosen even if the arguments would produce an\narray of integers.\naxis : int, optional\nThe axis in the result to store the samples. Relevant only if start\nor stop are array-like. By default (0), the samples will be along a\nnew axis inserted at the beginning. Use -1 to get an axis at the end.\n\n.. versionadded:: 1.16.0\n\n\nReturns\n-------\nsamples : ndarray\n`num` samples, equally spaced on a log scale.\n\nSee Also\n--------\narange : Similar to linspace, with the step size specified instead of the\nnumber of samples. Note that, when used with a float endpoint, the\nendpoint may or may not be included.\nlinspace : Similar to logspace, but with the samples uniformly distributed\nin linear space, instead of log space.\ngeomspace : Similar to logspace, but with endpoints specified directly.\n\nNotes\n-----\nLogspace is equivalent to the code\n\n>>> y = np.linspace(start, stop, num=num, endpoint=endpoint)\n... # doctest: +SKIP\n>>> power(base, y).astype(dtype)\n... # doctest: +SKIP\n\nExamples\n--------\n>>> np.logspace(2.0, 3.0, num=4)\narray([ 100. , 215.443469 , 464.15888336, 1000. ])\n>>> np.logspace(2.0, 3.0, num=4, endpoint=False)\narray([100. , 177.827941 , 316.22776602, 562.34132519])\n>>> np.logspace(2.0, 3.0, num=4, base=2.0)\narray([4. , 5.0396842 , 6.34960421, 8. ])\n\nGraphical illustration:\n\n>>> import matplotlib.pyplot as plt\n>>> N = 10\n>>> x1 = np.logspace(0.1, 1, N, endpoint=True)\n>>> x2 = np.logspace(0.1, 1, N, endpoint=False)\n>>> y = np.zeros(N)\n>>> plt.plot(x1, y, 'o')\n[]\n>>> plt.plot(x2, y + 0.5, 'o')\n[]\n>>> plt.ylim([-0.5, 1])\n(-0.5, 1)\n>>> plt.show()\n" }, { "name": "lookfor", "content": "Do a keyword search on docstrings.\n\nA list of objects that matched the search is displayed,\nsorted by relevance. All given keywords need to be found in the\ndocstring for it to be returned as a result, but the order does\nnot matter.\n\nParameters\n----------\nwhat : str\nString containing words to look for.\nmodule : str or list, optional\nName of module(s) whose docstrings to go through.\nimportmodules : bool, optional\nWhether to import sub-modules in packages. Default is True.\nregenerate : bool, optional\nWhether to re-generate the docstring cache. Default is False.\noutput : file-like, optional\nFile-like object to write the output to. If omitted, use a pager.\n\nSee Also\n--------\nsource, info\n\nNotes\n-----\nRelevance is determined only roughly, by checking if the keywords occur\nin the function name, at the start of a docstring, etc.\n\nExamples\n--------\n>>> np.lookfor('binary representation') # doctest: +SKIP\nSearch results for 'binary representation'\n------------------------------------------\nnumpy.binaryrepr\nReturn the binary representation of the input number as a string.\nnumpy.core.setupcommon.longdoublerepresentation\nGiven a binary dump as given by GNU od -b, look for long double\nnumpy.baserepr\nReturn a string representation of a number in the given base system.\n...\n" }, { "name": "mafromtxt", "content": "Load ASCII data stored in a text file and return a masked array.\n\n.. deprecated:: 1.17\nnp.mafromtxt is a deprecated alias of `genfromtxt` which\noverwrites the ``usemask`` argument with `True` even when\nexplicitly called as ``mafromtxt(..., usemask=False)``.\nUse `genfromtxt` instead.\n\nParameters\n----------\nfname, kwargs : For a description of input parameters, see `genfromtxt`.\n\nSee Also\n--------\nnumpy.genfromtxt : generic function to load ASCII data.\n" }, { "name": "mask_indices", "content": "Return the indices to access (n, n) arrays, given a masking function.\n\nAssume `maskfunc` is a function that, for a square array a of size\n``(n, n)`` with a possible offset argument `k`, when called as\n``maskfunc(a, k)`` returns a new array with zeros in certain locations\n(functions like `triu` or `tril` do precisely this). Then this function\nreturns the indices where the non-zero values would be located.\n\nParameters\n----------\nn : int\nThe returned indices will be valid to access arrays of shape (n, n).\nmaskfunc : callable\nA function whose call signature is similar to that of `triu`, `tril`.\nThat is, ``maskfunc(x, k)`` returns a boolean array, shaped like `x`.\n`k` is an optional argument to the function.\nk : scalar\nAn optional argument which is passed through to `maskfunc`. Functions\nlike `triu`, `tril` take a second argument that is interpreted as an\noffset.\n\nReturns\n-------\nindices : tuple of arrays.\nThe `n` arrays of indices corresponding to the locations where\n``maskfunc(np.ones((n, n)), k)`` is True.\n\nSee Also\n--------\ntriu, tril, triuindices, trilindices\n\nNotes\n-----\n.. versionadded:: 1.4.0\n\nExamples\n--------\nThese are the indices that would allow you to access the upper triangular\npart of any 3x3 array:\n\n>>> iu = np.maskindices(3, np.triu)\n\nFor example, if `a` is a 3x3 array:\n\n>>> a = np.arange(9).reshape(3, 3)\n>>> a\narray([[0, 1, 2],\n[3, 4, 5],\n[6, 7, 8]])\n>>> a[iu]\narray([0, 1, 2, 4, 5, 8])\n\nAn offset can be passed also to the masking function. This gets us the\nindices starting on the first diagonal right of the main one:\n\n>>> iu1 = np.maskindices(3, np.triu, 1)\n\nwith which we now extract only three elements:\n\n>>> a[iu1]\narray([1, 2, 5])\n\nmat = asmatrix(data, dtype=None)\nInterpret the input as a matrix.\n\nUnlike `matrix`, `asmatrix` does not make a copy if the input is already\na matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``.\n\nParameters\n----------\ndata : arraylike\nInput data.\ndtype : data-type\nData-type of the output matrix.\n\nReturns\n-------\nmat : matrix\n`data` interpreted as a matrix.\n\nExamples\n--------\n>>> x = np.array([[1, 2], [3, 4]])\n\n>>> m = np.asmatrix(x)\n\n>>> x[0,0] = 5\n\n>>> m\nmatrix([[5, 2],\n[3, 4]])\n" }, { "name": "maximum_sctype", "content": "Return the scalar type of highest precision of the same kind as the input.\n\nParameters\n----------\nt : dtype or dtype specifier\nThe input data type. This can be a `dtype` object or an object that\nis convertible to a `dtype`.\n\nReturns\n-------\nout : dtype\nThe highest precision data type of the same kind (`dtype.kind`) as `t`.\n\nSee Also\n--------\nobj2sctype, mintypecode, sctype2char\ndtype\n\nExamples\n--------\n>>> np.maximumsctype(int)\n\n>>> np.maximumsctype(np.uint8)\n\n>>> np.maximumsctype(complex)\n # may vary\n\n>>> np.maximumsctype(str)\n\n\n>>> np.maximumsctype('i2')\n\n>>> np.maximumsctype('f4')\n # may vary\n" }, { "name": "may_share_memory", "content": "maysharememory(a, b, maxwork=None)\n\nDetermine if two arrays might share memory\n\nA return of True does not necessarily mean that the two arrays\nshare any element. It just means that they *might*.\n\nOnly the memory bounds of a and b are checked by default.\n\nParameters\n----------\na, b : ndarray\nInput arrays\nmaxwork : int, optional\nEffort to spend on solving the overlap problem. See\n`sharesmemory` for details. Default for ``maysharememory``\nis to do a bounds check.\n\nReturns\n-------\nout : bool\n\nSee Also\n--------\nsharesmemory\n\nExamples\n--------\n>>> np.maysharememory(np.array([1,2]), np.array([5,8,9]))\nFalse\n>>> x = np.zeros([3, 4])\n>>> np.maysharememory(x[:,0], x[:,1])\nTrue\n" }, { "name": "mean", "content": "Compute the arithmetic mean along the specified axis.\n\nReturns the average of the array elements. The average is taken over\nthe flattened array by default, otherwise over the specified axis.\n`float64` intermediate and return values are used for integer inputs.\n\nParameters\n----------\na : arraylike\nArray containing numbers whose mean is desired. If `a` is not an\narray, a conversion is attempted.\naxis : None or int or tuple of ints, optional\nAxis or axes along which the means are computed. The default is to\ncompute the mean of the flattened array.\n\n.. versionadded:: 1.7.0\n\nIf this is a tuple of ints, a mean is performed over multiple axes,\ninstead of a single axis or all the axes as before.\ndtype : data-type, optional\nType to use in computing the mean. For integer inputs, the default\nis `float64`; for floating point inputs, it is the same as the\ninput dtype.\nout : ndarray, optional\nAlternate output array in which to place the result. The default\nis ``None``; if provided, it must have the same shape as the\nexpected output, but the type will be cast if necessary.\nSee :ref:`ufuncs-output-type` for more details.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `mean` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\nwhere : arraylike of bool, optional\nElements to include in the mean. See `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nm : ndarray, see dtype parameter above\nIf `out=None`, returns a new array containing the mean values,\notherwise a reference to the output array is returned.\n\nSee Also\n--------\naverage : Weighted average\nstd, var, nanmean, nanstd, nanvar\n\nNotes\n-----\nThe arithmetic mean is the sum of the elements along the axis divided\nby the number of elements.\n\nNote that for floating-point input, the mean is computed using the\nsame precision the input has. Depending on the input data, this can\ncause the results to be inaccurate, especially for `float32` (see\nexample below). Specifying a higher-precision accumulator using the\n`dtype` keyword can alleviate this issue.\n\nBy default, `float16` results are computed using `float32` intermediates\nfor extra precision.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, 4]])\n>>> np.mean(a)\n2.5\n>>> np.mean(a, axis=0)\narray([2., 3.])\n>>> np.mean(a, axis=1)\narray([1.5, 3.5])\n\nIn single precision, `mean` can be inaccurate:\n\n>>> a = np.zeros((2, 512*512), dtype=np.float32)\n>>> a[0, :] = 1.0\n>>> a[1, :] = 0.1\n>>> np.mean(a)\n0.54999924\n\nComputing the mean in float64 is more accurate:\n\n>>> np.mean(a, dtype=np.float64)\n0.55000000074505806 # may vary\n\nSpecifying a where argument:\n>>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])\n>>> np.mean(a)\n12.0\n>>> np.mean(a, where=[[True], [False], [False]])\n9.0\n" }, { "name": "median", "content": "Compute the median along the specified axis.\n\nReturns the median of the array elements.\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array.\naxis : {int, sequence of int, None}, optional\nAxis or axes along which the medians are computed. The default\nis to compute the median along a flattened version of the array.\nA sequence of axes is supported since version 1.9.0.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output,\nbut the type (of the output) will be cast if necessary.\noverwriteinput : bool, optional\nIf True, then allow use of memory of input array `a` for\ncalculations. The input array will be modified by the call to\n`median`. This will save memory when you do not need to preserve\nthe contents of the input array. Treat the input as undefined,\nbut it will probably be fully or partially sorted. Default is\nFalse. If `overwriteinput` is ``True`` and `a` is not already an\n`ndarray`, an error will be raised.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `arr`.\n\n.. versionadded:: 1.9.0\n\nReturns\n-------\nmedian : ndarray\nA new array holding the result. If the input contains integers\nor floats smaller than ``float64``, then the output data-type is\n``np.float64``. Otherwise, the data-type of the output is the\nsame as that of the input. If `out` is specified, that array is\nreturned instead.\n\nSee Also\n--------\nmean, percentile\n\nNotes\n-----\nGiven a vector ``V`` of length ``N``, the median of ``V`` is the\nmiddle value of a sorted copy of ``V``, ``Vsorted`` - i\ne., ``Vsorted[(N-1)/2]``, when ``N`` is odd, and the average of the\ntwo middle values of ``Vsorted`` when ``N`` is even.\n\nExamples\n--------\n>>> a = np.array([[10, 7, 4], [3, 2, 1]])\n>>> a\narray([[10, 7, 4],\n[ 3, 2, 1]])\n>>> np.median(a)\n3.5\n>>> np.median(a, axis=0)\narray([6.5, 4.5, 2.5])\n>>> np.median(a, axis=1)\narray([7., 2.])\n>>> m = np.median(a, axis=0)\n>>> out = np.zeroslike(m)\n>>> np.median(a, axis=0, out=m)\narray([6.5, 4.5, 2.5])\n>>> m\narray([6.5, 4.5, 2.5])\n>>> b = a.copy()\n>>> np.median(b, axis=1, overwriteinput=True)\narray([7., 2.])\n>>> assert not np.all(a==b)\n>>> b = a.copy()\n>>> np.median(b, axis=None, overwriteinput=True)\n3.5\n>>> assert not np.all(a==b)\n" }, { "name": "meshgrid", "content": "Return coordinate matrices from coordinate vectors.\n\nMake N-D coordinate arrays for vectorized evaluations of\nN-D scalar/vector fields over N-D grids, given\none-dimensional coordinate arrays x1, x2,..., xn.\n\n.. versionchanged:: 1.9\n1-D and 0-D cases are allowed.\n\nParameters\n----------\nx1, x2,..., xn : arraylike\n1-D arrays representing the coordinates of a grid.\nindexing : {'xy', 'ij'}, optional\nCartesian ('xy', default) or matrix ('ij') indexing of output.\nSee Notes for more details.\n\n.. versionadded:: 1.7.0\nsparse : bool, optional\nIf True a sparse grid is returned in order to conserve memory.\nDefault is False.\n\n.. versionadded:: 1.7.0\ncopy : bool, optional\nIf False, a view into the original arrays are returned in order to\nconserve memory. Default is True. Please note that\n``sparse=False, copy=False`` will likely return non-contiguous\narrays. Furthermore, more than one element of a broadcast array\nmay refer to a single memory location. If you need to write to the\narrays, make copies first.\n\n.. versionadded:: 1.7.0\n\nReturns\n-------\nX1, X2,..., XN : ndarray\nFor vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,\nreturn ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'\nor ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'\nwith the elements of `xi` repeated to fill the matrix along\nthe first dimension for `x1`, the second for `x2` and so on.\n\nNotes\n-----\nThis function supports both indexing conventions through the indexing\nkeyword argument. Giving the string 'ij' returns a meshgrid with\nmatrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.\nIn the 2-D case with inputs of length M and N, the outputs are of shape\n(N, M) for 'xy' indexing and (M, N) for 'ij' indexing. In the 3-D case\nwith inputs of length M, N and P, outputs are of shape (N, M, P) for\n'xy' indexing and (M, N, P) for 'ij' indexing. The difference is\nillustrated by the following code snippet::\n\nxv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')\nfor i in range(nx):\nfor j in range(ny):\n# treat xv[i,j], yv[i,j]\n\nxv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')\nfor i in range(nx):\nfor j in range(ny):\n# treat xv[j,i], yv[j,i]\n\nIn the 1-D and 0-D case, the indexing and sparse keywords have no effect.\n\nSee Also\n--------\nmgrid : Construct a multi-dimensional \"meshgrid\" using indexing notation.\nogrid : Construct an open multi-dimensional \"meshgrid\" using indexing\nnotation.\n\nExamples\n--------\n>>> nx, ny = (3, 2)\n>>> x = np.linspace(0, 1, nx)\n>>> y = np.linspace(0, 1, ny)\n>>> xv, yv = np.meshgrid(x, y)\n>>> xv\narray([[0. , 0.5, 1. ],\n[0. , 0.5, 1. ]])\n>>> yv\narray([[0., 0., 0.],\n[1., 1., 1.]])\n>>> xv, yv = np.meshgrid(x, y, sparse=True) # make sparse output arrays\n>>> xv\narray([[0. , 0.5, 1. ]])\n>>> yv\narray([[0.],\n[1.]])\n\n`meshgrid` is very useful to evaluate functions on a grid.\n\n>>> import matplotlib.pyplot as plt\n>>> x = np.arange(-5, 5, 0.1)\n>>> y = np.arange(-5, 5, 0.1)\n>>> xx, yy = np.meshgrid(x, y, sparse=True)\n>>> z = np.sin(xx2 + yy2) / (xx2 + yy2)\n>>> h = plt.contourf(x, y, z)\n>>> plt.axis('scaled')\n>>> plt.show()\n" }, { "name": "min_scalar_type", "content": "minscalartype(a)\n\nFor scalar ``a``, returns the data type with the smallest size\nand smallest scalar kind which can hold its value. For non-scalar\narray ``a``, returns the vector's dtype unmodified.\n\nFloating point values are not demoted to integers,\nand complex values are not demoted to floats.\n\nParameters\n----------\na : scalar or arraylike\nThe value whose minimal data type is to be found.\n\nReturns\n-------\nout : dtype\nThe minimal data type.\n\nNotes\n-----\n.. versionadded:: 1.6.0\n\nSee Also\n--------\nresulttype, promotetypes, dtype, cancast\n\nExamples\n--------\n>>> np.minscalartype(10)\ndtype('uint8')\n\n>>> np.minscalartype(-260)\ndtype('int16')\n\n>>> np.minscalartype(3.1)\ndtype('float16')\n\n>>> np.minscalartype(1e50)\ndtype('float64')\n\n>>> np.minscalartype(np.arange(4,dtype='f8'))\ndtype('float64')\n" }, { "name": "mintypecode", "content": "Return the character for the minimum-size type to which given types can\nbe safely cast.\n\nThe returned type character must represent the smallest size dtype such\nthat an array of the returned type can handle the data from an array of\nall types in `typechars` (or if `typechars` is an array, then its\ndtype.char).\n\nParameters\n----------\ntypechars : list of str or arraylike\nIf a list of strings, each string should represent a dtype.\nIf arraylike, the character representation of the array dtype is used.\ntypeset : str or list of str, optional\nThe set of characters that the returned character is chosen from.\nThe default set is 'GDFgdf'.\ndefault : str, optional\nThe default character, this is returned if none of the characters in\n`typechars` matches a character in `typeset`.\n\nReturns\n-------\ntypechar : str\nThe character representing the minimum-size type that was found.\n\nSee Also\n--------\ndtype, sctype2char, maximumsctype\n\nExamples\n--------\n>>> np.mintypecode(['d', 'f', 'S'])\n'd'\n>>> x = np.array([1.1, 2-3.j])\n>>> np.mintypecode(x)\n'D'\n\n>>> np.mintypecode('abceh', default='G')\n'G'\n" }, { "name": "moveaxis", "content": "Move axes of an array to new positions.\n\nOther axes remain in their original order.\n\n.. versionadded:: 1.11.0\n\nParameters\n----------\na : np.ndarray\nThe array whose axes should be reordered.\nsource : int or sequence of int\nOriginal positions of the axes to move. These must be unique.\ndestination : int or sequence of int\nDestination positions for each of the original axes. These must also be\nunique.\n\nReturns\n-------\nresult : np.ndarray\nArray with moved axes. This array is a view of the input array.\n\nSee Also\n--------\ntranspose : Permute the dimensions of an array.\nswapaxes : Interchange two axes of an array.\n\nExamples\n--------\n>>> x = np.zeros((3, 4, 5))\n>>> np.moveaxis(x, 0, -1).shape\n(4, 5, 3)\n>>> np.moveaxis(x, -1, 0).shape\n(5, 3, 4)\n\nThese all achieve the same result:\n\n>>> np.transpose(x).shape\n(5, 4, 3)\n>>> np.swapaxes(x, 0, -1).shape\n(5, 4, 3)\n>>> np.moveaxis(x, [0, 1], [-1, -2]).shape\n(5, 4, 3)\n>>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape\n(5, 4, 3)\n" }, { "name": "msort", "content": "Return a copy of an array sorted along the first axis.\n\nParameters\n----------\na : arraylike\nArray to be sorted.\n\nReturns\n-------\nsortedarray : ndarray\nArray of the same type and shape as `a`.\n\nSee Also\n--------\nsort\n\nNotes\n-----\n``np.msort(a)`` is equivalent to ``np.sort(a, axis=0)``.\n" }, { "name": "nan_to_num", "content": "Replace NaN with zero and infinity with large finite numbers (default\nbehaviour) or with the numbers defined by the user using the `nan`,\n`posinf` and/or `neginf` keywords.\n\nIf `x` is inexact, NaN is replaced by zero or by the user defined value in\n`nan` keyword, infinity is replaced by the largest finite floating point\nvalues representable by ``x.dtype`` or by the user defined value in\n`posinf` keyword and -infinity is replaced by the most negative finite\nfloating point values representable by ``x.dtype`` or by the user defined\nvalue in `neginf` keyword.\n\nFor complex dtypes, the above is applied to each of the real and\nimaginary components of `x` separately.\n\nIf `x` is not inexact, then no replacements are made.\n\nParameters\n----------\nx : scalar or arraylike\nInput data.\ncopy : bool, optional\nWhether to create a copy of `x` (True) or to replace values\nin-place (False). The in-place operation only occurs if\ncasting to an array does not require a copy.\nDefault is True.\n\n.. versionadded:: 1.13\nnan : int, float, optional\nValue to be used to fill NaN values. If no value is passed\nthen NaN values will be replaced with 0.0.\n\n.. versionadded:: 1.17\nposinf : int, float, optional\nValue to be used to fill positive infinity values. If no value is\npassed then positive infinity values will be replaced with a very\nlarge number.\n\n.. versionadded:: 1.17\nneginf : int, float, optional\nValue to be used to fill negative infinity values. If no value is\npassed then negative infinity values will be replaced with a very\nsmall (or negative) number.\n\n.. versionadded:: 1.17\n\n\n\nReturns\n-------\nout : ndarray\n`x`, with the non-finite values replaced. If `copy` is False, this may\nbe `x` itself.\n\nSee Also\n--------\nisinf : Shows which elements are positive or negative infinity.\nisneginf : Shows which elements are negative infinity.\nisposinf : Shows which elements are positive infinity.\nisnan : Shows which elements are Not a Number (NaN).\nisfinite : Shows which elements are finite (not NaN, not infinity)\n\nNotes\n-----\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754). This means that Not a Number is not equivalent to infinity.\n\nExamples\n--------\n>>> np.nantonum(np.inf)\n1.7976931348623157e+308\n>>> np.nantonum(-np.inf)\n-1.7976931348623157e+308\n>>> np.nantonum(np.nan)\n0.0\n>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])\n>>> np.nantonum(x)\narray([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary\n-1.28000000e+002, 1.28000000e+002])\n>>> np.nantonum(x, nan=-9999, posinf=33333333, neginf=33333333)\narray([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,\n-1.2800000e+02, 1.2800000e+02])\n>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])\narray([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary\n-1.28000000e+002, 1.28000000e+002])\n>>> np.nantonum(y)\narray([ 1.79769313e+308 +0.00000000e+000j, # may vary\n0.00000000e+000 +0.00000000e+000j,\n0.00000000e+000 +1.79769313e+308j])\n>>> np.nantonum(y, nan=111111, posinf=222222)\narray([222222.+111111.j, 111111. +0.j, 111111.+222222.j])\n" }, { "name": "nanargmax", "content": "Return the indices of the maximum values in the specified axis ignoring\nNaNs. For all-NaN slices ``ValueError`` is raised. Warning: the\nresults cannot be trusted if a slice contains only NaNs and -Infs.\n\n\nParameters\n----------\na : arraylike\nInput data.\naxis : int, optional\nAxis along which to operate. By default flattened input is used.\n\nReturns\n-------\nindexarray : ndarray\nAn array of indices or a single index value.\n\nSee Also\n--------\nargmax, nanargmin\n\nExamples\n--------\n>>> a = np.array([[np.nan, 4], [2, 3]])\n>>> np.argmax(a)\n0\n>>> np.nanargmax(a)\n1\n>>> np.nanargmax(a, axis=0)\narray([1, 0])\n>>> np.nanargmax(a, axis=1)\narray([1, 1])\n" }, { "name": "nanargmin", "content": "Return the indices of the minimum values in the specified axis ignoring\nNaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results\ncannot be trusted if a slice contains only NaNs and Infs.\n\nParameters\n----------\na : arraylike\nInput data.\naxis : int, optional\nAxis along which to operate. By default flattened input is used.\n\nReturns\n-------\nindexarray : ndarray\nAn array of indices or a single index value.\n\nSee Also\n--------\nargmin, nanargmax\n\nExamples\n--------\n>>> a = np.array([[np.nan, 4], [2, 3]])\n>>> np.argmin(a)\n0\n>>> np.nanargmin(a)\n2\n>>> np.nanargmin(a, axis=0)\narray([1, 1])\n>>> np.nanargmin(a, axis=1)\narray([1, 0])\n" }, { "name": "nancumprod", "content": "Return the cumulative product of array elements over a given axis treating Not a\nNumbers (NaNs) as one. The cumulative product does not change when NaNs are\nencountered and leading NaNs are replaced by ones.\n\nOnes are returned for slices that are all-NaN or empty.\n\n.. versionadded:: 1.12.0\n\nParameters\n----------\na : arraylike\nInput array.\naxis : int, optional\nAxis along which the cumulative product is computed. By default\nthe input is flattened.\ndtype : dtype, optional\nType of the returned array, as well as of the accumulator in which\nthe elements are multiplied. If *dtype* is not specified, it\ndefaults to the dtype of `a`, unless `a` has an integer dtype with\na precision less than that of the default platform integer. In\nthat case, the default platform integer is used instead.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output\nbut the type of the resulting values will be cast if necessary.\n\nReturns\n-------\nnancumprod : ndarray\nA new array holding the result is returned unless `out` is\nspecified, in which case it is returned.\n\nSee Also\n--------\nnumpy.cumprod : Cumulative product across array propagating NaNs.\nisnan : Show which elements are NaN.\n\nExamples\n--------\n>>> np.nancumprod(1)\narray([1])\n>>> np.nancumprod([1])\narray([1])\n>>> np.nancumprod([1, np.nan])\narray([1., 1.])\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nancumprod(a)\narray([1., 2., 6., 6.])\n>>> np.nancumprod(a, axis=0)\narray([[1., 2.],\n[3., 2.]])\n>>> np.nancumprod(a, axis=1)\narray([[1., 2.],\n[3., 3.]])\n" }, { "name": "nancumsum", "content": "Return the cumulative sum of array elements over a given axis treating Not a\nNumbers (NaNs) as zero. The cumulative sum does not change when NaNs are\nencountered and leading NaNs are replaced by zeros.\n\nZeros are returned for slices that are all-NaN or empty.\n\n.. versionadded:: 1.12.0\n\nParameters\n----------\na : arraylike\nInput array.\naxis : int, optional\nAxis along which the cumulative sum is computed. The default\n(None) is to compute the cumsum over the flattened array.\ndtype : dtype, optional\nType of the returned array and of the accumulator in which the\nelements are summed. If `dtype` is not specified, it defaults\nto the dtype of `a`, unless `a` has an integer dtype with a\nprecision less than that of the default platform integer. In\nthat case, the default platform integer is used.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output\nbut the type will be cast if necessary. See :ref:`ufuncs-output-type` for\nmore details.\n\nReturns\n-------\nnancumsum : ndarray.\nA new array holding the result is returned unless `out` is\nspecified, in which it is returned. The result has the same\nsize as `a`, and the same shape as `a` if `axis` is not None\nor `a` is a 1-d array.\n\nSee Also\n--------\nnumpy.cumsum : Cumulative sum across array propagating NaNs.\nisnan : Show which elements are NaN.\n\nExamples\n--------\n>>> np.nancumsum(1)\narray([1])\n>>> np.nancumsum([1])\narray([1])\n>>> np.nancumsum([1, np.nan])\narray([1., 1.])\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nancumsum(a)\narray([1., 3., 6., 6.])\n>>> np.nancumsum(a, axis=0)\narray([[1., 2.],\n[4., 2.]])\n>>> np.nancumsum(a, axis=1)\narray([[1., 3.],\n[3., 3.]])\n" }, { "name": "nanmax", "content": "Return the maximum of an array or maximum along an axis, ignoring any\nNaNs. When all-NaN slices are encountered a ``RuntimeWarning`` is\nraised and NaN is returned for that slice.\n\nParameters\n----------\na : arraylike\nArray containing numbers whose maximum is desired. If `a` is not an\narray, a conversion is attempted.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the maximum is computed. The default is to compute\nthe maximum of the flattened array.\nout : ndarray, optional\nAlternate output array in which to place the result. The default\nis ``None``; if provided, it must have the same shape as the\nexpected output, but the type will be cast if necessary. See\n:ref:`ufuncs-output-type` for more details.\n\n.. versionadded:: 1.8.0\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `a`.\n\nIf the value is anything but the default, then\n`keepdims` will be passed through to the `max` method\nof sub-classes of `ndarray`. If the sub-classes methods\ndoes not implement `keepdims` any exceptions will be raised.\n\n.. versionadded:: 1.8.0\n\nReturns\n-------\nnanmax : ndarray\nAn array with the same shape as `a`, with the specified axis removed.\nIf `a` is a 0-d array, or if axis is None, an ndarray scalar is\nreturned. The same dtype as `a` is returned.\n\nSee Also\n--------\nnanmin :\nThe minimum value of an array along a given axis, ignoring any NaNs.\namax :\nThe maximum value of an array along a given axis, propagating any NaNs.\nfmax :\nElement-wise maximum of two arrays, ignoring any NaNs.\nmaximum :\nElement-wise maximum of two arrays, propagating any NaNs.\nisnan :\nShows which elements are Not a Number (NaN).\nisfinite:\nShows which elements are neither NaN nor infinity.\n\namin, fmin, minimum\n\nNotes\n-----\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754). This means that Not a Number is not equivalent to infinity.\nPositive infinity is treated as a very large number and negative\ninfinity is treated as a very small (i.e. negative) number.\n\nIf the input has a integer type the function is equivalent to np.max.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanmax(a)\n3.0\n>>> np.nanmax(a, axis=0)\narray([3., 2.])\n>>> np.nanmax(a, axis=1)\narray([2., 3.])\n\nWhen positive infinity and negative infinity are present:\n\n>>> np.nanmax([1, 2, np.nan, np.NINF])\n2.0\n>>> np.nanmax([1, 2, np.nan, np.inf])\ninf\n" }, { "name": "nanmean", "content": "Compute the arithmetic mean along the specified axis, ignoring NaNs.\n\nReturns the average of the array elements. The average is taken over\nthe flattened array by default, otherwise over the specified axis.\n`float64` intermediate and return values are used for integer inputs.\n\nFor all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.\n\n.. versionadded:: 1.8.0\n\nParameters\n----------\na : arraylike\nArray containing numbers whose mean is desired. If `a` is not an\narray, a conversion is attempted.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the means are computed. The default is to compute\nthe mean of the flattened array.\ndtype : data-type, optional\nType to use in computing the mean. For integer inputs, the default\nis `float64`; for inexact inputs, it is the same as the input\ndtype.\nout : ndarray, optional\nAlternate output array in which to place the result. The default\nis ``None``; if provided, it must have the same shape as the\nexpected output, but the type will be cast if necessary. See\n:ref:`ufuncs-output-type` for more details.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `a`.\n\nIf the value is anything but the default, then\n`keepdims` will be passed through to the `mean` or `sum` methods\nof sub-classes of `ndarray`. If the sub-classes methods\ndoes not implement `keepdims` any exceptions will be raised.\n\nReturns\n-------\nm : ndarray, see dtype parameter above\nIf `out=None`, returns a new array containing the mean values,\notherwise a reference to the output array is returned. Nan is\nreturned for slices that contain only NaNs.\n\nSee Also\n--------\naverage : Weighted average\nmean : Arithmetic mean taken while not ignoring NaNs\nvar, nanvar\n\nNotes\n-----\nThe arithmetic mean is the sum of the non-NaN elements along the axis\ndivided by the number of non-NaN elements.\n\nNote that for floating-point input, the mean is computed using the same\nprecision the input has. Depending on the input data, this can cause\nthe results to be inaccurate, especially for `float32`. Specifying a\nhigher-precision accumulator using the `dtype` keyword can alleviate\nthis issue.\n\nExamples\n--------\n>>> a = np.array([[1, np.nan], [3, 4]])\n>>> np.nanmean(a)\n2.6666666666666665\n>>> np.nanmean(a, axis=0)\narray([2., 4.])\n>>> np.nanmean(a, axis=1)\narray([1., 3.5]) # may vary\n" }, { "name": "nanmedian", "content": "Compute the median along the specified axis, while ignoring NaNs.\n\nReturns the median of the array elements.\n\n.. versionadded:: 1.9.0\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array.\naxis : {int, sequence of int, None}, optional\nAxis or axes along which the medians are computed. The default\nis to compute the median along a flattened version of the array.\nA sequence of axes is supported since version 1.9.0.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output,\nbut the type (of the output) will be cast if necessary.\noverwriteinput : bool, optional\nIf True, then allow use of memory of input array `a` for\ncalculations. The input array will be modified by the call to\n`median`. This will save memory when you do not need to preserve\nthe contents of the input array. Treat the input as undefined,\nbut it will probably be fully or partially sorted. Default is\nFalse. If `overwriteinput` is ``True`` and `a` is not already an\n`ndarray`, an error will be raised.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `a`.\n\nIf this is anything but the default value it will be passed\nthrough (in the special case of an empty array) to the\n`mean` function of the underlying array. If the array is\na sub-class and `mean` does not have the kwarg `keepdims` this\nwill raise a RuntimeError.\n\nReturns\n-------\nmedian : ndarray\nA new array holding the result. If the input contains integers\nor floats smaller than ``float64``, then the output data-type is\n``np.float64``. Otherwise, the data-type of the output is the\nsame as that of the input. If `out` is specified, that array is\nreturned instead.\n\nSee Also\n--------\nmean, median, percentile\n\nNotes\n-----\nGiven a vector ``V`` of length ``N``, the median of ``V`` is the\nmiddle value of a sorted copy of ``V``, ``Vsorted`` - i.e.,\n``Vsorted[(N-1)/2]``, when ``N`` is odd and the average of the two\nmiddle values of ``Vsorted`` when ``N`` is even.\n\nExamples\n--------\n>>> a = np.array([[10.0, 7, 4], [3, 2, 1]])\n>>> a[0, 1] = np.nan\n>>> a\narray([[10., nan, 4.],\n[ 3., 2., 1.]])\n>>> np.median(a)\nnan\n>>> np.nanmedian(a)\n3.0\n>>> np.nanmedian(a, axis=0)\narray([6.5, 2. , 2.5])\n>>> np.median(a, axis=1)\narray([nan, 2.])\n>>> b = a.copy()\n>>> np.nanmedian(b, axis=1, overwriteinput=True)\narray([7., 2.])\n>>> assert not np.all(a==b)\n>>> b = a.copy()\n>>> np.nanmedian(b, axis=None, overwriteinput=True)\n3.0\n>>> assert not np.all(a==b)\n" }, { "name": "nanmin", "content": "Return minimum of an array or minimum along an axis, ignoring any NaNs.\nWhen all-NaN slices are encountered a ``RuntimeWarning`` is raised and\nNan is returned for that slice.\n\nParameters\n----------\na : arraylike\nArray containing numbers whose minimum is desired. If `a` is not an\narray, a conversion is attempted.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the minimum is computed. The default is to compute\nthe minimum of the flattened array.\nout : ndarray, optional\nAlternate output array in which to place the result. The default\nis ``None``; if provided, it must have the same shape as the\nexpected output, but the type will be cast if necessary. See\n:ref:`ufuncs-output-type` for more details.\n\n.. versionadded:: 1.8.0\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `a`.\n\nIf the value is anything but the default, then\n`keepdims` will be passed through to the `min` method\nof sub-classes of `ndarray`. If the sub-classes methods\ndoes not implement `keepdims` any exceptions will be raised.\n\n.. versionadded:: 1.8.0\n\nReturns\n-------\nnanmin : ndarray\nAn array with the same shape as `a`, with the specified axis\nremoved. If `a` is a 0-d array, or if axis is None, an ndarray\nscalar is returned. The same dtype as `a` is returned.\n\nSee Also\n--------\nnanmax :\nThe maximum value of an array along a given axis, ignoring any NaNs.\namin :\nThe minimum value of an array along a given axis, propagating any NaNs.\nfmin :\nElement-wise minimum of two arrays, ignoring any NaNs.\nminimum :\nElement-wise minimum of two arrays, propagating any NaNs.\nisnan :\nShows which elements are Not a Number (NaN).\nisfinite:\nShows which elements are neither NaN nor infinity.\n\namax, fmax, maximum\n\nNotes\n-----\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754). This means that Not a Number is not equivalent to infinity.\nPositive infinity is treated as a very large number and negative\ninfinity is treated as a very small (i.e. negative) number.\n\nIf the input has a integer type the function is equivalent to np.min.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanmin(a)\n1.0\n>>> np.nanmin(a, axis=0)\narray([1., 2.])\n>>> np.nanmin(a, axis=1)\narray([1., 3.])\n\nWhen positive infinity and negative infinity are present:\n\n>>> np.nanmin([1, 2, np.nan, np.inf])\n1.0\n>>> np.nanmin([1, 2, np.nan, np.NINF])" }, { "name": "-inf", "content": "" }, { "name": "nanpercentile", "content": "Compute the qth percentile of the data along the specified axis,\nwhile ignoring nan values.\n\nReturns the qth percentile(s) of the array elements.\n\n.. versionadded:: 1.9.0\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array, containing\nnan values to be ignored.\nq : arraylike of float\nPercentile or sequence of percentiles to compute, which must be between\n0 and 100 inclusive.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the percentiles are computed. The\ndefault is to compute the percentile(s) along a flattened\nversion of the array.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output,\nbut the type (of the output) will be cast if necessary.\noverwriteinput : bool, optional\nIf True, then allow the input array `a` to be modified by intermediate\ncalculations, to save memory. In this case, the contents of the input\n`a` after this function completes is undefined.\ninterpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\nThis optional parameter specifies the interpolation method to\nuse when the desired percentile lies between two data points\n``i < j``:\n\n* 'linear': ``i + (j - i) * fraction``, where ``fraction``\nis the fractional part of the index surrounded by ``i``\nand ``j``.\n* 'lower': ``i``.\n* 'higher': ``j``.\n* 'nearest': ``i`` or ``j``, whichever is nearest.\n* 'midpoint': ``(i + j) / 2``.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left in\nthe result as dimensions with size one. With this option, the\nresult will broadcast correctly against the original array `a`.\n\nIf this is anything but the default value it will be passed\nthrough (in the special case of an empty array) to the\n`mean` function of the underlying array. If the array is\na sub-class and `mean` does not have the kwarg `keepdims` this\nwill raise a RuntimeError.\n\nReturns\n-------\npercentile : scalar or ndarray\nIf `q` is a single percentile and `axis=None`, then the result\nis a scalar. If multiple percentiles are given, first axis of\nthe result corresponds to the percentiles. The other axes are\nthe axes that remain after the reduction of `a`. If the input\ncontains integers or floats smaller than ``float64``, the output\ndata-type is ``float64``. Otherwise, the output data-type is the\nsame as that of the input. If `out` is specified, that array is\nreturned instead.\n\nSee Also\n--------\nnanmean\nnanmedian : equivalent to ``nanpercentile(..., 50)``\npercentile, median, mean\nnanquantile : equivalent to nanpercentile, but with q in the range [0, 1].\n\nNotes\n-----\nGiven a vector ``V`` of length ``N``, the ``q``-th percentile of\n``V`` is the value ``q/100`` of the way from the minimum to the\nmaximum in a sorted copy of ``V``. The values and distances of\nthe two nearest neighbors as well as the `interpolation` parameter\nwill determine the percentile if the normalized ranking does not\nmatch the location of ``q`` exactly. This function is the same as\nthe median if ``q=50``, the same as the minimum if ``q=0`` and the\nsame as the maximum if ``q=100``.\n\nExamples\n--------\n>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])\n>>> a[0][1] = np.nan\n>>> a\narray([[10., nan, 4.],\n[ 3., 2., 1.]])\n>>> np.percentile(a, 50)\nnan\n>>> np.nanpercentile(a, 50)\n3.0\n>>> np.nanpercentile(a, 50, axis=0)\narray([6.5, 2. , 2.5])\n>>> np.nanpercentile(a, 50, axis=1, keepdims=True)\narray([[7.],\n[2.]])\n>>> m = np.nanpercentile(a, 50, axis=0)\n>>> out = np.zeroslike(m)\n>>> np.nanpercentile(a, 50, axis=0, out=out)\narray([6.5, 2. , 2.5])\n>>> m\narray([6.5, 2. , 2.5])\n\n>>> b = a.copy()\n>>> np.nanpercentile(b, 50, axis=1, overwriteinput=True)\narray([7., 2.])\n>>> assert not np.all(a==b)\n" }, { "name": "nanprod", "content": "Return the product of array elements over a given axis treating Not a\nNumbers (NaNs) as ones.\n\nOne is returned for slices that are all-NaN or empty.\n\n.. versionadded:: 1.10.0\n\nParameters\n----------\na : arraylike\nArray containing numbers whose product is desired. If `a` is not an\narray, a conversion is attempted.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the product is computed. The default is to compute\nthe product of the flattened array.\ndtype : data-type, optional\nThe type of the returned array and of the accumulator in which the\nelements are summed. By default, the dtype of `a` is used. An\nexception is when `a` has an integer type with less precision than\nthe platform (u)intp. In that case, the default will be either\n(u)int32 or (u)int64 depending on whether the platform is 32 or 64\nbits. For inexact inputs, dtype must be inexact.\nout : ndarray, optional\nAlternate output array in which to place the result. The default\nis ``None``. If provided, it must have the same shape as the\nexpected output, but the type will be cast if necessary. See\n:ref:`ufuncs-output-type` for more details. The casting of NaN to integer\ncan yield unexpected results.\nkeepdims : bool, optional\nIf True, the axes which are reduced are left in the result as\ndimensions with size one. With this option, the result will\nbroadcast correctly against the original `arr`.\n\nReturns\n-------\nnanprod : ndarray\nA new array holding the result is returned unless `out` is\nspecified, in which case it is returned.\n\nSee Also\n--------\nnumpy.prod : Product across array propagating NaNs.\nisnan : Show which elements are NaN.\n\nExamples\n--------\n>>> np.nanprod(1)\n1\n>>> np.nanprod([1])\n1\n>>> np.nanprod([1, np.nan])\n1.0\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanprod(a)\n6.0\n>>> np.nanprod(a, axis=0)\narray([3., 2.])\n" }, { "name": "nanquantile", "content": "Compute the qth quantile of the data along the specified axis,\nwhile ignoring nan values.\nReturns the qth quantile(s) of the array elements.\n\n.. versionadded:: 1.15.0\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array, containing\nnan values to be ignored\nq : arraylike of float\nQuantile or sequence of quantiles to compute, which must be between\n0 and 1 inclusive.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the quantiles are computed. The\ndefault is to compute the quantile(s) along a flattened\nversion of the array.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output,\nbut the type (of the output) will be cast if necessary.\noverwriteinput : bool, optional\nIf True, then allow the input array `a` to be modified by intermediate\ncalculations, to save memory. In this case, the contents of the input\n`a` after this function completes is undefined.\ninterpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\nThis optional parameter specifies the interpolation method to\nuse when the desired quantile lies between two data points\n``i < j``:\n\n* linear: ``i + (j - i) * fraction``, where ``fraction``\nis the fractional part of the index surrounded by ``i``\nand ``j``.\n* lower: ``i``.\n* higher: ``j``.\n* nearest: ``i`` or ``j``, whichever is nearest.\n* midpoint: ``(i + j) / 2``.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left in\nthe result as dimensions with size one. With this option, the\nresult will broadcast correctly against the original array `a`.\n\nIf this is anything but the default value it will be passed\nthrough (in the special case of an empty array) to the\n`mean` function of the underlying array. If the array is\na sub-class and `mean` does not have the kwarg `keepdims` this\nwill raise a RuntimeError.\n\nReturns\n-------\nquantile : scalar or ndarray\nIf `q` is a single percentile and `axis=None`, then the result\nis a scalar. If multiple quantiles are given, first axis of\nthe result corresponds to the quantiles. The other axes are\nthe axes that remain after the reduction of `a`. If the input\ncontains integers or floats smaller than ``float64``, the output\ndata-type is ``float64``. Otherwise, the output data-type is the\nsame as that of the input. If `out` is specified, that array is\nreturned instead.\n\nSee Also\n--------\nquantile\nnanmean, nanmedian\nnanmedian : equivalent to ``nanquantile(..., 0.5)``\nnanpercentile : same as nanquantile, but with q in the range [0, 100].\n\nExamples\n--------\n>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])\n>>> a[0][1] = np.nan\n>>> a\narray([[10., nan, 4.],\n[ 3., 2., 1.]])\n>>> np.quantile(a, 0.5)\nnan\n>>> np.nanquantile(a, 0.5)\n3.0\n>>> np.nanquantile(a, 0.5, axis=0)\narray([6.5, 2. , 2.5])\n>>> np.nanquantile(a, 0.5, axis=1, keepdims=True)\narray([[7.],\n[2.]])\n>>> m = np.nanquantile(a, 0.5, axis=0)\n>>> out = np.zeroslike(m)\n>>> np.nanquantile(a, 0.5, axis=0, out=out)\narray([6.5, 2. , 2.5])\n>>> m\narray([6.5, 2. , 2.5])\n>>> b = a.copy()\n>>> np.nanquantile(b, 0.5, axis=1, overwriteinput=True)\narray([7., 2.])\n>>> assert not np.all(a==b)\n" }, { "name": "nanstd", "content": "Compute the standard deviation along the specified axis, while\nignoring NaNs.\n\nReturns the standard deviation, a measure of the spread of a\ndistribution, of the non-NaN array elements. The standard deviation is\ncomputed for the flattened array by default, otherwise over the\nspecified axis.\n\nFor all-NaN slices or slices with zero degrees of freedom, NaN is\nreturned and a `RuntimeWarning` is raised.\n\n.. versionadded:: 1.8.0\n\nParameters\n----------\na : arraylike\nCalculate the standard deviation of the non-NaN values.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the standard deviation is computed. The default is\nto compute the standard deviation of the flattened array.\ndtype : dtype, optional\nType to use in computing the standard deviation. For arrays of\ninteger type the default is float64, for arrays of float types it\nis the same as the array type.\nout : ndarray, optional\nAlternative output array in which to place the result. It must have\nthe same shape as the expected output but the type (of the\ncalculated values) will be cast if necessary.\nddof : int, optional\nMeans Delta Degrees of Freedom. The divisor used in calculations\nis ``N - ddof``, where ``N`` represents the number of non-NaN\nelements. By default `ddof` is zero.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `a`.\n\nIf this value is anything but the default it is passed through\nas-is to the relevant functions of the sub-classes. If these\nfunctions do not have a `keepdims` kwarg, a RuntimeError will\nbe raised.\n\nReturns\n-------\nstandarddeviation : ndarray, see dtype parameter above.\nIf `out` is None, return a new array containing the standard\ndeviation, otherwise return a reference to the output array. If\nddof is >= the number of non-NaN elements in a slice or the slice\ncontains only NaNs, then the result for that slice is NaN.\n\nSee Also\n--------\nvar, mean, std\nnanvar, nanmean\n:ref:`ufuncs-output-type`\n\nNotes\n-----\nThe standard deviation is the square root of the average of the squared\ndeviations from the mean: ``std = sqrt(mean(abs(x - x.mean())2))``.\n\nThe average squared deviation is normally calculated as\n``x.sum() / N``, where ``N = len(x)``. If, however, `ddof` is\nspecified, the divisor ``N - ddof`` is used instead. In standard\nstatistical practice, ``ddof=1`` provides an unbiased estimator of the\nvariance of the infinite population. ``ddof=0`` provides a maximum\nlikelihood estimate of the variance for normally distributed variables.\nThe standard deviation computed in this function is the square root of\nthe estimated variance, so even with ``ddof=1``, it will not be an\nunbiased estimate of the standard deviation per se.\n\nNote that, for complex numbers, `std` takes the absolute value before\nsquaring, so that the result is always real and nonnegative.\n\nFor floating-point input, the *std* is computed using the same\nprecision the input has. Depending on the input data, this can cause\nthe results to be inaccurate, especially for float32 (see example\nbelow). Specifying a higher-accuracy accumulator using the `dtype`\nkeyword can alleviate this issue.\n\nExamples\n--------\n>>> a = np.array([[1, np.nan], [3, 4]])\n>>> np.nanstd(a)\n1.247219128924647\n>>> np.nanstd(a, axis=0)\narray([1., 0.])\n>>> np.nanstd(a, axis=1)\narray([0., 0.5]) # may vary\n" }, { "name": "nansum", "content": "Return the sum of array elements over a given axis treating Not a\nNumbers (NaNs) as zero.\n\nIn NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or\nempty. In later versions zero is returned.\n\nParameters\n----------\na : arraylike\nArray containing numbers whose sum is desired. If `a` is not an\narray, a conversion is attempted.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the sum is computed. The default is to compute the\nsum of the flattened array.\ndtype : data-type, optional\nThe type of the returned array and of the accumulator in which the\nelements are summed. By default, the dtype of `a` is used. An\nexception is when `a` has an integer type with less precision than\nthe platform (u)intp. In that case, the default will be either\n(u)int32 or (u)int64 depending on whether the platform is 32 or 64\nbits. For inexact inputs, dtype must be inexact.\n\n.. versionadded:: 1.8.0\nout : ndarray, optional\nAlternate output array in which to place the result. The default\nis ``None``. If provided, it must have the same shape as the\nexpected output, but the type will be cast if necessary. See\n:ref:`ufuncs-output-type` for more details. The casting of NaN to integer\ncan yield unexpected results.\n\n.. versionadded:: 1.8.0\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `a`.\n\n\nIf the value is anything but the default, then\n`keepdims` will be passed through to the `mean` or `sum` methods\nof sub-classes of `ndarray`. If the sub-classes methods\ndoes not implement `keepdims` any exceptions will be raised.\n\n.. versionadded:: 1.8.0\n\nReturns\n-------\nnansum : ndarray.\nA new array holding the result is returned unless `out` is\nspecified, in which it is returned. The result has the same\nsize as `a`, and the same shape as `a` if `axis` is not None\nor `a` is a 1-d array.\n\nSee Also\n--------\nnumpy.sum : Sum across array propagating NaNs.\nisnan : Show which elements are NaN.\nisfinite : Show which elements are not NaN or +/-inf.\n\nNotes\n-----\nIf both positive and negative infinity are present, the sum will be Not\nA Number (NaN).\n\nExamples\n--------\n>>> np.nansum(1)\n1\n>>> np.nansum([1])\n1\n>>> np.nansum([1, np.nan])\n1.0\n>>> a = np.array([[1, 1], [1, np.nan]])\n>>> np.nansum(a)\n3.0\n>>> np.nansum(a, axis=0)\narray([2., 1.])\n>>> np.nansum([1, np.nan, np.inf])\ninf\n>>> np.nansum([1, np.nan, np.NINF])" }, { "name": "-inf", "content": ">>> from numpy.testing import suppresswarnings\n>>> with suppresswarnings() as sup:\n... sup.filter(RuntimeWarning)\n... np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present\nnan\n" }, { "name": "nanvar", "content": "Compute the variance along the specified axis, while ignoring NaNs.\n\nReturns the variance of the array elements, a measure of the spread of\na distribution. The variance is computed for the flattened array by\ndefault, otherwise over the specified axis.\n\nFor all-NaN slices or slices with zero degrees of freedom, NaN is\nreturned and a `RuntimeWarning` is raised.\n\n.. versionadded:: 1.8.0\n\nParameters\n----------\na : arraylike\nArray containing numbers whose variance is desired. If `a` is not an\narray, a conversion is attempted.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the variance is computed. The default is to compute\nthe variance of the flattened array.\ndtype : data-type, optional\nType to use in computing the variance. For arrays of integer type\nthe default is `float64`; for arrays of float types it is the same as\nthe array type.\nout : ndarray, optional\nAlternate output array in which to place the result. It must have\nthe same shape as the expected output, but the type is cast if\nnecessary.\nddof : int, optional\n\"Delta Degrees of Freedom\": the divisor used in the calculation is\n``N - ddof``, where ``N`` represents the number of non-NaN\nelements. By default `ddof` is zero.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the original `a`.\n\n\nReturns\n-------\nvariance : ndarray, see dtype parameter above\nIf `out` is None, return a new array containing the variance,\notherwise return a reference to the output array. If ddof is >= the\nnumber of non-NaN elements in a slice or the slice contains only\nNaNs, then the result for that slice is NaN.\n\nSee Also\n--------\nstd : Standard deviation\nmean : Average\nvar : Variance while not ignoring NaNs\nnanstd, nanmean\n:ref:`ufuncs-output-type`\n\nNotes\n-----\nThe variance is the average of the squared deviations from the mean,\ni.e., ``var = mean(abs(x - x.mean())2)``.\n\nThe mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.\nIf, however, `ddof` is specified, the divisor ``N - ddof`` is used\ninstead. In standard statistical practice, ``ddof=1`` provides an\nunbiased estimator of the variance of a hypothetical infinite\npopulation. ``ddof=0`` provides a maximum likelihood estimate of the\nvariance for normally distributed variables.\n\nNote that for complex numbers, the absolute value is taken before\nsquaring, so that the result is always real and nonnegative.\n\nFor floating-point input, the variance is computed using the same\nprecision the input has. Depending on the input data, this can cause\nthe results to be inaccurate, especially for `float32` (see example\nbelow). Specifying a higher-accuracy accumulator using the ``dtype``\nkeyword can alleviate this issue.\n\nFor this function to work on sub-classes of ndarray, they must define\n`sum` with the kwarg `keepdims`\n\nExamples\n--------\n>>> a = np.array([[1, np.nan], [3, 4]])\n>>> np.nanvar(a)\n1.5555555555555554\n>>> np.nanvar(a, axis=0)\narray([1., 0.])\n>>> np.nanvar(a, axis=1)\narray([0., 0.25]) # may vary\n" }, { "name": "ndfromtxt", "content": "Load ASCII data stored in a file and return it as a single array.\n\n.. deprecated:: 1.17\nndfromtxt` is a deprecated alias of `genfromtxt` which\noverwrites the ``usemask`` argument with `False` even when\nexplicitly called as ``ndfromtxt(..., usemask=True)``.\nUse `genfromtxt` instead.\n\nParameters\n----------\nfname, kwargs : For a description of input parameters, see `genfromtxt`.\n\nSee Also\n--------\nnumpy.genfromtxt : generic function.\n" }, { "name": "ndim", "content": "Return the number of dimensions of an array.\n\nParameters\n----------\na : arraylike\nInput array. If it is not already an ndarray, a conversion is\nattempted.\n\nReturns\n-------\nnumberofdimensions : int\nThe number of dimensions in `a`. Scalars are zero-dimensional.\n\nSee Also\n--------\nndarray.ndim : equivalent method\nshape : dimensions of array\nndarray.shape : dimensions of array\n\nExamples\n--------\n>>> np.ndim([[1,2,3],[4,5,6]])\n2\n>>> np.ndim(np.array([[1,2,3],[4,5,6]]))\n2\n>>> np.ndim(1)\n0\n" }, { "name": "nested_iters", "content": "Create nditers for use in nested loops\n\nCreate a tuple of `nditer` objects which iterate in nested loops over\ndifferent axes of the op argument. The first iterator is used in the\noutermost loop, the last in the innermost loop. Advancing one will change\nthe subsequent iterators to point at its new element.\n\nParameters\n----------\nop : ndarray or sequence of arraylike\nThe array(s) to iterate over.\n\naxes : list of list of int\nEach item is used as an \"opaxes\" argument to an nditer\n\nflags, opflags, opdtypes, order, casting, buffersize (optional)\nSee `nditer` parameters of the same name\n\nReturns\n-------\niters : tuple of nditer\nAn nditer for each item in `axes`, outermost first\n\nSee Also\n--------\nnditer\n\nExamples\n--------\n\nBasic usage. Note how y is the \"flattened\" version of\n[a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified\nthe first iter's axes as [1]\n\n>>> a = np.arange(12).reshape(2, 3, 2)\n>>> i, j = np.nestediters(a, [[1], [0, 2]], flags=[\"multiindex\"])\n>>> for x in i:\n... print(i.multiindex)\n... for y in j:\n... print('', j.multiindex, y)\n(0,)\n(0, 0) 0\n(0, 1) 1\n(1, 0) 6\n(1, 1) 7\n(1,)\n(0, 0) 2\n(0, 1) 3\n(1, 0) 8\n(1, 1) 9\n(2,)\n(0, 0) 4\n(0, 1) 5\n(1, 0) 10\n(1, 1) 11\n" }, { "name": "nonzero", "content": "Return the indices of the elements that are non-zero.\n\nReturns a tuple of arrays, one for each dimension of `a`,\ncontaining the indices of the non-zero elements in that\ndimension. The values in `a` are always tested and returned in\nrow-major, C-style order.\n\nTo group the indices by element, rather than dimension, use `argwhere`,\nwhich returns a row for each non-zero element.\n\n.. note::\n\nWhen called on a zero-d array or scalar, ``nonzero(a)`` is treated\nas ``nonzero(atleast1d(a))``.\n\n.. deprecated:: 1.17.0\n\nUse `atleast1d` explicitly if this behavior is deliberate.\n\nParameters\n----------\na : arraylike\nInput array.\n\nReturns\n-------\ntupleofarrays : tuple\nIndices of elements that are non-zero.\n\nSee Also\n--------\nflatnonzero :\nReturn indices that are non-zero in the flattened version of the input\narray.\nndarray.nonzero :\nEquivalent ndarray method.\ncountnonzero :\nCounts the number of non-zero elements in the input array.\n\nNotes\n-----\nWhile the nonzero values can be obtained with ``a[nonzero(a)]``, it is\nrecommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which\nwill correctly handle 0-d arrays.\n\nExamples\n--------\n>>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])\n>>> x\narray([[3, 0, 0],\n[0, 4, 0],\n[5, 6, 0]])\n>>> np.nonzero(x)\n(array([0, 1, 2, 2]), array([0, 1, 0, 1]))\n\n>>> x[np.nonzero(x)]\narray([3, 4, 5, 6])\n>>> np.transpose(np.nonzero(x))\narray([[0, 0],\n[1, 1],\n[2, 0],\n[2, 1]])\n\nA common use for ``nonzero`` is to find the indices of an array, where\na condition is True. Given an array `a`, the condition `a` > 3 is a\nboolean array and since False is interpreted as 0, np.nonzero(a > 3)\nyields the indices of the `a` where the condition is true.\n\n>>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n>>> a > 3\narray([[False, False, False],\n[ True, True, True],\n[ True, True, True]])\n>>> np.nonzero(a > 3)\n(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))\n\nUsing this result to index `a` is equivalent to using the mask directly:\n\n>>> a[np.nonzero(a > 3)]\narray([4, 5, 6, 7, 8, 9])\n>>> a[a > 3] # prefer this spelling\narray([4, 5, 6, 7, 8, 9])\n\n``nonzero`` can also be called as a method of the array.\n\n>>> (a > 3).nonzero()\n(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))\n" }, { "name": "obj2sctype", "content": "Return the scalar dtype or NumPy equivalent of Python type of an object.\n\nParameters\n----------\nrep : any\nThe object of which the type is returned.\ndefault : any, optional\nIf given, this is returned for objects whose types can not be\ndetermined. If not given, None is returned for those objects.\n\nReturns\n-------\ndtype : dtype or Python type\nThe data type of `rep`.\n\nSee Also\n--------\nsctype2char, issctype, issubsctype, issubdtype, maximumsctype\n\nExamples\n--------\n>>> np.obj2sctype(np.int32)\n\n>>> np.obj2sctype(np.array([1., 2.]))\n\n>>> np.obj2sctype(np.array([1.j]))\n\n\n>>> np.obj2sctype(dict)\n\n>>> np.obj2sctype('string')\n\n>>> np.obj2sctype(1, default=list)\n\n" }, { "name": "ones", "content": "Return a new array of given shape and type, filled with ones.\n\nParameters\n----------\nshape : int or sequence of ints\nShape of the new array, e.g., ``(2, 3)`` or ``2``.\ndtype : data-type, optional\nThe desired data-type for the array, e.g., `numpy.int8`. Default is\n`numpy.float64`.\norder : {'C', 'F'}, optional, default: C\nWhether to store multi-dimensional data in row-major\n(C-style) or column-major (Fortran-style) order in\nmemory.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nArray of ones with the given shape, dtype, and order.\n\nSee Also\n--------\noneslike : Return an array of ones with shape and type of input.\nempty : Return a new uninitialized array.\nzeros : Return a new array setting values to zero.\nfull : Return a new array of given shape filled with value.\n\n\nExamples\n--------\n>>> np.ones(5)\narray([1., 1., 1., 1., 1.])\n\n>>> np.ones((5,), dtype=int)\narray([1, 1, 1, 1, 1])\n\n>>> np.ones((2, 1))\narray([[1.],\n[1.]])\n\n>>> s = (2,2)\n>>> np.ones(s)\narray([[1., 1.],\n[1., 1.]])\n" }, { "name": "ones_like", "content": "Return an array of ones with the same shape and type as a given array.\n\nParameters\n----------\na : arraylike\nThe shape and data-type of `a` define these same attributes of\nthe returned array.\ndtype : data-type, optional\nOverrides the data type of the result.\n\n.. versionadded:: 1.6.0\norder : {'C', 'F', 'A', or 'K'}, optional\nOverrides the memory layout of the result. 'C' means C-order,\n'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,\n'C' otherwise. 'K' means match the layout of `a` as closely\nas possible.\n\n.. versionadded:: 1.6.0\nsubok : bool, optional.\nIf True, then the newly created array will use the sub-class\ntype of `a`, otherwise it will be a base-class array. Defaults\nto True.\nshape : int or sequence of ints, optional.\nOverrides the shape of the result. If order='K' and the number of\ndimensions is unchanged, will try to keep order, otherwise,\norder='C' is implied.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\nout : ndarray\nArray of ones with the same shape and type as `a`.\n\nSee Also\n--------\nemptylike : Return an empty array with shape and type of input.\nzeroslike : Return an array of zeros with shape and type of input.\nfulllike : Return a new array with shape of input filled with value.\nones : Return a new array setting values to one.\n\nExamples\n--------\n>>> x = np.arange(6)\n>>> x = x.reshape((2, 3))\n>>> x\narray([[0, 1, 2],\n[3, 4, 5]])\n>>> np.oneslike(x)\narray([[1, 1, 1],\n[1, 1, 1]])\n\n>>> y = np.arange(3, dtype=float)\n>>> y\narray([0., 1., 2.])\n>>> np.oneslike(y)\narray([1., 1., 1.])\n" }, { "name": "outer", "content": "Compute the outer product of two vectors.\n\nGiven two vectors, ``a = [a0, a1, ..., aM]`` and\n``b = [b0, b1, ..., bN]``,\nthe outer product [1] is::\n\n[[a0*b0 a0*b1 ... a0*bN ]\n[a1*b0 .\n[ ... .\n[aM*b0 aM*bN ]]\n\nParameters\n----------\na : (M,) arraylike\nFirst input vector. Input is flattened if\nnot already 1-dimensional.\nb : (N,) arraylike\nSecond input vector. Input is flattened if\nnot already 1-dimensional.\nout : (M, N) ndarray, optional\nA location where the result is stored\n\n.. versionadded:: 1.9.0\n\nReturns\n-------\nout : (M, N) ndarray\n``out[i, j] = a[i] * b[j]``\n\nSee also\n--------\ninner\neinsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.\nufunc.outer : A generalization to dimensions other than 1D and other\noperations. ``np.multiply.outer(a.ravel(), b.ravel())``\nis the equivalent.\ntensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))``\nis the equivalent.\n\nReferences\n----------\n.. [1] : G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd\ned., Baltimore, MD, Johns Hopkins University Press, 1996,\npg. 8.\n\nExamples\n--------\nMake a (*very* coarse) grid for computing a Mandelbrot set:\n\n>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))\n>>> rl\narray([[-2., -1., 0., 1., 2.],\n[-2., -1., 0., 1., 2.],\n[-2., -1., 0., 1., 2.],\n[-2., -1., 0., 1., 2.],\n[-2., -1., 0., 1., 2.]])\n>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))\n>>> im\narray([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],\n[0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],\n[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n[0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],\n[0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])\n>>> grid = rl + im\n>>> grid\narray([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j],\n[-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j],\n[-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j],\n[-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],\n[-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])\n\nAn example using a \"vector\" of letters:\n\n>>> x = np.array(['a', 'b', 'c'], dtype=object)\n>>> np.outer(x, [1, 2, 3])\narray([['a', 'aa', 'aaa'],\n['b', 'bb', 'bbb'],\n['c', 'cc', 'ccc']], dtype=object)\n" }, { "name": "packbits", "content": "packbits(a, axis=None, bitorder='big')\n\nPacks the elements of a binary-valued array into bits in a uint8 array.\n\nThe result is padded to full bytes by inserting zero bits at the end.\n\nParameters\n----------\na : arraylike\nAn array of integers or booleans whose elements should be packed to\nbits.\naxis : int, optional\nThe dimension over which bit-packing is done.\n``None`` implies packing the flattened array.\nbitorder : {'big', 'little'}, optional\nThe order of the input bits. 'big' will mimic bin(val),\n``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will\nreverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``.\nDefaults to 'big'.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\npacked : ndarray\nArray of type uint8 whose elements represent bits corresponding to the\nlogical (0 or nonzero) value of the input elements. The shape of\n`packed` has the same number of dimensions as the input (unless `axis`\nis None, in which case the output is 1-D).\n\nSee Also\n--------\nunpackbits: Unpacks elements of a uint8 array into a binary-valued output\narray.\n\nExamples\n--------\n>>> a = np.array([[[1,0,1],\n... [0,1,0]],\n... [[1,1,0],\n... [0,0,1]]])\n>>> b = np.packbits(a, axis=-1)\n>>> b\narray([[[160],\n[ 64]],\n[[192],\n[ 32]]], dtype=uint8)\n\nNote that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,\nand 32 = 0010 0000.\n" }, { "name": "pad", "content": "Pad an array.\n\nParameters\n----------\narray : arraylike of rank N\nThe array to pad.\npadwidth : {sequence, arraylike, int}\nNumber of values padded to the edges of each axis.\n((before1, after1), ... (beforeN, afterN)) unique pad widths\nfor each axis.\n((before, after),) yields same before and after pad for each axis.\n(pad,) or int is a shortcut for before = after = pad width for all\naxes.\nmode : str or function, optional\nOne of the following string values or a user supplied function.\n\n'constant' (default)\nPads with a constant value.\n'edge'\nPads with the edge values of array.\n'linearramp'\nPads with the linear ramp between endvalue and the\narray edge value.\n'maximum'\nPads with the maximum value of all or part of the\nvector along each axis.\n'mean'\nPads with the mean value of all or part of the\nvector along each axis.\n'median'\nPads with the median value of all or part of the\nvector along each axis.\n'minimum'\nPads with the minimum value of all or part of the\nvector along each axis.\n'reflect'\nPads with the reflection of the vector mirrored on\nthe first and last values of the vector along each\naxis.\n'symmetric'\nPads with the reflection of the vector mirrored\nalong the edge of the array.\n'wrap'\nPads with the wrap of the vector along the axis.\nThe first values are used to pad the end and the\nend values are used to pad the beginning.\n'empty'\nPads with undefined values.\n\n.. versionadded:: 1.17\n\n\nPadding function, see Notes.\nstatlength : sequence or int, optional\nUsed in 'maximum', 'mean', 'median', and 'minimum'. Number of\nvalues at edge of each axis used to calculate the statistic value.\n\n((before1, after1), ... (beforeN, afterN)) unique statistic\nlengths for each axis.\n\n((before, after),) yields same before and after statistic lengths\nfor each axis.\n\n(statlength,) or int is a shortcut for before = after = statistic\nlength for all axes.\n\nDefault is ``None``, to use the entire axis.\nconstantvalues : sequence or scalar, optional\nUsed in 'constant'. The values to set the padded values for each\naxis.\n\n``((before1, after1), ... (beforeN, afterN))`` unique pad constants\nfor each axis.\n\n``((before, after),)`` yields same before and after constants for each\naxis.\n\n``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for\nall axes.\n\nDefault is 0.\nendvalues : sequence or scalar, optional\nUsed in 'linearramp'. The values used for the ending value of the\nlinearramp and that will form the edge of the padded array.\n\n``((before1, after1), ... (beforeN, afterN))`` unique end values\nfor each axis.\n\n``((before, after),)`` yields same before and after end values for each\naxis.\n\n``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for\nall axes.\n\nDefault is 0.\nreflecttype : {'even', 'odd'}, optional\nUsed in 'reflect', and 'symmetric'. The 'even' style is the\ndefault with an unaltered reflection around the edge value. For\nthe 'odd' style, the extended part of the array is created by\nsubtracting the reflected values from two times the edge value.\n\nReturns\n-------\npad : ndarray\nPadded array of rank equal to `array` with shape increased\naccording to `padwidth`.\n\nNotes\n-----\n.. versionadded:: 1.7.0\n\nFor an array with rank greater than 1, some of the padding of later\naxes is calculated from padding of previous axes. This is easiest to\nthink about with a rank 2 array where the corners of the padded array\nare calculated by using padded values from the first axis.\n\nThe padding function, if used, should modify a rank 1 array in-place. It\nhas the following signature::\n\npaddingfunc(vector, iaxispadwidth, iaxis, kwargs)\n\nwhere\n\nvector : ndarray\nA rank 1 array already padded with zeros. Padded values are\nvector[:iaxispadwidth[0]] and vector[-iaxispadwidth[1]:].\niaxispadwidth : tuple\nA 2-tuple of ints, iaxispadwidth[0] represents the number of\nvalues padded at the beginning of vector where\niaxispadwidth[1] represents the number of values padded at\nthe end of vector.\niaxis : int\nThe axis currently being calculated.\nkwargs : dict\nAny keyword arguments the function requires.\n\nExamples\n--------\n>>> a = [1, 2, 3, 4, 5]\n>>> np.pad(a, (2, 3), 'constant', constantvalues=(4, 6))\narray([4, 4, 1, ..., 6, 6, 6])\n\n>>> np.pad(a, (2, 3), 'edge')\narray([1, 1, 1, ..., 5, 5, 5])\n\n>>> np.pad(a, (2, 3), 'linearramp', endvalues=(5, -4))\narray([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])\n\n>>> np.pad(a, (2,), 'maximum')\narray([5, 5, 1, 2, 3, 4, 5, 5, 5])\n\n>>> np.pad(a, (2,), 'mean')\narray([3, 3, 1, 2, 3, 4, 5, 3, 3])\n\n>>> np.pad(a, (2,), 'median')\narray([3, 3, 1, 2, 3, 4, 5, 3, 3])\n\n>>> a = [[1, 2], [3, 4]]\n>>> np.pad(a, ((3, 2), (2, 3)), 'minimum')\narray([[1, 1, 1, 2, 1, 1, 1],\n[1, 1, 1, 2, 1, 1, 1],\n[1, 1, 1, 2, 1, 1, 1],\n[1, 1, 1, 2, 1, 1, 1],\n[3, 3, 3, 4, 3, 3, 3],\n[1, 1, 1, 2, 1, 1, 1],\n[1, 1, 1, 2, 1, 1, 1]])\n\n>>> a = [1, 2, 3, 4, 5]\n>>> np.pad(a, (2, 3), 'reflect')\narray([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])\n\n>>> np.pad(a, (2, 3), 'reflect', reflecttype='odd')\narray([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])\n\n>>> np.pad(a, (2, 3), 'symmetric')\narray([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])\n\n>>> np.pad(a, (2, 3), 'symmetric', reflecttype='odd')\narray([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])\n\n>>> np.pad(a, (2, 3), 'wrap')\narray([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])\n\n>>> def padwith(vector, padwidth, iaxis, kwargs):\n... padvalue = kwargs.get('padder', 10)\n... vector[:padwidth[0]] = padvalue\n... vector[-padwidth[1]:] = padvalue\n>>> a = np.arange(6)\n>>> a = a.reshape((2, 3))\n>>> np.pad(a, 2, padwith)\narray([[10, 10, 10, 10, 10, 10, 10],\n[10, 10, 10, 10, 10, 10, 10],\n[10, 10, 0, 1, 2, 10, 10],\n[10, 10, 3, 4, 5, 10, 10],\n[10, 10, 10, 10, 10, 10, 10],\n[10, 10, 10, 10, 10, 10, 10]])\n>>> np.pad(a, 2, padwith, padder=100)\narray([[100, 100, 100, 100, 100, 100, 100],\n[100, 100, 100, 100, 100, 100, 100],\n[100, 100, 0, 1, 2, 100, 100],\n[100, 100, 3, 4, 5, 100, 100],\n[100, 100, 100, 100, 100, 100, 100],\n[100, 100, 100, 100, 100, 100, 100]])\n" }, { "name": "partition", "content": "Return a partitioned copy of an array.\n\nCreates a copy of the array with its elements rearranged in such a\nway that the value of the element in k-th position is in the\nposition it would be in a sorted array. All elements smaller than\nthe k-th element are moved before this element and all equal or\ngreater are moved behind it. The ordering of the elements in the two\npartitions is undefined.\n\n.. versionadded:: 1.8.0\n\nParameters\n----------\na : arraylike\nArray to be sorted.\nkth : int or sequence of ints\nElement index to partition by. The k-th value of the element\nwill be in its final sorted position and all smaller elements\nwill be moved before it and all equal or greater elements behind\nit. The order of all elements in the partitions is undefined. If\nprovided with a sequence of k-th it will partition all elements\nindexed by k-th of them into their sorted position at once.\naxis : int or None, optional\nAxis along which to sort. If None, the array is flattened before\nsorting. The default is -1, which sorts along the last axis.\nkind : {'introselect'}, optional\nSelection algorithm. Default is 'introselect'.\norder : str or list of str, optional\nWhen `a` is an array with fields defined, this argument\nspecifies which fields to compare first, second, etc. A single\nfield can be specified as a string. Not all fields need be\nspecified, but unspecified fields will still be used, in the\norder in which they come up in the dtype, to break ties.\n\nReturns\n-------\npartitionedarray : ndarray\nArray of the same type and shape as `a`.\n\nSee Also\n--------\nndarray.partition : Method to sort an array in-place.\nargpartition : Indirect partition.\nsort : Full sorting\n\nNotes\n-----\nThe various selection algorithms are characterized by their average\nspeed, worst case performance, work space size, and whether they are\nstable. A stable sort keeps items with the same key in the same\nrelative order. The available algorithms have the following\nproperties:\n\n================= ======= ============= ============ =======\nkind speed worst case work space stable\n================= ======= ============= ============ =======\n'introselect' 1 O(n) 0 no\n================= ======= ============= ============ =======\n\nAll the partition algorithms make temporary copies of the data when\npartitioning along any but the last axis. Consequently,\npartitioning along the last axis is faster and uses less space than\npartitioning along any other axis.\n\nThe sort order for complex numbers is lexicographic. If both the\nreal and imaginary parts are non-nan then the order is determined by\nthe real parts except when they are equal, in which case the order\nis determined by the imaginary parts.\n\nExamples\n--------\n>>> a = np.array([3, 4, 2, 1])\n>>> np.partition(a, 3)\narray([2, 1, 3, 4])\n\n>>> np.partition(a, (1, 3))\narray([1, 2, 3, 4])\n" }, { "name": "percentile", "content": "Compute the q-th percentile of the data along the specified axis.\n\nReturns the q-th percentile(s) of the array elements.\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array.\nq : arraylike of float\nPercentile or sequence of percentiles to compute, which must be between\n0 and 100 inclusive.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the percentiles are computed. The\ndefault is to compute the percentile(s) along a flattened\nversion of the array.\n\n.. versionchanged:: 1.9.0\nA tuple of axes is supported\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output,\nbut the type (of the output) will be cast if necessary.\noverwriteinput : bool, optional\nIf True, then allow the input array `a` to be modified by intermediate\ncalculations, to save memory. In this case, the contents of the input\n`a` after this function completes is undefined.\n\ninterpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\nThis optional parameter specifies the interpolation method to\nuse when the desired percentile lies between two data points\n``i < j``:\n\n* 'linear': ``i + (j - i) * fraction``, where ``fraction``\nis the fractional part of the index surrounded by ``i``\nand ``j``.\n* 'lower': ``i``.\n* 'higher': ``j``.\n* 'nearest': ``i`` or ``j``, whichever is nearest.\n* 'midpoint': ``(i + j) / 2``.\n\n.. versionadded:: 1.9.0\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left in\nthe result as dimensions with size one. With this option, the\nresult will broadcast correctly against the original array `a`.\n\n.. versionadded:: 1.9.0\n\nReturns\n-------\npercentile : scalar or ndarray\nIf `q` is a single percentile and `axis=None`, then the result\nis a scalar. If multiple percentiles are given, first axis of\nthe result corresponds to the percentiles. The other axes are\nthe axes that remain after the reduction of `a`. If the input\ncontains integers or floats smaller than ``float64``, the output\ndata-type is ``float64``. Otherwise, the output data-type is the\nsame as that of the input. If `out` is specified, that array is\nreturned instead.\n\nSee Also\n--------\nmean\nmedian : equivalent to ``percentile(..., 50)``\nnanpercentile\nquantile : equivalent to percentile, except with q in the range [0, 1].\n\nNotes\n-----\nGiven a vector ``V`` of length ``N``, the q-th percentile of\n``V`` is the value ``q/100`` of the way from the minimum to the\nmaximum in a sorted copy of ``V``. The values and distances of\nthe two nearest neighbors as well as the `interpolation` parameter\nwill determine the percentile if the normalized ranking does not\nmatch the location of ``q`` exactly. This function is the same as\nthe median if ``q=50``, the same as the minimum if ``q=0`` and the\nsame as the maximum if ``q=100``.\n\nExamples\n--------\n>>> a = np.array([[10, 7, 4], [3, 2, 1]])\n>>> a\narray([[10, 7, 4],\n[ 3, 2, 1]])\n>>> np.percentile(a, 50)\n3.5\n>>> np.percentile(a, 50, axis=0)\narray([6.5, 4.5, 2.5])\n>>> np.percentile(a, 50, axis=1)\narray([7., 2.])\n>>> np.percentile(a, 50, axis=1, keepdims=True)\narray([[7.],\n[2.]])\n\n>>> m = np.percentile(a, 50, axis=0)\n>>> out = np.zeroslike(m)\n>>> np.percentile(a, 50, axis=0, out=out)\narray([6.5, 4.5, 2.5])\n>>> m\narray([6.5, 4.5, 2.5])\n\n>>> b = a.copy()\n>>> np.percentile(b, 50, axis=1, overwriteinput=True)\narray([7., 2.])\n>>> assert not np.all(a == b)\n\nThe different types of interpolation can be visualized graphically:\n\n.. plot::\n\nimport matplotlib.pyplot as plt\n\na = np.arange(4)\np = np.linspace(0, 100, 6001)\nax = plt.gca()\nlines = [\n('linear', None),\n('higher', '--'),\n('lower', '--'),\n('nearest', '-.'),\n('midpoint', '-.'),\n]\nfor interpolation, style in lines:\nax.plot(\np, np.percentile(a, p, interpolation=interpolation),\nlabel=interpolation, linestyle=style)\nax.set(\ntitle='Interpolation methods for list: ' + str(a),\nxlabel='Percentile',\nylabel='List item returned',\nyticks=a)\nax.legend()\nplt.show()\n" }, { "name": "piecewise", "content": "Evaluate a piecewise-defined function.\n\nGiven a set of conditions and corresponding functions, evaluate each\nfunction on the input data wherever its condition is true.\n\nParameters\n----------\nx : ndarray or scalar\nThe input domain.\ncondlist : list of bool arrays or bool scalars\nEach boolean array corresponds to a function in `funclist`. Wherever\n`condlist[i]` is True, `funclist[i](x)` is used as the output value.\n\nEach boolean array in `condlist` selects a piece of `x`,\nand should therefore be of the same shape as `x`.\n\nThe length of `condlist` must correspond to that of `funclist`.\nIf one extra function is given, i.e. if\n``len(funclist) == len(condlist) + 1``, then that extra function\nis the default value, used wherever all conditions are false.\nfunclist : list of callables, f(x,*args,kw), or scalars\nEach function is evaluated over `x` wherever its corresponding\ncondition is True. It should take a 1d array as input and give an 1d\narray or a scalar value as output. If, instead of a callable,\na scalar is provided then a constant function (``lambda x: scalar``) is\nassumed.\nargs : tuple, optional\nAny further arguments given to `piecewise` are passed to the functions\nupon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then\neach function is called as ``f(x, 1, 'a')``.\nkw : dict, optional\nKeyword arguments used in calling `piecewise` are passed to the\nfunctions upon execution, i.e., if called\n``piecewise(..., ..., alpha=1)``, then each function is called as\n``f(x, alpha=1)``.\n\nReturns\n-------\nout : ndarray\nThe output is the same shape and type as x and is found by\ncalling the functions in `funclist` on the appropriate portions of `x`,\nas defined by the boolean arrays in `condlist`. Portions not covered\nby any condition have a default value of 0.\n\n\nSee Also\n--------\nchoose, select, where\n\nNotes\n-----\nThis is similar to choose or select, except that functions are\nevaluated on elements of `x` that satisfy the corresponding condition from\n`condlist`.\n\nThe result is::\n\n|--\n|funclist[0](x[condlist[0]])\nout = |funclist[1](x[condlist[1]])\n|...\n|funclist[n2](x[condlist[n2]])\n|--\n\nExamples\n--------\nDefine the sigma function, which is -1 for ``x < 0`` and +1 for ``x >= 0``.\n\n>>> x = np.linspace(-2.5, 2.5, 6)\n>>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])\narray([-1., -1., -1., 1., 1., 1.])\n\nDefine the absolute value, which is ``-x`` for ``x <0`` and ``x`` for\n``x >= 0``.\n\n>>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])\narray([2.5, 1.5, 0.5, 0.5, 1.5, 2.5])\n\nApply the same function to a scalar value.\n\n>>> y = -2\n>>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])\narray(2)\n" }, { "name": "place", "content": "Change elements of an array based on conditional and input values.\n\nSimilar to ``np.copyto(arr, vals, where=mask)``, the difference is that\n`place` uses the first N elements of `vals`, where N is the number of\nTrue values in `mask`, while `copyto` uses the elements where `mask`\nis True.\n\nNote that `extract` does the exact opposite of `place`.\n\nParameters\n----------\narr : ndarray\nArray to put data into.\nmask : arraylike\nBoolean mask array. Must have the same size as `a`.\nvals : 1-D sequence\nValues to put into `a`. Only the first N elements are used, where\nN is the number of True values in `mask`. If `vals` is smaller\nthan N, it will be repeated, and if elements of `a` are to be masked,\nthis sequence must be non-empty.\n\nSee Also\n--------\ncopyto, put, take, extract\n\nExamples\n--------\n>>> arr = np.arange(6).reshape(2, 3)\n>>> np.place(arr, arr>2, [44, 55])\n>>> arr\narray([[ 0, 1, 2],\n[44, 55, 44]])\n" }, { "name": "poly", "content": "Find the coefficients of a polynomial with the given sequence of roots.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nReturns the coefficients of the polynomial whose leading coefficient\nis one for the given sequence of zeros (multiple roots must be included\nin the sequence as many times as their multiplicity; see Examples).\nA square matrix (or array, which will be treated as a matrix) can also\nbe given, in which case the coefficients of the characteristic polynomial\nof the matrix are returned.\n\nParameters\n----------\nseqofzeros : arraylike, shape (N,) or (N, N)\nA sequence of polynomial roots, or a square array or matrix object.\n\nReturns\n-------\nc : ndarray\n1D array of polynomial coefficients from highest to lowest degree:\n\n``c[0] * x(N) + c[1] * x(N-1) + ... + c[N-1] * x + c[N]``\nwhere c[0] always equals 1.\n\nRaises\n------\nValueError\nIf input is the wrong shape (the input must be a 1-D or square\n2-D array).\n\nSee Also\n--------\npolyval : Compute polynomial values.\nroots : Return the roots of a polynomial.\npolyfit : Least squares polynomial fit.\npoly1d : A one-dimensional polynomial class.\n\nNotes\n-----\nSpecifying the roots of a polynomial still leaves one degree of\nfreedom, typically represented by an undetermined leading\ncoefficient. [1] In the case of this function, that coefficient -\nthe first one in the returned array - is always taken as one. (If\nfor some reason you have one other point, the only automatic way\npresently to leverage that information is to use ``polyfit``.)\n\nThe characteristic polynomial, :math:`pa(t)`, of an `n`-by-`n`\nmatrix A is given by\n\n:math:`pa(t) = \\mathrm{det}(t\\, \\mathbf{I} - \\mathbf{A})`,\n\nwhere I is the `n`-by-`n` identity matrix. [2]\n\nReferences\n----------\n.. [1] M. Sullivan and M. Sullivan, III, \"Algebra and Trignometry,\nEnhanced With Graphing Utilities,\" Prentice-Hall, pg. 318, 1996.\n\n.. [2] G. Strang, \"Linear Algebra and Its Applications, 2nd Edition,\"\nAcademic Press, pg. 182, 1980.\n\nExamples\n--------\nGiven a sequence of a polynomial's zeros:\n\n>>> np.poly((0, 0, 0)) # Multiple root example\narray([1., 0., 0., 0.])\n\nThe line above represents z3 + 0*z2 + 0*z + 0.\n\n>>> np.poly((-1./2, 0, 1./2))\narray([ 1. , 0. , -0.25, 0. ])\n\nThe line above represents z3 - z/4\n\n>>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))\narray([ 1. , -0.77086955, 0.08618131, 0. ]) # random\n\nGiven a square array object:\n\n>>> P = np.array([[0, 1./3], [-1./2, 0]])\n>>> np.poly(P)\narray([1. , 0. , 0.16666667])\n\nNote how in all cases the leading coefficient is always 1.\n" }, { "name": "polyadd", "content": "Find the sum of two polynomials.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nReturns the polynomial resulting from the sum of two input polynomials.\nEach input must be either a poly1d object or a 1D sequence of polynomial\ncoefficients, from highest to lowest degree.\n\nParameters\n----------\na1, a2 : arraylike or poly1d object\nInput polynomials.\n\nReturns\n-------\nout : ndarray or poly1d object\nThe sum of the inputs. If either input is a poly1d object, then the\noutput is also a poly1d object. Otherwise, it is a 1D array of\npolynomial coefficients from highest to lowest degree.\n\nSee Also\n--------\npoly1d : A one-dimensional polynomial class.\npoly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval\n\nExamples\n--------\n>>> np.polyadd([1, 2], [9, 5, 4])\narray([9, 6, 6])\n\nUsing poly1d objects:\n\n>>> p1 = np.poly1d([1, 2])\n>>> p2 = np.poly1d([9, 5, 4])\n>>> print(p1)\n1 x + 2\n>>> print(p2)\n2\n9 x + 5 x + 4\n>>> print(np.polyadd(p1, p2))\n2\n9 x + 6 x + 6\n" }, { "name": "polyder", "content": "Return the derivative of the specified order of a polynomial.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nParameters\n----------\np : poly1d or sequence\nPolynomial to differentiate.\nA sequence is interpreted as polynomial coefficients, see `poly1d`.\nm : int, optional\nOrder of differentiation (default: 1)\n\nReturns\n-------\nder : poly1d\nA new polynomial representing the derivative.\n\nSee Also\n--------\npolyint : Anti-derivative of a polynomial.\npoly1d : Class for one-dimensional polynomials.\n\nExamples\n--------\nThe derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:\n\n>>> p = np.poly1d([1,1,1,1])\n>>> p2 = np.polyder(p)\n>>> p2\npoly1d([3, 2, 1])\n\nwhich evaluates to:\n\n>>> p2(2.)\n17.0\n\nWe can verify this, approximating the derivative with\n``(f(x + h) - f(x))/h``:\n\n>>> (p(2. + 0.001) - p(2.)) / 0.001\n17.007000999997857\n\nThe fourth-order derivative of a 3rd-order polynomial is zero:\n\n>>> np.polyder(p, 2)\npoly1d([6, 2])\n>>> np.polyder(p, 3)\npoly1d([6])\n>>> np.polyder(p, 4)\npoly1d([0])\n" }, { "name": "polydiv", "content": "Returns the quotient and remainder of polynomial division.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nThe input arrays are the coefficients (including any coefficients\nequal to zero) of the \"numerator\" (dividend) and \"denominator\"\n(divisor) polynomials, respectively.\n\nParameters\n----------\nu : arraylike or poly1d\nDividend polynomial's coefficients.\n\nv : arraylike or poly1d\nDivisor polynomial's coefficients.\n\nReturns\n-------\nq : ndarray\nCoefficients, including those equal to zero, of the quotient.\nr : ndarray\nCoefficients, including those equal to zero, of the remainder.\n\nSee Also\n--------\npoly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub\npolyval\n\nNotes\n-----\nBoth `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need\nnot equal `v.ndim`. In other words, all four possible combinations -\n``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,\n``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.\n\nExamples\n--------\n.. math:: \\frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25\n\n>>> x = np.array([3.0, 5.0, 2.0])\n>>> y = np.array([2.0, 1.0])\n>>> np.polydiv(x, y)\n(array([1.5 , 1.75]), array([0.25]))\n" }, { "name": "polyfit", "content": "Least squares polynomial fit.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nFit a polynomial ``p(x) = p[0] * xdeg + ... + p[deg]`` of degree `deg`\nto points `(x, y)`. Returns a vector of coefficients `p` that minimises\nthe squared error in the order `deg`, `deg-1`, ... `0`.\n\nThe `Polynomial.fit ` class\nmethod is recommended for new code as it is more stable numerically. See\nthe documentation of the method for more information.\n\nParameters\n----------\nx : arraylike, shape (M,)\nx-coordinates of the M sample points ``(x[i], y[i])``.\ny : arraylike, shape (M,) or (M, K)\ny-coordinates of the sample points. Several data sets of sample\npoints sharing the same x-coordinates can be fitted at once by\npassing in a 2D-array that contains one dataset per column.\ndeg : int\nDegree of the fitting polynomial\nrcond : float, optional\nRelative condition number of the fit. Singular values smaller than\nthis relative to the largest singular value will be ignored. The\ndefault value is len(x)*eps, where eps is the relative precision of\nthe float type, about 2e-16 in most cases.\nfull : bool, optional\nSwitch determining nature of return value. When it is False (the\ndefault) just the coefficients are returned, when True diagnostic\ninformation from the singular value decomposition is also returned.\nw : arraylike, shape (M,), optional\nWeights to apply to the y-coordinates of the sample points. For\ngaussian uncertainties, use 1/sigma (not 1/sigma2).\ncov : bool or str, optional\nIf given and not `False`, return not just the estimate but also its\ncovariance matrix. By default, the covariance are scaled by\nchi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed\nto be unreliable except in a relative sense and everything is scaled\nsuch that the reduced chi2 is unity. This scaling is omitted if\n``cov='unscaled'``, as is relevant for the case that the weights are\n1/sigma2, with sigma known to be a reliable estimate of the\nuncertainty.\n\nReturns\n-------\np : ndarray, shape (deg + 1,) or (deg + 1, K)\nPolynomial coefficients, highest power first. If `y` was 2-D, the\ncoefficients for `k`-th data set are in ``p[:,k]``.\n\nresiduals, rank, singularvalues, rcond\nPresent only if `full` = True. Residuals is sum of squared residuals\nof the least-squares fit, the effective rank of the scaled Vandermonde\ncoefficient matrix, its singular values, and the specified value of\n`rcond`. For more details, see `linalg.lstsq`.\n\nV : ndarray, shape (M,M) or (M,M,K)\nPresent only if `full` = False and `cov`=True. The covariance\nmatrix of the polynomial coefficient estimates. The diagonal of\nthis matrix are the variance estimates for each coefficient. If y\nis a 2-D array, then the covariance matrix for the `k`-th data set\nare in ``V[:,:,k]``\n\n\nWarns\n-----\nRankWarning\nThe rank of the coefficient matrix in the least-squares fit is\ndeficient. The warning is only raised if `full` = False.\n\nThe warnings can be turned off by\n\n>>> import warnings\n>>> warnings.simplefilter('ignore', np.RankWarning)\n\nSee Also\n--------\npolyval : Compute polynomial values.\nlinalg.lstsq : Computes a least-squares fit.\nscipy.interpolate.UnivariateSpline : Computes spline fits.\n\nNotes\n-----\nThe solution minimizes the squared error\n\n.. math ::\nE = \\sum{j=0}^k |p(xj) - yj|^2\n\nin the equations::\n\nx[0]n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]\nx[1]n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]\n...\nx[k]n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]\n\nThe coefficient matrix of the coefficients `p` is a Vandermonde matrix.\n\n`polyfit` issues a `RankWarning` when the least-squares fit is badly\nconditioned. This implies that the best fit is not well-defined due\nto numerical error. The results may be improved by lowering the polynomial\ndegree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter\ncan also be set to a value smaller than its default, but the resulting\nfit may be spurious: including contributions from the small singular\nvalues can add numerical noise to the result.\n\nNote that fitting polynomial coefficients is inherently badly conditioned\nwhen the degree of the polynomial is large or the interval of sample points\nis badly centered. The quality of the fit should always be checked in these\ncases. When polynomial fits are not satisfactory, splines may be a good\nalternative.\n\nReferences\n----------\n.. [1] Wikipedia, \"Curve fitting\",\nhttps://en.wikipedia.org/wiki/Curvefitting\n.. [2] Wikipedia, \"Polynomial interpolation\",\nhttps://en.wikipedia.org/wiki/Polynomialinterpolation\n\nExamples\n--------\n>>> import warnings\n>>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])\n>>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])\n>>> z = np.polyfit(x, y, 3)\n>>> z\narray([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary\n\nIt is convenient to use `poly1d` objects for dealing with polynomials:\n\n>>> p = np.poly1d(z)\n>>> p(0.5)\n0.6143849206349179 # may vary\n>>> p(3.5)\n-0.34732142857143039 # may vary\n>>> p(10)\n22.579365079365115 # may vary\n\nHigh-order polynomials may oscillate wildly:\n\n>>> with warnings.catchwarnings():\n... warnings.simplefilter('ignore', np.RankWarning)\n... p30 = np.poly1d(np.polyfit(x, y, 30))\n...\n>>> p30(4)\n-0.80000000000000204 # may vary\n>>> p30(5)\n-0.99999999999999445 # may vary\n>>> p30(4.5)\n-0.10547061179440398 # may vary\n\nIllustration:\n\n>>> import matplotlib.pyplot as plt\n>>> xp = np.linspace(-2, 6, 100)\n>>> = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')\n>>> plt.ylim(-2,2)\n(-2, 2)\n>>> plt.show()\n" }, { "name": "polyint", "content": "Return an antiderivative (indefinite integral) of a polynomial.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nThe returned order `m` antiderivative `P` of polynomial `p` satisfies\n:math:`\\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`\nintegration constants `k`. The constants determine the low-order\npolynomial part\n\n.. math:: \\frac{k{m-1}}{0!} x^0 + \\ldots + \\frac{k0}{(m-1)!}x^{m-1}\n\nof `P` so that :math:`P^{(j)}(0) = k{m-j-1}`.\n\nParameters\n----------\np : arraylike or poly1d\nPolynomial to integrate.\nA sequence is interpreted as polynomial coefficients, see `poly1d`.\nm : int, optional\nOrder of the antiderivative. (Default: 1)\nk : list of `m` scalars or scalar, optional\nIntegration constants. They are given in the order of integration:\nthose corresponding to highest-order terms come first.\n\nIf ``None`` (default), all constants are assumed to be zero.\nIf `m = 1`, a single scalar can be given instead of a list.\n\nSee Also\n--------\npolyder : derivative of a polynomial\npoly1d.integ : equivalent method\n\nExamples\n--------\nThe defining property of the antiderivative:\n\n>>> p = np.poly1d([1,1,1])\n>>> P = np.polyint(p)\n>>> P\npoly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary\n>>> np.polyder(P) == p\nTrue\n\nThe integration constants default to zero, but can be specified:\n\n>>> P = np.polyint(p, 3)\n>>> P(0)\n0.0\n>>> np.polyder(P)(0)\n0.0\n>>> np.polyder(P, 2)(0)\n0.0\n>>> P = np.polyint(p, 3, k=[6,5,3])\n>>> P\npoly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may vary\n\nNote that 3 = 6 / 2!, and that the constants are given in the order of\nintegrations. Constant of the highest-order polynomial term comes first:\n\n>>> np.polyder(P, 2)(0)\n6.0\n>>> np.polyder(P, 1)(0)\n5.0\n>>> P(0)\n3.0\n" }, { "name": "polymul", "content": "Find the product of two polynomials.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nFinds the polynomial resulting from the multiplication of the two input\npolynomials. Each input must be either a poly1d object or a 1D sequence\nof polynomial coefficients, from highest to lowest degree.\n\nParameters\n----------\na1, a2 : arraylike or poly1d object\nInput polynomials.\n\nReturns\n-------\nout : ndarray or poly1d object\nThe polynomial resulting from the multiplication of the inputs. If\neither inputs is a poly1d object, then the output is also a poly1d\nobject. Otherwise, it is a 1D array of polynomial coefficients from\nhighest to lowest degree.\n\nSee Also\n--------\npoly1d : A one-dimensional polynomial class.\npoly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval\nconvolve : Array convolution. Same output as polymul, but has parameter\nfor overlap mode.\n\nExamples\n--------\n>>> np.polymul([1, 2, 3], [9, 5, 1])\narray([ 9, 23, 38, 17, 3])\n\nUsing poly1d objects:\n\n>>> p1 = np.poly1d([1, 2, 3])\n>>> p2 = np.poly1d([9, 5, 1])\n>>> print(p1)\n2\n1 x + 2 x + 3\n>>> print(p2)\n2\n9 x + 5 x + 1\n>>> print(np.polymul(p1, p2))\n4 3 2\n9 x + 23 x + 38 x + 17 x + 3\n" }, { "name": "polysub", "content": "Difference (subtraction) of two polynomials.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nGiven two polynomials `a1` and `a2`, returns ``a1 - a2``.\n`a1` and `a2` can be either arraylike sequences of the polynomials'\ncoefficients (including coefficients equal to zero), or `poly1d` objects.\n\nParameters\n----------\na1, a2 : arraylike or poly1d\nMinuend and subtrahend polynomials, respectively.\n\nReturns\n-------\nout : ndarray or poly1d\nArray or `poly1d` object of the difference polynomial's coefficients.\n\nSee Also\n--------\npolyval, polydiv, polymul, polyadd\n\nExamples\n--------\n.. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)\n\n>>> np.polysub([2, 10, -2], [3, 10, -4])\narray([-1, 0, 2])\n" }, { "name": "polyval", "content": "Evaluate a polynomial at specific values.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nIf `p` is of length N, this function returns the value:\n\n``p[0]*x(N-1) + p[1]*x(N-2) + ... + p[N-2]*x + p[N-1]``\n\nIf `x` is a sequence, then ``p(x)`` is returned for each element of ``x``.\nIf `x` is another polynomial then the composite polynomial ``p(x(t))``\nis returned.\n\nParameters\n----------\np : arraylike or poly1d object\n1D array of polynomial coefficients (including coefficients equal\nto zero) from highest degree to the constant term, or an\ninstance of poly1d.\nx : arraylike or poly1d object\nA number, an array of numbers, or an instance of poly1d, at\nwhich to evaluate `p`.\n\nReturns\n-------\nvalues : ndarray or poly1d\nIf `x` is a poly1d instance, the result is the composition of the two\npolynomials, i.e., `x` is \"substituted\" in `p` and the simplified\nresult is returned. In addition, the type of `x` - arraylike or\npoly1d - governs the type of the output: `x` arraylike => `values`\narraylike, `x` a poly1d object => `values` is also.\n\nSee Also\n--------\npoly1d: A polynomial class.\n\nNotes\n-----\nHorner's scheme [1] is used to evaluate the polynomial. Even so,\nfor polynomials of high degree the values may be inaccurate due to\nrounding errors. Use carefully.\n\nIf `x` is a subtype of `ndarray` the return value will be of the same type.\n\nReferences\n----------\n.. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.\ntrans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand\nReinhold Co., 1985, pg. 720.\n\nExamples\n--------\n>>> np.polyval([3,0,1], 5) # 3 * 52 + 0 * 51 + 1\n76\n>>> np.polyval([3,0,1], np.poly1d(5))\npoly1d([76])\n>>> np.polyval(np.poly1d([3,0,1]), 5)\n76\n>>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))\npoly1d([76])\n" }, { "name": "printoptions", "content": "Context manager for setting print options.\n\nSet print options for the scope of the `with` block, and restore the old\noptions at the end. See `setprintoptions` for the full description of\navailable options.\n\nExamples\n--------\n\n>>> from numpy.testing import assertequal\n>>> with np.printoptions(precision=2):\n... np.array([2.0]) / 3\narray([0.67])\n\nThe `as`-clause of the `with`-statement gives the current print options:\n\n>>> with np.printoptions(precision=2) as opts:\n... assertequal(opts, np.getprintoptions())\n\nSee Also\n--------\nsetprintoptions, getprintoptions\n" }, { "name": "prod", "content": "Return the product of array elements over a given axis.\n\nParameters\n----------\na : arraylike\nInput data.\naxis : None or int or tuple of ints, optional\nAxis or axes along which a product is performed. The default,\naxis=None, will calculate the product of all the elements in the\ninput array. If axis is negative it counts from the last to the\nfirst axis.\n\n.. versionadded:: 1.7.0\n\nIf axis is a tuple of ints, a product is performed on all of the\naxes specified in the tuple instead of a single axis or all the\naxes as before.\ndtype : dtype, optional\nThe type of the returned array, as well as of the accumulator in\nwhich the elements are multiplied. The dtype of `a` is used by\ndefault unless `a` has an integer dtype of less precision than the\ndefault platform integer. In that case, if `a` is signed then the\nplatform integer is used while if `a` is unsigned then an unsigned\ninteger of the same precision as the platform integer is used.\nout : ndarray, optional\nAlternative output array in which to place the result. It must have\nthe same shape as the expected output, but the type of the output\nvalues will be cast if necessary.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left in the\nresult as dimensions with size one. With this option, the result\nwill broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `prod` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\ninitial : scalar, optional\nThe starting value for this product. See `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.15.0\n\nwhere : arraylike of bool, optional\nElements to include in the product. See `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\nproductalongaxis : ndarray, see `dtype` parameter above.\nAn array shaped as `a` but with the specified axis removed.\nReturns a reference to `out` if specified.\n\nSee Also\n--------\nndarray.prod : equivalent method\n:ref:`ufuncs-output-type`\n\nNotes\n-----\nArithmetic is modular when using integer types, and no error is\nraised on overflow. That means that, on a 32-bit platform:\n\n>>> x = np.array([536870910, 536870910, 536870910, 536870910])\n>>> np.prod(x)\n16 # may vary\n\nThe product of an empty array is the neutral element 1:\n\n>>> np.prod([])\n1.0\n\nExamples\n--------\nBy default, calculate the product of all elements:\n\n>>> np.prod([1.,2.])\n2.0\n\nEven when the input array is two-dimensional:\n\n>>> np.prod([[1.,2.],[3.,4.]])\n24.0\n\nBut we can also specify the axis over which to multiply:\n\n>>> np.prod([[1.,2.],[3.,4.]], axis=1)\narray([ 2., 12.])\n\nOr select specific elements to include:\n\n>>> np.prod([1., np.nan, 3.], where=[True, False, True])\n3.0\n\nIf the type of `x` is unsigned, then the output type is\nthe unsigned platform integer:\n\n>>> x = np.array([1, 2, 3], dtype=np.uint8)\n>>> np.prod(x).dtype == np.uint\nTrue\n\nIf `x` is of a signed integer type, then the output type\nis the default platform integer:\n\n>>> x = np.array([1, 2, 3], dtype=np.int8)\n>>> np.prod(x).dtype == int\nTrue\n\nYou can also start the product with a value other than one:\n\n>>> np.prod([1, 2], initial=5)\n10\n" }, { "name": "product", "content": "Return the product of array elements over a given axis.\n\nSee Also\n--------\nprod : equivalent function; see for details.\n" }, { "name": "promote_types", "content": "promotetypes(type1, type2)\n\nReturns the data type with the smallest size and smallest scalar\nkind to which both ``type1`` and ``type2`` may be safely cast.\nThe returned data type is always in native byte order.\n\nThis function is symmetric, but rarely associative.\n\nParameters\n----------\ntype1 : dtype or dtype specifier\nFirst data type.\ntype2 : dtype or dtype specifier\nSecond data type.\n\nReturns\n-------\nout : dtype\nThe promoted data type.\n\nNotes\n-----\n.. versionadded:: 1.6.0\n\nStarting in NumPy 1.9, promotetypes function now returns a valid string\nlength when given an integer or float dtype as one argument and a string\ndtype as another argument. Previously it always returned the input string\ndtype, even if it wasn't long enough to store the max integer/float value\nconverted to a string.\n\nSee Also\n--------\nresulttype, dtype, cancast\n\nExamples\n--------\n>>> np.promotetypes('f4', 'f8')\ndtype('float64')\n\n>>> np.promotetypes('i8', 'f4')\ndtype('float64')\n\n>>> np.promotetypes('>i8', '>> np.promotetypes('i4', 'S8')\ndtype('S11')\n\nAn example of a non-associative case:\n\n>>> p = np.promotetypes\n>>> p('S', p('i1', 'u1'))\ndtype('S6')\n>>> p(p('S', 'i1'), 'u1')\ndtype('S4')\n" }, { "name": "ptp", "content": "Range of values (maximum - minimum) along an axis.\n\nThe name of the function comes from the acronym for 'peak to peak'.\n\n.. warning::\n`ptp` preserves the data type of the array. This means the\nreturn value for an input of signed integers with n bits\n(e.g. `np.int8`, `np.int16`, etc) is also a signed integer\nwith n bits. In that case, peak-to-peak values greater than\n``2(n-1)-1`` will be returned as negative values. An example\nwith a work-around is shown below.\n\nParameters\n----------\na : arraylike\nInput values.\naxis : None or int or tuple of ints, optional\nAxis along which to find the peaks. By default, flatten the\narray. `axis` may be negative, in\nwhich case it counts from the last to the first axis.\n\n.. versionadded:: 1.15.0\n\nIf this is a tuple of ints, a reduction is performed on multiple\naxes, instead of a single axis or all the axes as before.\nout : arraylike\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output,\nbut the type of the output values will be cast if necessary.\n\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `ptp` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\nReturns\n-------\nptp : ndarray\nA new array holding the result, unless `out` was\nspecified, in which case a reference to `out` is returned.\n\nExamples\n--------\n>>> x = np.array([[4, 9, 2, 10],\n... [6, 9, 7, 12]])\n\n>>> np.ptp(x, axis=1)\narray([8, 6])\n\n>>> np.ptp(x, axis=0)\narray([2, 0, 5, 2])\n\n>>> np.ptp(x)\n10\n\nThis example shows that a negative value can be returned when\nthe input is an array of signed integers.\n\n>>> y = np.array([[1, 127],\n... [0, 127],\n... [-1, 127],\n... [-2, 127]], dtype=np.int8)\n>>> np.ptp(y, axis=1)\narray([ 126, 127, -128, -127], dtype=int8)\n\nA work-around is to use the `view()` method to view the result as\nunsigned integers with the same bit width:\n\n>>> np.ptp(y, axis=1).view(np.uint8)\narray([126, 127, 128, 129], dtype=uint8)\n" }, { "name": "put", "content": "Replaces specified elements of an array with given values.\n\nThe indexing works on the flattened target array. `put` is roughly\nequivalent to:\n\n::\n\na.flat[ind] = v\n\nParameters\n----------\na : ndarray\nTarget array.\nind : arraylike\nTarget indices, interpreted as integers.\nv : arraylike\nValues to place in `a` at target indices. If `v` is shorter than\n`ind` it will be repeated as necessary.\nmode : {'raise', 'wrap', 'clip'}, optional\nSpecifies how out-of-bounds indices will behave.\n\n* 'raise' -- raise an error (default)\n* 'wrap' -- wrap around\n* 'clip' -- clip to the range\n\n'clip' mode means that all indices that are too large are replaced\nby the index that addresses the last element along that axis. Note\nthat this disables indexing with negative numbers. In 'raise' mode,\nif an exception occurs the target array may still be modified.\n\nSee Also\n--------\nputmask, place\nputalongaxis : Put elements by matching the array and the index arrays\n\nExamples\n--------\n>>> a = np.arange(5)\n>>> np.put(a, [0, 2], [-44, -55])\n>>> a\narray([-44, 1, -55, 3, 4])\n\n>>> a = np.arange(5)\n>>> np.put(a, 22, -5, mode='clip')\n>>> a\narray([ 0, 1, 2, 3, -5])\n" }, { "name": "put_along_axis", "content": "Put values into the destination array by matching 1d index and data slices.\n\nThis iterates over matching 1d slices oriented along the specified axis in\nthe index and data arrays, and uses the former to place values into the\nlatter. These slices can be different lengths.\n\nFunctions returning an index along an axis, like `argsort` and\n`argpartition`, produce suitable indices for this function.\n\n.. versionadded:: 1.15.0\n\nParameters\n----------\narr : ndarray (Ni..., M, Nk...)\nDestination array.\nindices : ndarray (Ni..., J, Nk...)\nIndices to change along each 1d slice of `arr`. This must match the\ndimension of arr, but dimensions in Ni and Nj may be 1 to broadcast\nagainst `arr`.\nvalues : arraylike (Ni..., J, Nk...)\nvalues to insert at those indices. Its shape and dimension are\nbroadcast to match that of `indices`.\naxis : int\nThe axis to take 1d slices along. If axis is None, the destination\narray is treated as if a flattened 1d view had been created of it.\n\nNotes\n-----\nThis is equivalent to (but faster than) the following use of `ndindex` and\n`s`, which sets each of ``ii`` and ``kk`` to a tuple of indices::\n\nNi, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]\nJ = indices.shape[axis] # Need not equal M\n\nfor ii in ndindex(Ni):\nfor kk in ndindex(Nk):\na1d = a [ii + s[:,] + kk]\nindices1d = indices[ii + s[:,] + kk]\nvalues1d = values [ii + s[:,] + kk]\nfor j in range(J):\na1d[indices1d[j]] = values1d[j]\n\nEquivalently, eliminating the inner loop, the last two lines would be::\n\na1d[indices1d] = values1d\n\nSee Also\n--------\ntakealongaxis :\nTake values from the input array by matching 1d index and data slices\n\nExamples\n--------\n\nFor this sample array\n\n>>> a = np.array([[10, 30, 20], [60, 40, 50]])\n\nWe can replace the maximum values with:\n\n>>> ai = np.expanddims(np.argmax(a, axis=1), axis=1)\n>>> ai\narray([[1],\n[0]])\n>>> np.putalongaxis(a, ai, 99, axis=1)\n>>> a\narray([[10, 99, 20],\n[99, 40, 50]])\n" }, { "name": "putmask", "content": "putmask(a, mask, values)\n\nChanges elements of an array based on conditional and input values.\n\nSets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.\n\nIf `values` is not the same size as `a` and `mask` then it will repeat.\nThis gives behavior different from ``a[mask] = values``.\n\nParameters\n----------\na : ndarray\nTarget array.\nmask : arraylike\nBoolean mask array. It has to be the same shape as `a`.\nvalues : arraylike\nValues to put into `a` where `mask` is True. If `values` is smaller\nthan `a` it will be repeated.\n\nSee Also\n--------\nplace, put, take, copyto\n\nExamples\n--------\n>>> x = np.arange(6).reshape(2, 3)\n>>> np.putmask(x, x>2, x2)\n>>> x\narray([[ 0, 1, 2],\n[ 9, 16, 25]])\n\nIf `values` is smaller than `a` it is repeated:\n\n>>> x = np.arange(5)\n>>> np.putmask(x, x>1, [-33, -44])\n>>> x\narray([ 0, 1, -33, -44, -33])\n" }, { "name": "quantile", "content": "Compute the q-th quantile of the data along the specified axis.\n\n.. versionadded:: 1.15.0\n\nParameters\n----------\na : arraylike\nInput array or object that can be converted to an array.\nq : arraylike of float\nQuantile or sequence of quantiles to compute, which must be between\n0 and 1 inclusive.\naxis : {int, tuple of int, None}, optional\nAxis or axes along which the quantiles are computed. The\ndefault is to compute the quantile(s) along a flattened\nversion of the array.\nout : ndarray, optional\nAlternative output array in which to place the result. It must\nhave the same shape and buffer length as the expected output,\nbut the type (of the output) will be cast if necessary.\noverwriteinput : bool, optional\nIf True, then allow the input array `a` to be modified by intermediate\ncalculations, to save memory. In this case, the contents of the input\n`a` after this function completes is undefined.\ninterpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\nThis optional parameter specifies the interpolation method to\nuse when the desired quantile lies between two data points\n``i < j``:\n\n* linear: ``i + (j - i) * fraction``, where ``fraction``\nis the fractional part of the index surrounded by ``i``\nand ``j``.\n* lower: ``i``.\n* higher: ``j``.\n* nearest: ``i`` or ``j``, whichever is nearest.\n* midpoint: ``(i + j) / 2``.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left in\nthe result as dimensions with size one. With this option, the\nresult will broadcast correctly against the original array `a`.\n\nReturns\n-------\nquantile : scalar or ndarray\nIf `q` is a single quantile and `axis=None`, then the result\nis a scalar. If multiple quantiles are given, first axis of\nthe result corresponds to the quantiles. The other axes are\nthe axes that remain after the reduction of `a`. If the input\ncontains integers or floats smaller than ``float64``, the output\ndata-type is ``float64``. Otherwise, the output data-type is the\nsame as that of the input. If `out` is specified, that array is\nreturned instead.\n\nSee Also\n--------\nmean\npercentile : equivalent to quantile, but with q in the range [0, 100].\nmedian : equivalent to ``quantile(..., 0.5)``\nnanquantile\n\nNotes\n-----\nGiven a vector ``V`` of length ``N``, the q-th quantile of\n``V`` is the value ``q`` of the way from the minimum to the\nmaximum in a sorted copy of ``V``. The values and distances of\nthe two nearest neighbors as well as the `interpolation` parameter\nwill determine the quantile if the normalized ranking does not\nmatch the location of ``q`` exactly. This function is the same as\nthe median if ``q=0.5``, the same as the minimum if ``q=0.0`` and the\nsame as the maximum if ``q=1.0``.\n\nExamples\n--------\n>>> a = np.array([[10, 7, 4], [3, 2, 1]])\n>>> a\narray([[10, 7, 4],\n[ 3, 2, 1]])\n>>> np.quantile(a, 0.5)\n3.5\n>>> np.quantile(a, 0.5, axis=0)\narray([6.5, 4.5, 2.5])\n>>> np.quantile(a, 0.5, axis=1)\narray([7., 2.])\n>>> np.quantile(a, 0.5, axis=1, keepdims=True)\narray([[7.],\n[2.]])\n>>> m = np.quantile(a, 0.5, axis=0)\n>>> out = np.zeroslike(m)\n>>> np.quantile(a, 0.5, axis=0, out=out)\narray([6.5, 4.5, 2.5])\n>>> m\narray([6.5, 4.5, 2.5])\n>>> b = a.copy()\n>>> np.quantile(b, 0.5, axis=1, overwriteinput=True)\narray([7., 2.])\n>>> assert not np.all(a == b)\n" }, { "name": "ravel", "content": "Return a contiguous flattened array.\n\nA 1-D array, containing the elements of the input, is returned. A copy is\nmade only if needed.\n\nAs of NumPy 1.10, the returned array will have the same type as the input\narray. (for example, a masked array will be returned for a masked array\ninput)\n\nParameters\n----------\na : arraylike\nInput array. The elements in `a` are read in the order specified by\n`order`, and packed as a 1-D array.\norder : {'C','F', 'A', 'K'}, optional\n\nThe elements of `a` are read using this index order. 'C' means\nto index the elements in row-major, C-style order,\nwith the last axis index changing fastest, back to the first\naxis index changing slowest. 'F' means to index the elements\nin column-major, Fortran-style order, with the\nfirst index changing fastest, and the last index changing\nslowest. Note that the 'C' and 'F' options take no account of\nthe memory layout of the underlying array, and only refer to\nthe order of axis indexing. 'A' means to read the elements in\nFortran-like index order if `a` is Fortran *contiguous* in\nmemory, C-like order otherwise. 'K' means to read the\nelements in the order they occur in memory, except for\nreversing the data when strides are negative. By default, 'C'\nindex order is used.\n\nReturns\n-------\ny : arraylike\ny is an array of the same subtype as `a`, with shape ``(a.size,)``.\nNote that matrices are special cased for backward compatibility, if `a`\nis a matrix, then y is a 1-D ndarray.\n\nSee Also\n--------\nndarray.flat : 1-D iterator over an array.\nndarray.flatten : 1-D array copy of the elements of an array\nin row-major order.\nndarray.reshape : Change the shape of an array without changing its data.\n\nNotes\n-----\nIn row-major, C-style order, in two dimensions, the row index\nvaries the slowest, and the column index the quickest. This can\nbe generalized to multiple dimensions, where row-major order\nimplies that the index along the first axis varies slowest, and\nthe index along the last quickest. The opposite holds for\ncolumn-major, Fortran-style index ordering.\n\nWhen a view is desired in as many cases as possible, ``arr.reshape(-1)``\nmay be preferable.\n\nExamples\n--------\nIt is equivalent to ``reshape(-1, order=order)``.\n\n>>> x = np.array([[1, 2, 3], [4, 5, 6]])\n>>> np.ravel(x)\narray([1, 2, 3, 4, 5, 6])\n\n>>> x.reshape(-1)\narray([1, 2, 3, 4, 5, 6])\n\n>>> np.ravel(x, order='F')\narray([1, 4, 2, 5, 3, 6])\n\nWhen ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:\n\n>>> np.ravel(x.T)\narray([1, 4, 2, 5, 3, 6])\n>>> np.ravel(x.T, order='A')\narray([1, 2, 3, 4, 5, 6])\n\nWhen ``order`` is 'K', it will preserve orderings that are neither 'C'\nnor 'F', but won't reverse axes:\n\n>>> a = np.arange(3)[::-1]; a\narray([2, 1, 0])\n>>> a.ravel(order='C')\narray([2, 1, 0])\n>>> a.ravel(order='K')\narray([2, 1, 0])\n\n>>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a\narray([[[ 0, 2, 4],\n[ 1, 3, 5]],\n[[ 6, 8, 10],\n[ 7, 9, 11]]])\n>>> a.ravel(order='C')\narray([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11])\n>>> a.ravel(order='K')\narray([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])\n" }, { "name": "ravel_multi_index", "content": "ravelmultiindex(multiindex, dims, mode='raise', order='C')\n\nConverts a tuple of index arrays into an array of flat\nindices, applying boundary modes to the multi-index.\n\nParameters\n----------\nmultiindex : tuple of arraylike\nA tuple of integer arrays, one array for each dimension.\ndims : tuple of ints\nThe shape of array into which the indices from ``multiindex`` apply.\nmode : {'raise', 'wrap', 'clip'}, optional\nSpecifies how out-of-bounds indices are handled. Can specify\neither one mode or a tuple of modes, one mode per index.\n\n* 'raise' -- raise an error (default)\n* 'wrap' -- wrap around\n* 'clip' -- clip to the range\n\nIn 'clip' mode, a negative index which would normally\nwrap will clip to 0 instead.\norder : {'C', 'F'}, optional\nDetermines whether the multi-index should be viewed as\nindexing in row-major (C-style) or column-major\n(Fortran-style) order.\n\nReturns\n-------\nraveledindices : ndarray\nAn array of indices into the flattened version of an array\nof dimensions ``dims``.\n\nSee Also\n--------\nunravelindex\n\nNotes\n-----\n.. versionadded:: 1.6.0\n\nExamples\n--------\n>>> arr = np.array([[3,6,6],[4,5,1]])\n>>> np.ravelmultiindex(arr, (7,6))\narray([22, 41, 37])\n>>> np.ravelmultiindex(arr, (7,6), order='F')\narray([31, 41, 13])\n>>> np.ravelmultiindex(arr, (4,6), mode='clip')\narray([22, 23, 19])\n>>> np.ravelmultiindex(arr, (4,4), mode=('clip','wrap'))\narray([12, 13, 13])\n\n>>> np.ravelmultiindex((3,1,4,1), (6,7,8,9))\n1621\n" }, { "name": "real", "content": "Return the real part of the complex argument.\n\nParameters\n----------\nval : arraylike\nInput array.\n\nReturns\n-------\nout : ndarray or scalar\nThe real component of the complex argument. If `val` is real, the type\nof `val` is used for the output. If `val` has complex elements, the\nreturned type is float.\n\nSee Also\n--------\nrealifclose, imag, angle\n\nExamples\n--------\n>>> a = np.array([1+2j, 3+4j, 5+6j])\n>>> a.real\narray([1., 3., 5.])\n>>> a.real = 9\n>>> a\narray([9.+2.j, 9.+4.j, 9.+6.j])\n>>> a.real = np.array([9, 8, 7])\n>>> a\narray([9.+2.j, 8.+4.j, 7.+6.j])\n>>> np.real(1 + 1j)\n1.0\n" }, { "name": "real_if_close", "content": "If input is complex with all imaginary parts close to zero, return\nreal parts.\n\n\"Close to zero\" is defined as `tol` * (machine epsilon of the type for\n`a`).\n\nParameters\n----------\na : arraylike\nInput array.\ntol : float\nTolerance in machine epsilons for the complex part of the elements\nin the array.\n\nReturns\n-------\nout : ndarray\nIf `a` is real, the type of `a` is used for the output. If `a`\nhas complex elements, the returned type is float.\n\nSee Also\n--------\nreal, imag, angle\n\nNotes\n-----\nMachine epsilon varies from machine to machine and between data types\nbut Python floats on most platforms have a machine epsilon equal to\n2.2204460492503131e-16. You can use 'np.finfo(float).eps' to print\nout the machine epsilon for floats.\n\nExamples\n--------\n>>> np.finfo(float).eps\n2.2204460492503131e-16 # may vary\n\n>>> np.realifclose([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)\narray([2.1, 5.2])\n>>> np.realifclose([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)\narray([2.1+4.e-13j, 5.2 + 3e-15j])\n" }, { "name": "recfromcsv", "content": "Load ASCII data stored in a comma-separated file.\n\nThe returned array is a record array (if ``usemask=False``, see\n`recarray`) or a masked record array (if ``usemask=True``,\nsee `ma.mrecords.MaskedRecords`).\n\nParameters\n----------\nfname, kwargs : For a description of input parameters, see `genfromtxt`.\n\nSee Also\n--------\nnumpy.genfromtxt : generic function to load ASCII data.\n\nNotes\n-----\nBy default, `dtype` is None, which means that the data-type of the output\narray will be determined from the data.\n" }, { "name": "recfromtxt", "content": "Load ASCII data from a file and return it in a record array.\n\nIf ``usemask=False`` a standard `recarray` is returned,\nif ``usemask=True`` a MaskedRecords array is returned.\n\nParameters\n----------\nfname, kwargs : For a description of input parameters, see `genfromtxt`.\n\nSee Also\n--------\nnumpy.genfromtxt : generic function\n\nNotes\n-----\nBy default, `dtype` is None, which means that the data-type of the output\narray will be determined from the data.\n" }, { "name": "repeat", "content": "Repeat elements of an array.\n\nParameters\n----------\na : arraylike\nInput array.\nrepeats : int or array of ints\nThe number of repetitions for each element. `repeats` is broadcasted\nto fit the shape of the given axis.\naxis : int, optional\nThe axis along which to repeat values. By default, use the\nflattened input array, and return a flat output array.\n\nReturns\n-------\nrepeatedarray : ndarray\nOutput array which has the same shape as `a`, except along\nthe given axis.\n\nSee Also\n--------\ntile : Tile an array.\nunique : Find the unique elements of an array.\n\nExamples\n--------\n>>> np.repeat(3, 4)\narray([3, 3, 3, 3])\n>>> x = np.array([[1,2],[3,4]])\n>>> np.repeat(x, 2)\narray([1, 1, 2, 2, 3, 3, 4, 4])\n>>> np.repeat(x, 3, axis=1)\narray([[1, 1, 1, 2, 2, 2],\n[3, 3, 3, 4, 4, 4]])\n>>> np.repeat(x, [1, 2], axis=0)\narray([[1, 2],\n[3, 4],\n[3, 4]])\n" }, { "name": "require", "content": "Return an ndarray of the provided type that satisfies requirements.\n\nThis function is useful to be sure that an array with the correct flags\nis returned for passing to compiled code (perhaps through ctypes).\n\nParameters\n----------\na : arraylike\nThe object to be converted to a type-and-requirement-satisfying array.\ndtype : data-type\nThe required data-type. If None preserve the current dtype. If your\napplication requires the data to be in native byteorder, include\na byteorder specification as a part of the dtype specification.\nrequirements : str or list of str\nThe requirements list can be any of the following\n\n* 'FCONTIGUOUS' ('F') - ensure a Fortran-contiguous array\n* 'CCONTIGUOUS' ('C') - ensure a C-contiguous array\n* 'ALIGNED' ('A') - ensure a data-type aligned array\n* 'WRITEABLE' ('W') - ensure a writable array\n* 'OWNDATA' ('O') - ensure an array that owns its own data\n* 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nArray with specified requirements and type if given.\n\nSee Also\n--------\nasarray : Convert input to an ndarray.\nasanyarray : Convert to an ndarray, but pass through ndarray subclasses.\nascontiguousarray : Convert input to a contiguous array.\nasfortranarray : Convert input to an ndarray with column-major\nmemory order.\nndarray.flags : Information about the memory layout of the array.\n\nNotes\n-----\nThe returned array will be guaranteed to have the listed requirements\nby making a copy if needed.\n\nExamples\n--------\n>>> x = np.arange(6).reshape(2,3)\n>>> x.flags\nCCONTIGUOUS : True\nFCONTIGUOUS : False\nOWNDATA : False\nWRITEABLE : True\nALIGNED : True\nWRITEBACKIFCOPY : False\nUPDATEIFCOPY : False\n\n>>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])\n>>> y.flags\nCCONTIGUOUS : False\nFCONTIGUOUS : True\nOWNDATA : True\nWRITEABLE : True\nALIGNED : True\nWRITEBACKIFCOPY : False\nUPDATEIFCOPY : False\n" }, { "name": "reshape", "content": "Gives a new shape to an array without changing its data.\n\nParameters\n----------\na : arraylike\nArray to be reshaped.\nnewshape : int or tuple of ints\nThe new shape should be compatible with the original shape. If\nan integer, then the result will be a 1-D array of that length.\nOne shape dimension can be -1. In this case, the value is\ninferred from the length of the array and remaining dimensions.\norder : {'C', 'F', 'A'}, optional\nRead the elements of `a` using this index order, and place the\nelements into the reshaped array using this index order. 'C'\nmeans to read / write the elements using C-like index order,\nwith the last axis index changing fastest, back to the first\naxis index changing slowest. 'F' means to read / write the\nelements using Fortran-like index order, with the first index\nchanging fastest, and the last index changing slowest. Note that\nthe 'C' and 'F' options take no account of the memory layout of\nthe underlying array, and only refer to the order of indexing.\n'A' means to read / write the elements in Fortran-like index\norder if `a` is Fortran *contiguous* in memory, C-like order\notherwise.\n\nReturns\n-------\nreshapedarray : ndarray\nThis will be a new view object if possible; otherwise, it will\nbe a copy. Note there is no guarantee of the *memory layout* (C- or\nFortran- contiguous) of the returned array.\n\nSee Also\n--------\nndarray.reshape : Equivalent method.\n\nNotes\n-----\nIt is not always possible to change the shape of an array without\ncopying the data. If you want an error to be raised when the data is copied,\nyou should assign the new shape to the shape attribute of the array::\n\n>>> a = np.zeros((10, 2))\n\n# A transpose makes the array non-contiguous\n>>> b = a.T\n\n# Taking a view makes it possible to modify the shape without modifying\n# the initial object.\n>>> c = b.view()\n>>> c.shape = (20)\nTraceback (most recent call last):\n...\nAttributeError: Incompatible shape for in-place modification. Use\n`.reshape()` to make a copy with the desired shape.\n\nThe `order` keyword gives the index ordering both for *fetching* the values\nfrom `a`, and then *placing* the values into the output array.\nFor example, let's say you have an array:\n\n>>> a = np.arange(6).reshape((3, 2))\n>>> a\narray([[0, 1],\n[2, 3],\n[4, 5]])\n\nYou can think of reshaping as first raveling the array (using the given\nindex order), then inserting the elements from the raveled array into the\nnew array using the same kind of index ordering as was used for the\nraveling.\n\n>>> np.reshape(a, (2, 3)) # C-like index ordering\narray([[0, 1, 2],\n[3, 4, 5]])\n>>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape\narray([[0, 1, 2],\n[3, 4, 5]])\n>>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering\narray([[0, 4, 3],\n[2, 1, 5]])\n>>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')\narray([[0, 4, 3],\n[2, 1, 5]])\n\nExamples\n--------\n>>> a = np.array([[1,2,3], [4,5,6]])\n>>> np.reshape(a, 6)\narray([1, 2, 3, 4, 5, 6])\n>>> np.reshape(a, 6, order='F')\narray([1, 4, 2, 5, 3, 6])\n\n>>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2\narray([[1, 2],\n[3, 4],\n[5, 6]])\n" }, { "name": "resize", "content": "Return a new array with the specified shape.\n\nIf the new array is larger than the original array, then the new\narray is filled with repeated copies of `a`. Note that this behavior\nis different from a.resize(newshape) which fills with zeros instead\nof repeated copies of `a`.\n\nParameters\n----------\na : arraylike\nArray to be resized.\n\nnewshape : int or tuple of int\nShape of resized array.\n\nReturns\n-------\nreshapedarray : ndarray\nThe new array is formed from the data in the old array, repeated\nif necessary to fill out the required number of elements. The\ndata are repeated iterating over the array in C-order.\n\nSee Also\n--------\nnp.reshape : Reshape an array without changing the total size.\nnp.pad : Enlarge and pad an array.\nnp.repeat : Repeat elements of an array.\nndarray.resize : resize an array in-place.\n\nNotes\n-----\nWhen the total size of the array does not change `~numpy.reshape` should\nbe used. In most other cases either indexing (to reduce the size)\nor padding (to increase the size) may be a more appropriate solution.\n\nWarning: This functionality does not consider axes separately,\ni.e. it does not apply interpolation/extrapolation.\nIt fills the return array with the required number of elements, iterating\nover `a` in C-order, disregarding axes (and cycling back from the start if\nthe new shape is larger). This functionality is therefore not suitable to\nresize images, or data where each axis represents a separate and distinct\nentity.\n\nExamples\n--------\n>>> a=np.array([[0,1],[2,3]])\n>>> np.resize(a,(2,3))\narray([[0, 1, 2],\n[3, 0, 1]])\n>>> np.resize(a,(1,4))\narray([[0, 1, 2, 3]])\n>>> np.resize(a,(2,4))\narray([[0, 1, 2, 3],\n[0, 1, 2, 3]])\n" }, { "name": "result_type", "content": "resulttype(*arraysanddtypes)\n\nReturns the type that results from applying the NumPy\ntype promotion rules to the arguments.\n\nType promotion in NumPy works similarly to the rules in languages\nlike C++, with some slight differences. When both scalars and\narrays are used, the array's type takes precedence and the actual value\nof the scalar is taken into account.\n\nFor example, calculating 3*a, where a is an array of 32-bit floats,\nintuitively should result in a 32-bit float output. If the 3 is a\n32-bit integer, the NumPy rules indicate it can't convert losslessly\ninto a 32-bit float, so a 64-bit float should be the result type.\nBy examining the value of the constant, '3', we see that it fits in\nan 8-bit integer, which can be cast losslessly into the 32-bit float.\n\nParameters\n----------\narraysanddtypes : list of arrays and dtypes\nThe operands of some operation whose result type is needed.\n\nReturns\n-------\nout : dtype\nThe result type.\n\nSee also\n--------\ndtype, promotetypes, minscalartype, cancast\n\nNotes\n-----\n.. versionadded:: 1.6.0\n\nThe specific algorithm used is as follows.\n\nCategories are determined by first checking which of boolean,\ninteger (int/uint), or floating point (float/complex) the maximum\nkind of all the arrays and the scalars are.\n\nIf there are only scalars or the maximum category of the scalars\nis higher than the maximum category of the arrays,\nthe data types are combined with :func:`promotetypes`\nto produce the return value.\n\nOtherwise, `minscalartype` is called on each array, and\nthe resulting data types are all combined with :func:`promotetypes`\nto produce the return value.\n\nThe set of int values is not a subset of the uint values for types\nwith the same number of bits, something not reflected in\n:func:`minscalartype`, but handled as a special case in `resulttype`.\n\nExamples\n--------\n>>> np.resulttype(3, np.arange(7, dtype='i1'))\ndtype('int8')\n\n>>> np.resulttype('i4', 'c8')\ndtype('complex128')\n\n>>> np.resulttype(3.0, -2)\ndtype('float64')\n" }, { "name": "roll", "content": "Roll array elements along a given axis.\n\nElements that roll beyond the last position are re-introduced at\nthe first.\n\nParameters\n----------\na : arraylike\nInput array.\nshift : int or tuple of ints\nThe number of places by which elements are shifted. If a tuple,\nthen `axis` must be a tuple of the same size, and each of the\ngiven axes is shifted by the corresponding number. If an int\nwhile `axis` is a tuple of ints, then the same value is used for\nall given axes.\naxis : int or tuple of ints, optional\nAxis or axes along which elements are shifted. By default, the\narray is flattened before shifting, after which the original\nshape is restored.\n\nReturns\n-------\nres : ndarray\nOutput array, with the same shape as `a`.\n\nSee Also\n--------\nrollaxis : Roll the specified axis backwards, until it lies in a\ngiven position.\n\nNotes\n-----\n.. versionadded:: 1.12.0\n\nSupports rolling over multiple dimensions simultaneously.\n\nExamples\n--------\n>>> x = np.arange(10)\n>>> np.roll(x, 2)\narray([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])\n>>> np.roll(x, -2)\narray([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])\n\n>>> x2 = np.reshape(x, (2,5))\n>>> x2\narray([[0, 1, 2, 3, 4],\n[5, 6, 7, 8, 9]])\n>>> np.roll(x2, 1)\narray([[9, 0, 1, 2, 3],\n[4, 5, 6, 7, 8]])\n>>> np.roll(x2, -1)\narray([[1, 2, 3, 4, 5],\n[6, 7, 8, 9, 0]])\n>>> np.roll(x2, 1, axis=0)\narray([[5, 6, 7, 8, 9],\n[0, 1, 2, 3, 4]])\n>>> np.roll(x2, -1, axis=0)\narray([[5, 6, 7, 8, 9],\n[0, 1, 2, 3, 4]])\n>>> np.roll(x2, 1, axis=1)\narray([[4, 0, 1, 2, 3],\n[9, 5, 6, 7, 8]])\n>>> np.roll(x2, -1, axis=1)\narray([[1, 2, 3, 4, 0],\n[6, 7, 8, 9, 5]])\n" }, { "name": "rollaxis", "content": "Roll the specified axis backwards, until it lies in a given position.\n\nThis function continues to be supported for backward compatibility, but you\nshould prefer `moveaxis`. The `moveaxis` function was added in NumPy\n1.11.\n\nParameters\n----------\na : ndarray\nInput array.\naxis : int\nThe axis to be rolled. The positions of the other axes do not\nchange relative to one another.\nstart : int, optional\nWhen ``start <= axis``, the axis is rolled back until it lies in\nthis position. When ``start > axis``, the axis is rolled until it\nlies before this position. The default, 0, results in a \"complete\"\nroll. The following table describes how negative values of ``start``\nare interpreted:\n\n.. table::\n:align: left\n\n+-------------------+----------------------+\n| ``start`` | Normalized ``start`` |\n+===================+======================+\n| ``-(arr.ndim+1)`` | raise ``AxisError`` |\n+-------------------+----------------------+\n| ``-arr.ndim`` | 0 |\n+-------------------+----------------------+\n| |vdots| | |vdots| |\n+-------------------+----------------------+\n| ``-1`` | ``arr.ndim-1`` |\n+-------------------+----------------------+\n| ``0`` | ``0`` |\n+-------------------+----------------------+\n| |vdots| | |vdots| |\n+-------------------+----------------------+\n| ``arr.ndim`` | ``arr.ndim`` |\n+-------------------+----------------------+\n| ``arr.ndim + 1`` | raise ``AxisError`` |\n+-------------------+----------------------+\n\n.. |vdots| unicode:: U+22EE .. Vertical Ellipsis\n\nReturns\n-------\nres : ndarray\nFor NumPy >= 1.10.0 a view of `a` is always returned. For earlier\nNumPy versions a view of `a` is returned only if the order of the\naxes is changed, otherwise the input array is returned.\n\nSee Also\n--------\nmoveaxis : Move array axes to new positions.\nroll : Roll the elements of an array by a number of positions along a\ngiven axis.\n\nExamples\n--------\n>>> a = np.ones((3,4,5,6))\n>>> np.rollaxis(a, 3, 1).shape\n(3, 6, 4, 5)\n>>> np.rollaxis(a, 2).shape\n(5, 3, 4, 6)\n>>> np.rollaxis(a, 1, 4).shape\n(3, 5, 6, 4)\n" }, { "name": "roots", "content": "Return the roots of a polynomial with coefficients given in p.\n\n.. note::\nThis forms part of the old polynomial API. Since version 1.4, the\nnew polynomial API defined in `numpy.polynomial` is preferred.\nA summary of the differences can be found in the\n:doc:`transition guide `.\n\nThe values in the rank-1 array `p` are coefficients of a polynomial.\nIf the length of `p` is n+1 then the polynomial is described by::\n\np[0] * xn + p[1] * x(n-1) + ... + p[n-1]*x + p[n]\n\nParameters\n----------\np : arraylike\nRank-1 array of polynomial coefficients.\n\nReturns\n-------\nout : ndarray\nAn array containing the roots of the polynomial.\n\nRaises\n------\nValueError\nWhen `p` cannot be converted to a rank-1 array.\n\nSee also\n--------\npoly : Find the coefficients of a polynomial with a given sequence\nof roots.\npolyval : Compute polynomial values.\npolyfit : Least squares polynomial fit.\npoly1d : A one-dimensional polynomial class.\n\nNotes\n-----\nThe algorithm relies on computing the eigenvalues of the\ncompanion matrix [1].\n\nReferences\n----------\n.. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*. Cambridge, UK:\nCambridge University Press, 1999, pp. 146-7.\n\nExamples\n--------\n>>> coeff = [3.2, 2, 1]\n>>> np.roots(coeff)\narray([-0.3125+0.46351241j, -0.3125-0.46351241j])\n" }, { "name": "rot90", "content": "Rotate an array by 90 degrees in the plane specified by axes.\n\nRotation direction is from the first towards the second axis.\n\nParameters\n----------\nm : arraylike\nArray of two or more dimensions.\nk : integer\nNumber of times the array is rotated by 90 degrees.\naxes: (2,) arraylike\nThe array is rotated in the plane defined by the axes.\nAxes must be different.\n\n.. versionadded:: 1.12.0\n\nReturns\n-------\ny : ndarray\nA rotated view of `m`.\n\nSee Also\n--------\nflip : Reverse the order of elements in an array along the given axis.\nfliplr : Flip an array horizontally.\nflipud : Flip an array vertically.\n\nNotes\n-----\nrot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1))\nrot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))\n\nExamples\n--------\n>>> m = np.array([[1,2],[3,4]], int)\n>>> m\narray([[1, 2],\n[3, 4]])\n>>> np.rot90(m)\narray([[2, 4],\n[1, 3]])\n>>> np.rot90(m, 2)\narray([[4, 3],\n[2, 1]])\n>>> m = np.arange(8).reshape((2,2,2))\n>>> np.rot90(m, 1, (1,2))\narray([[[1, 3],\n[0, 2]],\n[[5, 7],\n[4, 6]]])\n" }, { "name": "round_", "content": "Round an array to the given number of decimals.\n\nSee Also\n--------\naround : equivalent function; see for details.\n\nrowstack = vstack(tup)\nStack arrays in sequence vertically (row wise).\n\nThis is equivalent to concatenation along the first axis after 1-D arrays\nof shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by\n`vsplit`.\n\nThis function makes most sense for arrays with up to 3 dimensions. For\ninstance, for pixel-data with a height (first axis), width (second axis),\nand r/g/b channels (third axis). The functions `concatenate`, `stack` and\n`block` provide more general stacking and concatenation operations.\n\nParameters\n----------\ntup : sequence of ndarrays\nThe arrays must have the same shape along all but the first axis.\n1-D arrays must have the same length.\n\nReturns\n-------\nstacked : ndarray\nThe array formed by stacking the given arrays, will be at least 2-D.\n\nSee Also\n--------\nconcatenate : Join a sequence of arrays along an existing axis.\nstack : Join a sequence of arrays along a new axis.\nblock : Assemble an nd-array from nested lists of blocks.\nhstack : Stack arrays in sequence horizontally (column wise).\ndstack : Stack arrays in sequence depth wise (along third axis).\ncolumnstack : Stack 1-D arrays as columns into a 2-D array.\nvsplit : Split an array into multiple sub-arrays vertically (row-wise).\n\nExamples\n--------\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.vstack((a,b))\narray([[1, 2, 3],\n[4, 5, 6]])\n\n>>> a = np.array([[1], [2], [3]])\n>>> b = np.array([[4], [5], [6]])\n>>> np.vstack((a,b))\narray([[1],\n[2],\n[3],\n[4],\n[5],\n[6]])\n" }, { "name": "safe_eval", "content": "Protected string evaluation.\n\nEvaluate a string containing a Python literal expression without\nallowing the execution of arbitrary non-literal code.\n\nParameters\n----------\nsource : str\nThe string to evaluate.\n\nReturns\n-------\nobj : object\nThe result of evaluating `source`.\n\nRaises\n------\nSyntaxError\nIf the code has invalid Python syntax, or if it contains\nnon-literal code.\n\nExamples\n--------\n>>> np.safeeval('1')\n1\n>>> np.safeeval('[1, 2, 3]')\n[1, 2, 3]\n>>> np.safeeval('{\"foo\": (\"bar\", 10.0)}')\n{'foo': ('bar', 10.0)}\n\n>>> np.safeeval('import os')\nTraceback (most recent call last):\n...\nSyntaxError: invalid syntax\n\n>>> np.safeeval('open(\"/home/user/.ssh/iddsa\").read()')\nTraceback (most recent call last):\n...\nValueError: malformed node or string: \n" }, { "name": "save", "content": "Save an array to a binary file in NumPy ``.npy`` format.\n\nParameters\n----------\nfile : file, str, or pathlib.Path\nFile or filename to which the data is saved. If file is a file-object,\nthen the filename is unchanged. If file is a string or Path, a ``.npy``\nextension will be appended to the filename if it does not already\nhave one.\narr : arraylike\nArray data to be saved.\nallowpickle : bool, optional\nAllow saving object arrays using Python pickles. Reasons for disallowing\npickles include security (loading pickled data can execute arbitrary\ncode) and portability (pickled objects may not be loadable on different\nPython installations, for example if the stored objects require libraries\nthat are not available, and not all pickled data is compatible between\nPython 2 and Python 3).\nDefault: True\nfiximports : bool, optional\nOnly useful in forcing objects in object arrays on Python 3 to be\npickled in a Python 2 compatible way. If `fiximports` is True, pickle\nwill try to map the new Python 3 names to the old module names used in\nPython 2, so that the pickle data stream is readable with Python 2.\n\nSee Also\n--------\nsavez : Save several arrays into a ``.npz`` archive\nsavetxt, load\n\nNotes\n-----\nFor a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.\n\nAny data saved to the file is appended to the end of the file.\n\nExamples\n--------\n>>> from tempfile import TemporaryFile\n>>> outfile = TemporaryFile()\n\n>>> x = np.arange(10)\n>>> np.save(outfile, x)\n\n>>> = outfile.seek(0) # Only needed here to simulate closing & reopening file\n>>> np.load(outfile)\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n\n>>> with open('test.npy', 'wb') as f:\n... np.save(f, np.array([1, 2]))\n... np.save(f, np.array([1, 3]))\n>>> with open('test.npy', 'rb') as f:\n... a = np.load(f)\n... b = np.load(f)\n>>> print(a, b)\n# [1 2] [1 3]\n" }, { "name": "savetxt", "content": "Save an array to a text file.\n\nParameters\n----------\nfname : filename or file handle\nIf the filename ends in ``.gz``, the file is automatically saved in\ncompressed gzip format. `loadtxt` understands gzipped files\ntransparently.\nX : 1D or 2D arraylike\nData to be saved to a text file.\nfmt : str or sequence of strs, optional\nA single format (%10.5f), a sequence of formats, or a\nmulti-format string, e.g. 'Iteration %d -- %10.5f', in which\ncase `delimiter` is ignored. For complex `X`, the legal options\nfor `fmt` are:\n\n* a single specifier, `fmt='%.4e'`, resulting in numbers formatted\nlike `' (%s+%sj)' % (fmt, fmt)`\n* a full string specifying every real and imaginary part, e.g.\n`' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns\n* a list of specifiers, one per column - in this case, the real\nand imaginary part must have separate specifiers,\ne.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns\ndelimiter : str, optional\nString or character separating columns.\nnewline : str, optional\nString or character separating lines.\n\n.. versionadded:: 1.5.0\nheader : str, optional\nString that will be written at the beginning of the file.\n\n.. versionadded:: 1.7.0\nfooter : str, optional\nString that will be written at the end of the file.\n\n.. versionadded:: 1.7.0\ncomments : str, optional\nString that will be prepended to the ``header`` and ``footer`` strings,\nto mark them as comments. Default: '# ', as expected by e.g.\n``numpy.loadtxt``.\n\n.. versionadded:: 1.7.0\nencoding : {None, str}, optional\nEncoding used to encode the outputfile. Does not apply to output\nstreams. If the encoding is something other than 'bytes' or 'latin1'\nyou will not be able to load the file in NumPy versions < 1.14. Default\nis 'latin1'.\n\n.. versionadded:: 1.14.0\n\n\nSee Also\n--------\nsave : Save an array to a binary file in NumPy ``.npy`` format\nsavez : Save several arrays into an uncompressed ``.npz`` archive\nsavezcompressed : Save several arrays into a compressed ``.npz`` archive\n\nNotes\n-----\nFurther explanation of the `fmt` parameter\n(``%[flag]width[.precision]specifier``):\n\nflags:\n``-`` : left justify\n\n``+`` : Forces to precede result with + or -.\n\n``0`` : Left pad the number with zeros instead of space (see width).\n\nwidth:\nMinimum number of characters to be printed. The value is not truncated\nif it has more characters.\n\nprecision:\n- For integer specifiers (eg. ``d,i,o,x``), the minimum number of\ndigits.\n- For ``e, E`` and ``f`` specifiers, the number of digits to print\nafter the decimal point.\n- For ``g`` and ``G``, the maximum number of significant digits.\n- For ``s``, the maximum number of characters.\n\nspecifiers:\n``c`` : character\n\n``d`` or ``i`` : signed decimal integer\n\n``e`` or ``E`` : scientific notation with ``e`` or ``E``.\n\n``f`` : decimal floating point\n\n``g,G`` : use the shorter of ``e,E`` or ``f``\n\n``o`` : signed octal\n\n``s`` : string of characters\n\n``u`` : unsigned decimal integer\n\n``x,X`` : unsigned hexadecimal integer\n\nThis explanation of ``fmt`` is not complete, for an exhaustive\nspecification see [1].\n\nReferences\n----------\n.. [1] `Format Specification Mini-Language\n`,\nPython Documentation.\n\nExamples\n--------\n>>> x = y = z = np.arange(0.0,5.0,1.0)\n>>> np.savetxt('test.out', x, delimiter=',') # X is an array\n>>> np.savetxt('test.out', (x,y,z)) # x,y,z equal sized 1D arrays\n>>> np.savetxt('test.out', x, fmt='%1.4e') # use exponential notation\n" }, { "name": "savez", "content": "Save several arrays into a single file in uncompressed ``.npz`` format.\n\nProvide arrays as keyword arguments to store them under the\ncorresponding name in the output file: ``savez(fn, x=x, y=y)``.\n\nIf arrays are specified as positional arguments, i.e., ``savez(fn,\nx, y)``, their names will be `arr0`, `arr1`, etc.\n\nParameters\n----------\nfile : str or file\nEither the filename (string) or an open file (file-like object)\nwhere the data will be saved. If file is a string or a Path, the\n``.npz`` extension will be appended to the filename if it is not\nalready there.\nargs : Arguments, optional\nArrays to save to the file. Please use keyword arguments (see\n`kwds` below) to assign names to arrays. Arrays specified as\nargs will be named \"arr0\", \"arr1\", and so on.\nkwds : Keyword arguments, optional\nArrays to save to the file. Each array will be saved to the\noutput file with its corresponding keyword name.\n\nReturns\n-------\nNone\n\nSee Also\n--------\nsave : Save a single array to a binary file in NumPy format.\nsavetxt : Save an array to a file as plain text.\nsavezcompressed : Save several arrays into a compressed ``.npz`` archive\n\nNotes\n-----\nThe ``.npz`` file format is a zipped archive of files named after the\nvariables they contain. The archive is not compressed and each file\nin the archive contains one variable in ``.npy`` format. For a\ndescription of the ``.npy`` format, see :py:mod:`numpy.lib.format`.\n\nWhen opening the saved ``.npz`` file with `load` a `NpzFile` object is\nreturned. This is a dictionary-like object which can be queried for\nits list of arrays (with the ``.files`` attribute), and for the arrays\nthemselves.\n\nWhen saving dictionaries, the dictionary keys become filenames\ninside the ZIP archive. Therefore, keys should be valid filenames.\nE.g., avoid keys that begin with ``/`` or contain ``.``.\n\nExamples\n--------\n>>> from tempfile import TemporaryFile\n>>> outfile = TemporaryFile()\n>>> x = np.arange(10)\n>>> y = np.sin(x)\n\nUsing `savez` with \\*args, the arrays are saved with default names.\n\n>>> np.savez(outfile, x, y)\n>>> = outfile.seek(0) # Only needed here to simulate closing & reopening file\n>>> npzfile = np.load(outfile)\n>>> npzfile.files\n['arr0', 'arr1']\n>>> npzfile['arr0']\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\nUsing `savez` with \\kwds, the arrays are saved with the keyword names.\n\n>>> outfile = TemporaryFile()\n>>> np.savez(outfile, x=x, y=y)\n>>> = outfile.seek(0)\n>>> npzfile = np.load(outfile)\n>>> sorted(npzfile.files)\n['x', 'y']\n>>> npzfile['x']\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n" }, { "name": "savez_compressed", "content": "Save several arrays into a single file in compressed ``.npz`` format.\n\nProvide arrays as keyword arguments to store them under the\ncorresponding name in the output file: ``savez(fn, x=x, y=y)``.\n\nIf arrays are specified as positional arguments, i.e., ``savez(fn,\nx, y)``, their names will be `arr0`, `arr1`, etc.\n\nParameters\n----------\nfile : str or file\nEither the filename (string) or an open file (file-like object)\nwhere the data will be saved. If file is a string or a Path, the\n``.npz`` extension will be appended to the filename if it is not\nalready there.\nargs : Arguments, optional\nArrays to save to the file. Please use keyword arguments (see\n`kwds` below) to assign names to arrays. Arrays specified as\nargs will be named \"arr0\", \"arr1\", and so on.\nkwds : Keyword arguments, optional\nArrays to save to the file. Each array will be saved to the\noutput file with its corresponding keyword name.\n\nReturns\n-------\nNone\n\nSee Also\n--------\nnumpy.save : Save a single array to a binary file in NumPy format.\nnumpy.savetxt : Save an array to a file as plain text.\nnumpy.savez : Save several arrays into an uncompressed ``.npz`` file format\nnumpy.load : Load the files created by savezcompressed.\n\nNotes\n-----\nThe ``.npz`` file format is a zipped archive of files named after the\nvariables they contain. The archive is compressed with\n``zipfile.ZIPDEFLATED`` and each file in the archive contains one variable\nin ``.npy`` format. For a description of the ``.npy`` format, see\n:py:mod:`numpy.lib.format`.\n\n\nWhen opening the saved ``.npz`` file with `load` a `NpzFile` object is\nreturned. This is a dictionary-like object which can be queried for\nits list of arrays (with the ``.files`` attribute), and for the arrays\nthemselves.\n\nExamples\n--------\n>>> testarray = np.random.rand(3, 2)\n>>> testvector = np.random.rand(4)\n>>> np.savezcompressed('/tmp/123', a=testarray, b=testvector)\n>>> loaded = np.load('/tmp/123.npz')\n>>> print(np.arrayequal(testarray, loaded['a']))\nTrue\n>>> print(np.arrayequal(testvector, loaded['b']))\nTrue\n" }, { "name": "sctype2char", "content": "Return the string representation of a scalar dtype.\n\nParameters\n----------\nsctype : scalar dtype or object\nIf a scalar dtype, the corresponding string character is\nreturned. If an object, `sctype2char` tries to infer its scalar type\nand then return the corresponding string character.\n\nReturns\n-------\ntypechar : str\nThe string character corresponding to the scalar type.\n\nRaises\n------\nValueError\nIf `sctype` is an object for which the type can not be inferred.\n\nSee Also\n--------\nobj2sctype, issctype, issubsctype, mintypecode\n\nExamples\n--------\n>>> for sctype in [np.int32, np.double, np.complex, np.string, np.ndarray]:\n... print(np.sctype2char(sctype))\nl # may vary\nd\nD\nS\nO\n\n>>> x = np.array([1., 2-1.j])\n>>> np.sctype2char(x)\n'D'\n>>> np.sctype2char(list)\n'O'\n" }, { "name": "searchsorted", "content": "Find indices where elements should be inserted to maintain order.\n\nFind the indices into a sorted array `a` such that, if the\ncorresponding elements in `v` were inserted before the indices, the\norder of `a` would be preserved.\n\nAssuming that `a` is sorted:\n\n====== ============================\n`side` returned index `i` satisfies\n====== ============================\nleft ``a[i-1] < v <= a[i]``\nright ``a[i-1] <= v < a[i]``\n====== ============================\n\nParameters\n----------\na : 1-D arraylike\nInput array. If `sorter` is None, then it must be sorted in\nascending order, otherwise `sorter` must be an array of indices\nthat sort it.\nv : arraylike\nValues to insert into `a`.\nside : {'left', 'right'}, optional\nIf 'left', the index of the first suitable location found is given.\nIf 'right', return the last such index. If there is no suitable\nindex, return either 0 or N (where N is the length of `a`).\nsorter : 1-D arraylike, optional\nOptional array of integer indices that sort array a into ascending\norder. They are typically the result of argsort.\n\n.. versionadded:: 1.7.0\n\nReturns\n-------\nindices : array of ints\nArray of insertion points with the same shape as `v`.\n\nSee Also\n--------\nsort : Return a sorted copy of an array.\nhistogram : Produce histogram from 1-D data.\n\nNotes\n-----\nBinary search is used to find the required insertion points.\n\nAs of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing\n`nan` values. The enhanced sort order is documented in `sort`.\n\nThis function uses the same algorithm as the builtin python `bisect.bisectleft`\n(``side='left'``) and `bisect.bisectright` (``side='right'``) functions,\nwhich is also vectorized in the `v` argument.\n\nExamples\n--------\n>>> np.searchsorted([1,2,3,4,5], 3)\n2\n>>> np.searchsorted([1,2,3,4,5], 3, side='right')\n3\n>>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])\narray([0, 5, 1, 2])\n" }, { "name": "select", "content": "Return an array drawn from elements in choicelist, depending on conditions.\n\nParameters\n----------\ncondlist : list of bool ndarrays\nThe list of conditions which determine from which array in `choicelist`\nthe output elements are taken. When multiple conditions are satisfied,\nthe first one encountered in `condlist` is used.\nchoicelist : list of ndarrays\nThe list of arrays from which the output elements are taken. It has\nto be of the same length as `condlist`.\ndefault : scalar, optional\nThe element inserted in `output` when all conditions evaluate to False.\n\nReturns\n-------\noutput : ndarray\nThe output at position m is the m-th element of the array in\n`choicelist` where the m-th element of the corresponding array in\n`condlist` is True.\n\nSee Also\n--------\nwhere : Return elements from one of two arrays depending on condition.\ntake, choose, compress, diag, diagonal\n\nExamples\n--------\n>>> x = np.arange(10)\n>>> condlist = [x<3, x>5]\n>>> choicelist = [x, x2]\n>>> np.select(condlist, choicelist)\narray([ 0, 1, 2, ..., 49, 64, 81])\n" }, { "name": "set_numeric_ops", "content": "setnumericops(op1=func1, op2=func2, ...)\n\nSet numerical operators for array objects.\n\n.. deprecated:: 1.16\n\nFor the general case, use :c:func:`PyUFuncReplaceLoopBySignature`.\nFor ndarray subclasses, define the ``arrayufunc`` method and\noverride the relevant ufunc.\n\nParameters\n----------\nop1, op2, ... : callable\nEach ``op = func`` pair describes an operator to be replaced.\nFor example, ``add = lambda x, y: np.add(x, y) % 5`` would replace\naddition by modulus 5 addition.\n\nReturns\n-------\nsavedops : list of callables\nA list of all operators, stored before making replacements.\n\nNotes\n-----\n.. WARNING::\nUse with care! Incorrect usage may lead to memory errors.\n\nA function replacing an operator cannot make use of that operator.\nFor example, when replacing add, you may not use ``+``. Instead,\ndirectly call ufuncs.\n\nExamples\n--------\n>>> def addmod5(x, y):\n... return np.add(x, y) % 5\n...\n>>> oldfuncs = np.setnumericops(add=addmod5)\n\n>>> x = np.arange(12).reshape((3, 4))\n>>> x + x\narray([[0, 2, 4, 1],\n[3, 0, 2, 4],\n[1, 3, 0, 2]])\n\n>>> ignore = np.setnumericops(oldfuncs) # restore operators\n" }, { "name": "set_printoptions", "content": "Set printing options.\n\nThese options determine the way floating point numbers, arrays and\nother NumPy objects are displayed.\n\nParameters\n----------\nprecision : int or None, optional\nNumber of digits of precision for floating point output (default 8).\nMay be None if `floatmode` is not `fixed`, to print as many digits as\nnecessary to uniquely specify the value.\nthreshold : int, optional\nTotal number of array elements which trigger summarization\nrather than full repr (default 1000).\nTo always use the full repr without summarization, pass `sys.maxsize`.\nedgeitems : int, optional\nNumber of array items in summary at beginning and end of\neach dimension (default 3).\nlinewidth : int, optional\nThe number of characters per line for the purpose of inserting\nline breaks (default 75).\nsuppress : bool, optional\nIf True, always print floating point numbers using fixed point\nnotation, in which case numbers equal to zero in the current precision\nwill print as zero. If False, then scientific notation is used when\nabsolute value of the smallest number is < 1e-4 or the ratio of the\nmaximum absolute value to the minimum is > 1e3. The default is False.\nnanstr : str, optional\nString representation of floating point not-a-number (default nan).\ninfstr : str, optional\nString representation of floating point infinity (default inf).\nsign : string, either '-', '+', or ' ', optional\nControls printing of the sign of floating-point types. If '+', always\nprint the sign of positive values. If ' ', always prints a space\n(whitespace character) in the sign position of positive values. If\n'-', omit the sign character of positive values. (default '-')\nformatter : dict of callables, optional\nIf not None, the keys should indicate the type(s) that the respective\nformatting function applies to. Callables should return a string.\nTypes that are not specified (by their corresponding keys) are handled\nby the default formatters. Individual types for which a formatter\ncan be set are:\n\n- 'bool'\n- 'int'\n- 'timedelta' : a `numpy.timedelta64`\n- 'datetime' : a `numpy.datetime64`\n- 'float'\n- 'longfloat' : 128-bit floats\n- 'complexfloat'\n- 'longcomplexfloat' : composed of two 128-bit floats\n- 'numpystr' : types `numpy.string` and `numpy.unicode`\n- 'object' : `np.object` arrays\n\nOther keys that can be used to set a group of types at once are:\n\n- 'all' : sets all types\n- 'intkind' : sets 'int'\n- 'floatkind' : sets 'float' and 'longfloat'\n- 'complexkind' : sets 'complexfloat' and 'longcomplexfloat'\n- 'strkind' : sets 'numpystr'\nfloatmode : str, optional\nControls the interpretation of the `precision` option for\nfloating-point types. Can take the following values\n(default maxprecequal):\n\n* 'fixed': Always print exactly `precision` fractional digits,\neven if this would print more or fewer digits than\nnecessary to specify the value uniquely.\n* 'unique': Print the minimum number of fractional digits necessary\nto represent each value uniquely. Different elements may\nhave a different number of digits. The value of the\n`precision` option is ignored.\n* 'maxprec': Print at most `precision` fractional digits, but if\nan element can be uniquely represented with fewer digits\nonly print it with that many.\n* 'maxprecequal': Print at most `precision` fractional digits,\nbut if every element in the array can be uniquely\nrepresented with an equal number of fewer digits, use that\nmany digits for all elements.\nlegacy : string or `False`, optional\nIf set to the string `'1.13'` enables 1.13 legacy printing mode. This\napproximates numpy 1.13 print output by including a space in the sign\nposition of floats and different behavior for 0d arrays. If set to\n`False`, disables legacy mode. Unrecognized strings will be ignored\nwith a warning for forward compatibility.\n\n.. versionadded:: 1.14.0\n\nSee Also\n--------\ngetprintoptions, printoptions, setstringfunction, array2string\n\nNotes\n-----\n`formatter` is always reset with a call to `setprintoptions`.\n\nUse `printoptions` as a context manager to set the values temporarily.\n\nExamples\n--------\nFloating point precision can be set:\n\n>>> np.setprintoptions(precision=4)\n>>> np.array([1.123456789])\n[1.1235]\n\nLong arrays can be summarised:\n\n>>> np.setprintoptions(threshold=5)\n>>> np.arange(10)\narray([0, 1, 2, ..., 7, 8, 9])\n\nSmall results can be suppressed:\n\n>>> eps = np.finfo(float).eps\n>>> x = np.arange(4.)\n>>> x2 - (x + eps)2\narray([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00])\n>>> np.setprintoptions(suppress=True)\n>>> x2 - (x + eps)2\narray([-0., -0., 0., 0.])\n\nA custom formatter can be used to display array elements as desired:\n\n>>> np.setprintoptions(formatter={'all':lambda x: 'int: '+str(-x)})\n>>> x = np.arange(3)\n>>> x\narray([int: 0, int: -1, int: -2])\n>>> np.setprintoptions() # formatter gets reset\n>>> x\narray([0, 1, 2])\n\nTo put back the default options, you can use:\n\n>>> np.setprintoptions(edgeitems=3, infstr='inf',\n... linewidth=75, nanstr='nan', precision=8,\n... suppress=False, threshold=1000, formatter=None)\n\nAlso to temporarily override options, use `printoptions` as a context manager:\n\n>>> with np.printoptions(precision=2, suppress=True, threshold=5):\n... np.linspace(0, 10, 10)\narray([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ])\n" }, { "name": "set_string_function", "content": "Set a Python function to be used when pretty printing arrays.\n\nParameters\n----------\nf : function or None\nFunction to be used to pretty print arrays. The function should expect\na single array argument and return a string of the representation of\nthe array. If None, the function is reset to the default NumPy function\nto print arrays.\nrepr : bool, optional\nIf True (default), the function for pretty printing (``repr``)\nis set, if False the function that returns the default string\nrepresentation (``str``) is set.\n\nSee Also\n--------\nsetprintoptions, getprintoptions\n\nExamples\n--------\n>>> def pprint(arr):\n... return 'HA! - What are you going to do now?'\n...\n>>> np.setstringfunction(pprint)\n>>> a = np.arange(10)\n>>> a\nHA! - What are you going to do now?\n>>> = a\n>>> # [0 1 2 3 4 5 6 7 8 9]\n\nWe can reset the function to the default:\n\n>>> np.setstringfunction(None)\n>>> a\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n`repr` affects either pretty printing or normal string representation.\nNote that ``repr`` is still affected by setting ``str``\nbecause the width of each array element in the returned string becomes\nequal to the length of the result of ``str()``.\n\n>>> x = np.arange(4)\n>>> np.setstringfunction(lambda x:'random', repr=False)\n>>> x.str()\n'random'\n>>> x.repr()\n'array([0, 1, 2, 3])'\n" }, { "name": "setbufsize", "content": "Set the size of the buffer used in ufuncs.\n\nParameters\n----------\nsize : int\nSize of buffer.\n" }, { "name": "setdiff1d", "content": "Find the set difference of two arrays.\n\nReturn the unique values in `ar1` that are not in `ar2`.\n\nParameters\n----------\nar1 : arraylike\nInput array.\nar2 : arraylike\nInput comparison array.\nassumeunique : bool\nIf True, the input arrays are both assumed to be unique, which\ncan speed up the calculation. Default is False.\n\nReturns\n-------\nsetdiff1d : ndarray\n1D array of values in `ar1` that are not in `ar2`. The result\nis sorted when `assumeunique=False`, but otherwise only sorted\nif the input is sorted.\n\nSee Also\n--------\nnumpy.lib.arraysetops : Module with a number of other functions for\nperforming set operations on arrays.\n\nExamples\n--------\n>>> a = np.array([1, 2, 3, 2, 4, 1])\n>>> b = np.array([3, 4, 5, 6])\n>>> np.setdiff1d(a, b)\narray([1, 2])\n" }, { "name": "seterr", "content": "Set how floating-point errors are handled.\n\nNote that operations on integer scalar types (such as `int16`) are\nhandled like floating point, and are affected by these settings.\n\nParameters\n----------\nall : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional\nSet treatment for all types of floating-point errors at once:\n\n- ignore: Take no action when the exception occurs.\n- warn: Print a `RuntimeWarning` (via the Python `warnings` module).\n- raise: Raise a `FloatingPointError`.\n- call: Call a function specified using the `seterrcall` function.\n- print: Print a warning directly to ``stdout``.\n- log: Record error in a Log object specified by `seterrcall`.\n\nThe default is not to change the current behavior.\ndivide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional\nTreatment for division by zero.\nover : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional\nTreatment for floating-point overflow.\nunder : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional\nTreatment for floating-point underflow.\ninvalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional\nTreatment for invalid floating-point operation.\n\nReturns\n-------\noldsettings : dict\nDictionary containing the old settings.\n\nSee also\n--------\nseterrcall : Set a callback function for the 'call' mode.\ngeterr, geterrcall, errstate\n\nNotes\n-----\nThe floating-point exceptions are defined in the IEEE 754 standard [1]:\n\n- Division by zero: infinite result obtained from finite numbers.\n- Overflow: result too large to be expressed.\n- Underflow: result so close to zero that some precision\nwas lost.\n- Invalid operation: result is not an expressible number, typically\nindicates that a NaN was produced.\n\n.. [1] https://en.wikipedia.org/wiki/IEEE754\n\nExamples\n--------\n>>> oldsettings = np.seterr(all='ignore') #seterr to known value\n>>> np.seterr(over='raise')\n{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}\n>>> np.seterr(oldsettings) # reset to default\n{'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}\n\n>>> np.int16(32000) * np.int16(3)\n30464\n>>> oldsettings = np.seterr(all='warn', over='raise')\n>>> np.int16(32000) * np.int16(3)\nTraceback (most recent call last):\nFile \"\", line 1, in \nFloatingPointError: overflow encountered in shortscalars\n\n>>> oldsettings = np.seterr(all='print')\n>>> np.geterr()\n{'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}\n>>> np.int16(32000) * np.int16(3)\n30464\n" }, { "name": "seterrcall", "content": "Set the floating-point error callback function or log object.\n\nThere are two ways to capture floating-point error messages. The first\nis to set the error-handler to 'call', using `seterr`. Then, set\nthe function to call using this function.\n\nThe second is to set the error-handler to 'log', using `seterr`.\nFloating-point errors then trigger a call to the 'write' method of\nthe provided object.\n\nParameters\n----------\nfunc : callable f(err, flag) or object with write method\nFunction to call upon floating-point errors ('call'-mode) or\nobject whose 'write' method is used to log such message ('log'-mode).\n\nThe call function takes two arguments. The first is a string describing\nthe type of error (such as \"divide by zero\", \"overflow\", \"underflow\",\nor \"invalid value\"), and the second is the status flag. The flag is a\nbyte, whose four least-significant bits indicate the type of error, one\nof \"divide\", \"over\", \"under\", \"invalid\"::\n\n[0 0 0 0 divide over under invalid]\n\nIn other words, ``flags = divide + 2*over + 4*under + 8*invalid``.\n\nIf an object is provided, its write method should take one argument,\na string.\n\nReturns\n-------\nh : callable, log instance or None\nThe old error handler.\n\nSee Also\n--------\nseterr, geterr, geterrcall\n\nExamples\n--------\nCallback upon error:\n\n>>> def errhandler(type, flag):\n... print(\"Floating point error (%s), with flag %s\" % (type, flag))\n...\n\n>>> savedhandler = np.seterrcall(errhandler)\n>>> saveerr = np.seterr(all='call')\n\n>>> np.array([1, 2, 3]) / 0.0\nFloating point error (divide by zero), with flag 1\narray([inf, inf, inf])\n\n>>> np.seterrcall(savedhandler)\n\n>>> np.seterr(saveerr)\n{'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'}\n\nLog error message:\n\n>>> class Log:\n... def write(self, msg):\n... print(\"LOG: %s\" % msg)\n...\n\n>>> log = Log()\n>>> savedhandler = np.seterrcall(log)\n>>> saveerr = np.seterr(all='log')\n\n>>> np.array([1, 2, 3]) / 0.0\nLOG: Warning: divide by zero encountered in truedivide\narray([inf, inf, inf])\n\n>>> np.seterrcall(savedhandler)\n\n>>> np.seterr(saveerr)\n{'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'}\n" }, { "name": "seterrobj", "content": "seterrobj(errobj)\n\nSet the object that defines floating-point error handling.\n\nThe error object contains all information that defines the error handling\nbehavior in NumPy. `seterrobj` is used internally by the other\nfunctions that set error handling behavior (`seterr`, `seterrcall`).\n\nParameters\n----------\nerrobj : list\nThe error object, a list containing three elements:\n[internal numpy buffer size, error mask, error callback function].\n\nThe error mask is a single integer that holds the treatment information\non all four floating point errors. The information for each error type\nis contained in three bits of the integer. If we print it in base 8, we\ncan see what treatment is set for \"invalid\", \"under\", \"over\", and\n\"divide\" (in that order). The printed string can be interpreted with\n\n* 0 : 'ignore'\n* 1 : 'warn'\n* 2 : 'raise'\n* 3 : 'call'\n* 4 : 'print'\n* 5 : 'log'\n\nSee Also\n--------\ngeterrobj, seterr, geterr, seterrcall, geterrcall\ngetbufsize, setbufsize\n\nNotes\n-----\nFor complete documentation of the types of floating-point exceptions and\ntreatment options, see `seterr`.\n\nExamples\n--------\n>>> olderrobj = np.geterrobj() # first get the defaults\n>>> olderrobj\n[8192, 521, None]\n\n>>> def errhandler(type, flag):\n... print(\"Floating point error (%s), with flag %s\" % (type, flag))\n...\n>>> newerrobj = [20000, 12, errhandler]\n>>> np.seterrobj(newerrobj)\n>>> np.baserepr(12, 8) # int for divide=4 ('print') and over=1 ('warn')\n'14'\n>>> np.geterr()\n{'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'}\n>>> np.geterrcall() is errhandler\nTrue\n" }, { "name": "setxor1d", "content": "Find the set exclusive-or of two arrays.\n\nReturn the sorted, unique values that are in only one (not both) of the\ninput arrays.\n\nParameters\n----------\nar1, ar2 : arraylike\nInput arrays.\nassumeunique : bool\nIf True, the input arrays are both assumed to be unique, which\ncan speed up the calculation. Default is False.\n\nReturns\n-------\nsetxor1d : ndarray\nSorted 1D array of unique values that are in only one of the input\narrays.\n\nExamples\n--------\n>>> a = np.array([1, 2, 3, 2, 4])\n>>> b = np.array([2, 3, 5, 7, 5])\n>>> np.setxor1d(a,b)\narray([1, 4, 5, 7])\n" }, { "name": "shape", "content": "Return the shape of an array.\n\nParameters\n----------\na : arraylike\nInput array.\n\nReturns\n-------\nshape : tuple of ints\nThe elements of the shape tuple give the lengths of the\ncorresponding array dimensions.\n\nSee Also\n--------\nlen\nndarray.shape : Equivalent array method.\n\nExamples\n--------\n>>> np.shape(np.eye(3))\n(3, 3)\n>>> np.shape([[1, 2]])\n(1, 2)\n>>> np.shape([0])\n(1,)\n>>> np.shape(0)\n()\n\n>>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])\n>>> np.shape(a)\n(2,)\n>>> a.shape\n(2,)\n" }, { "name": "shares_memory", "content": "sharesmemory(a, b, maxwork=None)\n\nDetermine if two arrays share memory.\n\n.. warning::\n\nThis function can be exponentially slow for some inputs, unless\n`maxwork` is set to a finite number or ``MAYSHAREBOUNDS``.\nIf in doubt, use `numpy.maysharememory` instead.\n\nParameters\n----------\na, b : ndarray\nInput arrays\nmaxwork : int, optional\nEffort to spend on solving the overlap problem (maximum number\nof candidate solutions to consider). The following special\nvalues are recognized:\n\nmaxwork=MAYSHAREEXACT (default)\nThe problem is solved exactly. In this case, the function returns\nTrue only if there is an element shared between the arrays. Finding\nthe exact solution may take extremely long in some cases.\nmaxwork=MAYSHAREBOUNDS\nOnly the memory bounds of a and b are checked.\n\nRaises\n------\nnumpy.TooHardError\nExceeded maxwork.\n\nReturns\n-------\nout : bool\n\nSee Also\n--------\nmaysharememory\n\nExamples\n--------\n>>> x = np.array([1, 2, 3, 4])\n>>> np.sharesmemory(x, np.array([5, 6, 7]))\nFalse\n>>> np.sharesmemory(x[::2], x)\nTrue\n>>> np.sharesmemory(x[::2], x[1::2])\nFalse\n\nChecking whether two arrays share memory is NP-complete, and\nruntime may increase exponentially in the number of\ndimensions. Hence, `maxwork` should generally be set to a finite\nnumber, as it is possible to construct examples that take\nextremely long to run:\n\n>>> from numpy.lib.stridetricks import asstrided\n>>> x = np.zeros([192163377], dtype=np.int8)\n>>> x1 = asstrided(x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049))\n>>> x2 = asstrided(x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1))\n>>> np.sharesmemory(x1, x2, maxwork=1000)\nTraceback (most recent call last):\n...\nnumpy.TooHardError: Exceeded maxwork\n\nRunning ``np.sharesmemory(x1, x2)`` without `maxwork` set takes\naround 1 minute for this case. It is possible to find problems\nthat take still significantly longer.\n\nshowconfig = show()\nShow libraries in the system on which NumPy was built.\n\nPrint information about various resources (libraries, library\ndirectories, include directories, etc.) in the system on which\nNumPy was built.\n\nSee Also\n--------\ngetinclude : Returns the directory containing NumPy C\nheader files.\n\nNotes\n-----\nClasses specifying the information to be printed are defined\nin the `numpy.distutils.systeminfo` module.\n\nInformation may include:\n\n* ``language``: language used to write the libraries (mostly\nC or f77)\n* ``libraries``: names of libraries found in the system\n* ``librarydirs``: directories containing the libraries\n* ``includedirs``: directories containing library header files\n* ``srcdirs``: directories containing library source files\n* ``definemacros``: preprocessor macros used by\n``distutils.setup``\n* ``baseline``: minimum CPU features required\n* ``found``: dispatched features supported in the system\n* ``not found``: dispatched features that are not supported\nin the system\n\nExamples\n--------\n>>> import numpy as np\n>>> np.showconfig()\nblasoptinfo:\nlanguage = c\ndefinemacros = [('HAVECBLAS', None)]\nlibraries = ['openblas', 'openblas']\nlibrarydirs = ['/usr/local/lib']\n" }, { "name": "sinc", "content": "Return the normalized sinc function.\n\nThe sinc function is :math:`\\sin(\\pi x)/(\\pi x)`.\n\n.. note::\n\nNote the normalization factor of ``pi`` used in the definition.\nThis is the most commonly used definition in signal processing.\nUse ``sinc(x / np.pi)`` to obtain the unnormalized sinc function\n:math:`\\sin(x)/(x)` that is more common in mathematics.\n\nParameters\n----------\nx : ndarray\nArray (possibly multi-dimensional) of values for which to to\ncalculate ``sinc(x)``.\n\nReturns\n-------\nout : ndarray\n``sinc(x)``, which has the same shape as the input.\n\nNotes\n-----\n``sinc(0)`` is the limit value 1.\n\nThe name sinc is short for \"sine cardinal\" or \"sinus cardinalis\".\n\nThe sinc function is used in various signal processing applications,\nincluding in anti-aliasing, in the construction of a Lanczos resampling\nfilter, and in interpolation.\n\nFor bandlimited interpolation of discrete-time signals, the ideal\ninterpolation kernel is proportional to the sinc function.\n\nReferences\n----------\n.. [1] Weisstein, Eric W. \"Sinc Function.\" From MathWorld--A Wolfram Web\nResource. http://mathworld.wolfram.com/SincFunction.html\n.. [2] Wikipedia, \"Sinc function\",\nhttps://en.wikipedia.org/wiki/Sincfunction\n\nExamples\n--------\n>>> import matplotlib.pyplot as plt\n>>> x = np.linspace(-4, 4, 41)\n>>> np.sinc(x)\narray([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary\n-8.90384387e-02, -5.84680802e-02, 3.89804309e-17,\n6.68206631e-02, 1.16434881e-01, 1.26137788e-01,\n8.50444803e-02, -3.89804309e-17, -1.03943254e-01,\n-1.89206682e-01, -2.16236208e-01, -1.55914881e-01,\n3.89804309e-17, 2.33872321e-01, 5.04551152e-01,\n7.56826729e-01, 9.35489284e-01, 1.00000000e+00,\n9.35489284e-01, 7.56826729e-01, 5.04551152e-01,\n2.33872321e-01, 3.89804309e-17, -1.55914881e-01,\n-2.16236208e-01, -1.89206682e-01, -1.03943254e-01,\n-3.89804309e-17, 8.50444803e-02, 1.26137788e-01,\n1.16434881e-01, 6.68206631e-02, 3.89804309e-17,\n-5.84680802e-02, -8.90384387e-02, -8.40918587e-02,\n-4.92362781e-02, -3.89804309e-17])\n\n>>> plt.plot(x, np.sinc(x))\n[]\n>>> plt.title(\"Sinc Function\")\nText(0.5, 1.0, 'Sinc Function')\n>>> plt.ylabel(\"Amplitude\")\nText(0, 0.5, 'Amplitude')\n>>> plt.xlabel(\"X\")\nText(0.5, 0, 'X')\n>>> plt.show()\n" }, { "name": "size", "content": "Return the number of elements along a given axis.\n\nParameters\n----------\na : arraylike\nInput data.\naxis : int, optional\nAxis along which the elements are counted. By default, give\nthe total number of elements.\n\nReturns\n-------\nelementcount : int\nNumber of elements along the specified axis.\n\nSee Also\n--------\nshape : dimensions of array\nndarray.shape : dimensions of array\nndarray.size : number of elements in array\n\nExamples\n--------\n>>> a = np.array([[1,2,3],[4,5,6]])\n>>> np.size(a)\n6\n>>> np.size(a,1)\n3\n>>> np.size(a,0)\n2\n" }, { "name": "sometrue", "content": "Check whether some values are true.\n\nRefer to `any` for full documentation.\n\nSee Also\n--------\nany : equivalent function; see for details.\n" }, { "name": "sort", "content": "Return a sorted copy of an array.\n\nParameters\n----------\na : arraylike\nArray to be sorted.\naxis : int or None, optional\nAxis along which to sort. If None, the array is flattened before\nsorting. The default is -1, which sorts along the last axis.\nkind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\nSorting algorithm. The default is 'quicksort'. Note that both 'stable'\nand 'mergesort' use timsort or radix sort under the covers and, in general,\nthe actual implementation will vary with data type. The 'mergesort' option\nis retained for backwards compatibility.\n\n.. versionchanged:: 1.15.0.\nThe 'stable' option was added.\n\norder : str or list of str, optional\nWhen `a` is an array with fields defined, this argument specifies\nwhich fields to compare first, second, etc. A single field can\nbe specified as a string, and not all fields need be specified,\nbut unspecified fields will still be used, in the order in which\nthey come up in the dtype, to break ties.\n\nReturns\n-------\nsortedarray : ndarray\nArray of the same type and shape as `a`.\n\nSee Also\n--------\nndarray.sort : Method to sort an array in-place.\nargsort : Indirect sort.\nlexsort : Indirect stable sort on multiple keys.\nsearchsorted : Find elements in a sorted array.\npartition : Partial sort.\n\nNotes\n-----\nThe various sorting algorithms are characterized by their average speed,\nworst case performance, work space size, and whether they are stable. A\nstable sort keeps items with the same key in the same relative\norder. The four algorithms implemented in NumPy have the following\nproperties:\n\n=========== ======= ============= ============ ========\nkind speed worst case work space stable\n=========== ======= ============= ============ ========\n'quicksort' 1 O(n^2) 0 no\n'heapsort' 3 O(n*log(n)) 0 no\n'mergesort' 2 O(n*log(n)) ~n/2 yes\n'timsort' 2 O(n*log(n)) ~n/2 yes\n=========== ======= ============= ============ ========\n\n.. note:: The datatype determines which of 'mergesort' or 'timsort'\nis actually used, even if 'mergesort' is specified. User selection\nat a finer scale is not currently available.\n\nAll the sort algorithms make temporary copies of the data when\nsorting along any but the last axis. Consequently, sorting along\nthe last axis is faster and uses less space than sorting along\nany other axis.\n\nThe sort order for complex numbers is lexicographic. If both the real\nand imaginary parts are non-nan then the order is determined by the\nreal parts except when they are equal, in which case the order is\ndetermined by the imaginary parts.\n\nPrevious to numpy 1.4.0 sorting real and complex arrays containing nan\nvalues led to undefined behaviour. In numpy versions >= 1.4.0 nan\nvalues are sorted to the end. The extended sort order is:\n\n* Real: [R, nan]\n* Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]\n\nwhere R is a non-nan real value. Complex values with the same nan\nplacements are sorted according to the non-nan part if it exists.\nNon-nan values are sorted as before.\n\n.. versionadded:: 1.12.0\n\nquicksort has been changed to `introsort `.\nWhen sorting does not make enough progress it switches to\n`heapsort `.\nThis implementation makes quicksort O(n*log(n)) in the worst case.\n\n'stable' automatically chooses the best stable sorting algorithm\nfor the data type being sorted.\nIt, along with 'mergesort' is currently mapped to\n`timsort `\nor `radix sort `\ndepending on the data type.\nAPI forward compatibility currently limits the\nability to select the implementation and it is hardwired for the different\ndata types.\n\n.. versionadded:: 1.17.0\n\nTimsort is added for better performance on already or nearly\nsorted data. On random data timsort is almost identical to\nmergesort. It is now used for stable sort while quicksort is still the\ndefault sort if none is chosen. For timsort details, refer to\n`CPython listsort.txt `.\n'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is an\nO(n) sort instead of O(n log n).\n\n.. versionchanged:: 1.18.0\n\nNaT now sorts to the end of arrays for consistency with NaN.\n\nExamples\n--------\n>>> a = np.array([[1,4],[3,1]])\n>>> np.sort(a) # sort along the last axis\narray([[1, 4],\n[1, 3]])\n>>> np.sort(a, axis=None) # sort the flattened array\narray([1, 1, 3, 4])\n>>> np.sort(a, axis=0) # sort along the first axis\narray([[1, 1],\n[3, 4]])\n\nUse the `order` keyword to specify a field to use when sorting a\nstructured array:\n\n>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]\n>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),\n... ('Galahad', 1.7, 38)]\n>>> a = np.array(values, dtype=dtype) # create a structured array\n>>> np.sort(a, order='height') # doctest: +SKIP\narray([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),\n('Lancelot', 1.8999999999999999, 38)],\ndtype=[('name', '|S10'), ('height', '>> np.sort(a, order=['age', 'height']) # doctest: +SKIP\narray([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),\n('Arthur', 1.8, 41)],\ndtype=[('name', '|S10'), ('height', '>> np.sortcomplex([5, 3, 6, 2, 1])\narray([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])\n\n>>> np.sortcomplex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])\narray([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])\n" }, { "name": "source", "content": "Print or write to a file the source code for a NumPy object.\n\nThe source code is only returned for objects written in Python. Many\nfunctions and classes are defined in C and will therefore not return\nuseful information.\n\nParameters\n----------\nobject : numpy object\nInput object. This can be any object (function, class, module,\n...).\noutput : file object, optional\nIf `output` not supplied then source code is printed to screen\n(sys.stdout). File object must be created with either write 'w' or\nappend 'a' modes.\n\nSee Also\n--------\nlookfor, info\n\nExamples\n--------\n>>> np.source(np.interp) #doctest: +SKIP\nIn file: /usr/lib/python2.6/dist-packages/numpy/lib/functionbase.py\ndef interp(x, xp, fp, left=None, right=None):\n\"\"\".... (full docstring printed)\"\"\"\nif isinstance(x, (float, int, number)):\nreturn compiledinterp([x], xp, fp, left, right).item()\nelse:\nreturn compiledinterp(x, xp, fp, left, right)\n\nThe source code is only returned for objects written in Python.\n\n>>> np.source(np.array) #doctest: +SKIP\nNot available for this object.\n" }, { "name": "split", "content": "Split an array into multiple sub-arrays as views into `ary`.\n\nParameters\n----------\nary : ndarray\nArray to be divided into sub-arrays.\nindicesorsections : int or 1-D array\nIf `indicesorsections` is an integer, N, the array will be divided\ninto N equal arrays along `axis`. If such a split is not possible,\nan error is raised.\n\nIf `indicesorsections` is a 1-D array of sorted integers, the entries\nindicate where along `axis` the array is split. For example,\n``[2, 3]`` would, for ``axis=0``, result in\n\n- ary[:2]\n- ary[2:3]\n- ary[3:]\n\nIf an index exceeds the dimension of the array along `axis`,\nan empty sub-array is returned correspondingly.\naxis : int, optional\nThe axis along which to split, default is 0.\n\nReturns\n-------\nsub-arrays : list of ndarrays\nA list of sub-arrays as views into `ary`.\n\nRaises\n------\nValueError\nIf `indicesorsections` is given as an integer, but\na split does not result in equal division.\n\nSee Also\n--------\narraysplit : Split an array into multiple sub-arrays of equal or\nnear-equal size. Does not raise an exception if\nan equal division cannot be made.\nhsplit : Split array into multiple sub-arrays horizontally (column-wise).\nvsplit : Split array into multiple sub-arrays vertically (row wise).\ndsplit : Split array into multiple sub-arrays along the 3rd axis (depth).\nconcatenate : Join a sequence of arrays along an existing axis.\nstack : Join a sequence of arrays along a new axis.\nhstack : Stack arrays in sequence horizontally (column wise).\nvstack : Stack arrays in sequence vertically (row wise).\ndstack : Stack arrays in sequence depth wise (along third dimension).\n\nExamples\n--------\n>>> x = np.arange(9.0)\n>>> np.split(x, 3)\n[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])]\n\n>>> x = np.arange(8.0)\n>>> np.split(x, [3, 5, 6, 10])\n[array([0., 1., 2.]),\narray([3., 4.]),\narray([5.]),\narray([6., 7.]),\narray([], dtype=float64)]\n" }, { "name": "squeeze", "content": "Remove axes of length one from `a`.\n\nParameters\n----------\na : arraylike\nInput data.\naxis : None or int or tuple of ints, optional\n.. versionadded:: 1.7.0\n\nSelects a subset of the entries of length one in the\nshape. If an axis is selected with shape entry greater than\none, an error is raised.\n\nReturns\n-------\nsqueezed : ndarray\nThe input array, but with all or a subset of the\ndimensions of length 1 removed. This is always `a` itself\nor a view into `a`. Note that if all axes are squeezed,\nthe result is a 0d array and not a scalar.\n\nRaises\n------\nValueError\nIf `axis` is not None, and an axis being squeezed is not of length 1\n\nSee Also\n--------\nexpanddims : The inverse operation, adding entries of length one\nreshape : Insert, remove, and combine dimensions, and resize existing ones\n\nExamples\n--------\n>>> x = np.array([[[0], [1], [2]]])\n>>> x.shape\n(1, 3, 1)\n>>> np.squeeze(x).shape\n(3,)\n>>> np.squeeze(x, axis=0).shape\n(3, 1)\n>>> np.squeeze(x, axis=1).shape\nTraceback (most recent call last):\n...\nValueError: cannot select an axis to squeeze out which has size not equal to one\n>>> np.squeeze(x, axis=2).shape\n(1, 3)\n>>> x = np.array([[1234]])\n>>> x.shape\n(1, 1)\n>>> np.squeeze(x)\narray(1234) # 0d array\n>>> np.squeeze(x).shape\n()\n>>> np.squeeze(x)[()]\n1234\n" }, { "name": "stack", "content": "Join a sequence of arrays along a new axis.\n\nThe ``axis`` parameter specifies the index of the new axis in the\ndimensions of the result. For example, if ``axis=0`` it will be the first\ndimension and if ``axis=-1`` it will be the last dimension.\n\n.. versionadded:: 1.10.0\n\nParameters\n----------\narrays : sequence of arraylike\nEach array must have the same shape.\n\naxis : int, optional\nThe axis in the result array along which the input arrays are stacked.\n\nout : ndarray, optional\nIf provided, the destination to place the result. The shape must be\ncorrect, matching that of what stack would have returned if no\nout argument were specified.\n\nReturns\n-------\nstacked : ndarray\nThe stacked array has one more dimension than the input arrays.\n\nSee Also\n--------\nconcatenate : Join a sequence of arrays along an existing axis.\nblock : Assemble an nd-array from nested lists of blocks.\nsplit : Split array into a list of multiple sub-arrays of equal size.\n\nExamples\n--------\n>>> arrays = [np.random.randn(3, 4) for in range(10)]\n>>> np.stack(arrays, axis=0).shape\n(10, 3, 4)\n\n>>> np.stack(arrays, axis=1).shape\n(3, 10, 4)\n\n>>> np.stack(arrays, axis=2).shape\n(3, 4, 10)\n\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.stack((a, b))\narray([[1, 2, 3],\n[4, 5, 6]])\n\n>>> np.stack((a, b), axis=-1)\narray([[1, 4],\n[2, 5],\n[3, 6]])\n" }, { "name": "std", "content": "Compute the standard deviation along the specified axis.\n\nReturns the standard deviation, a measure of the spread of a distribution,\nof the array elements. The standard deviation is computed for the\nflattened array by default, otherwise over the specified axis.\n\nParameters\n----------\na : arraylike\nCalculate the standard deviation of these values.\naxis : None or int or tuple of ints, optional\nAxis or axes along which the standard deviation is computed. The\ndefault is to compute the standard deviation of the flattened array.\n\n.. versionadded:: 1.7.0\n\nIf this is a tuple of ints, a standard deviation is performed over\nmultiple axes, instead of a single axis or all the axes as before.\ndtype : dtype, optional\nType to use in computing the standard deviation. For arrays of\ninteger type the default is float64, for arrays of float types it is\nthe same as the array type.\nout : ndarray, optional\nAlternative output array in which to place the result. It must have\nthe same shape as the expected output but the type (of the calculated\nvalues) will be cast if necessary.\nddof : int, optional\nMeans Delta Degrees of Freedom. The divisor used in calculations\nis ``N - ddof``, where ``N`` represents the number of elements.\nBy default `ddof` is zero.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `std` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\nwhere : arraylike of bool, optional\nElements to include in the standard deviation.\nSee `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nstandarddeviation : ndarray, see dtype parameter above.\nIf `out` is None, return a new array containing the standard deviation,\notherwise return a reference to the output array.\n\nSee Also\n--------\nvar, mean, nanmean, nanstd, nanvar\n:ref:`ufuncs-output-type`\n\nNotes\n-----\nThe standard deviation is the square root of the average of the squared\ndeviations from the mean, i.e., ``std = sqrt(mean(x))``, where\n``x = abs(a - a.mean())2``.\n\nThe average squared deviation is typically calculated as ``x.sum() / N``,\nwhere ``N = len(x)``. If, however, `ddof` is specified, the divisor\n``N - ddof`` is used instead. In standard statistical practice, ``ddof=1``\nprovides an unbiased estimator of the variance of the infinite population.\n``ddof=0`` provides a maximum likelihood estimate of the variance for\nnormally distributed variables. The standard deviation computed in this\nfunction is the square root of the estimated variance, so even with\n``ddof=1``, it will not be an unbiased estimate of the standard deviation\nper se.\n\nNote that, for complex numbers, `std` takes the absolute\nvalue before squaring, so that the result is always real and nonnegative.\n\nFor floating-point input, the *std* is computed using the same\nprecision the input has. Depending on the input data, this can cause\nthe results to be inaccurate, especially for float32 (see example below).\nSpecifying a higher-accuracy accumulator using the `dtype` keyword can\nalleviate this issue.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, 4]])\n>>> np.std(a)\n1.1180339887498949 # may vary\n>>> np.std(a, axis=0)\narray([1., 1.])\n>>> np.std(a, axis=1)\narray([0.5, 0.5])\n\nIn single precision, std() can be inaccurate:\n\n>>> a = np.zeros((2, 512*512), dtype=np.float32)\n>>> a[0, :] = 1.0\n>>> a[1, :] = 0.1\n>>> np.std(a)\n0.45000005\n\nComputing the standard deviation in float64 is more accurate:\n\n>>> np.std(a, dtype=np.float64)\n0.44999999925494177 # may vary\n\nSpecifying a where argument:\n\n>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])\n>>> np.std(a)\n2.614064523559687 # may vary\n>>> np.std(a, where=[[True], [True], [False]])\n2.0\n" }, { "name": "sum", "content": "Sum of array elements over a given axis.\n\nParameters\n----------\na : arraylike\nElements to sum.\naxis : None or int or tuple of ints, optional\nAxis or axes along which a sum is performed. The default,\naxis=None, will sum all of the elements of the input array. If\naxis is negative it counts from the last to the first axis.\n\n.. versionadded:: 1.7.0\n\nIf axis is a tuple of ints, a sum is performed on all of the axes\nspecified in the tuple instead of a single axis or all the axes as\nbefore.\ndtype : dtype, optional\nThe type of the returned array and of the accumulator in which the\nelements are summed. The dtype of `a` is used by default unless `a`\nhas an integer dtype of less precision than the default platform\ninteger. In that case, if `a` is signed then the platform integer\nis used while if `a` is unsigned then an unsigned integer of the\nsame precision as the platform integer is used.\nout : ndarray, optional\nAlternative output array in which to place the result. It must have\nthe same shape as the expected output, but the type of the output\nvalues will be cast if necessary.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `sum` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\ninitial : scalar, optional\nStarting value for the sum. See `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.15.0\n\nwhere : arraylike of bool, optional\nElements to include in the sum. See `~numpy.ufunc.reduce` for details.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\nsumalongaxis : ndarray\nAn array with the same shape as `a`, with the specified\naxis removed. If `a` is a 0-d array, or if `axis` is None, a scalar\nis returned. If an output array is specified, a reference to\n`out` is returned.\n\nSee Also\n--------\nndarray.sum : Equivalent method.\n\nadd.reduce : Equivalent functionality of `add`.\n\ncumsum : Cumulative sum of array elements.\n\ntrapz : Integration of array values using the composite trapezoidal rule.\n\nmean, average\n\nNotes\n-----\nArithmetic is modular when using integer types, and no error is\nraised on overflow.\n\nThe sum of an empty array is the neutral element 0:\n\n>>> np.sum([])\n0.0\n\nFor floating point numbers the numerical precision of sum (and\n``np.add.reduce``) is in general limited by directly adding each number\nindividually to the result causing rounding errors in every step.\nHowever, often numpy will use a numerically better approach (partial\npairwise summation) leading to improved precision in many use-cases.\nThis improved precision is always provided when no ``axis`` is given.\nWhen ``axis`` is given, it will depend on which axis is summed.\nTechnically, to provide the best speed possible, the improved precision\nis only used when the summation is along the fast axis in memory.\nNote that the exact precision may vary depending on other parameters.\nIn contrast to NumPy, Python's ``math.fsum`` function uses a slower but\nmore precise approach to summation.\nEspecially when summing a large number of lower precision floating point\nnumbers, such as ``float32``, numerical errors can become significant.\nIn such cases it can be advisable to use `dtype=\"float64\"` to use a higher\nprecision for the output.\n\nExamples\n--------\n>>> np.sum([0.5, 1.5])\n2.0\n>>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)\n1\n>>> np.sum([[0, 1], [0, 5]])\n6\n>>> np.sum([[0, 1], [0, 5]], axis=0)\narray([0, 6])\n>>> np.sum([[0, 1], [0, 5]], axis=1)\narray([1, 5])\n>>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)\narray([1., 5.])\n\nIf the accumulator is too small, overflow occurs:\n\n>>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)\n-128\n\nYou can also start the sum with a value other than zero:\n\n>>> np.sum([10], initial=5)\n15\n" }, { "name": "swapaxes", "content": "Interchange two axes of an array.\n\nParameters\n----------\na : arraylike\nInput array.\naxis1 : int\nFirst axis.\naxis2 : int\nSecond axis.\n\nReturns\n-------\naswapped : ndarray\nFor NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is\nreturned; otherwise a new array is created. For earlier NumPy\nversions a view of `a` is returned only if the order of the\naxes is changed, otherwise the input array is returned.\n\nExamples\n--------\n>>> x = np.array([[1,2,3]])\n>>> np.swapaxes(x,0,1)\narray([[1],\n[2],\n[3]])\n\n>>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])\n>>> x\narray([[[0, 1],\n[2, 3]],\n[[4, 5],\n[6, 7]]])\n\n>>> np.swapaxes(x,0,2)\narray([[[0, 4],\n[2, 6]],\n[[1, 5],\n[3, 7]]])\n" }, { "name": "take", "content": "Take elements from an array along an axis.\n\nWhen axis is not None, this function does the same thing as \"fancy\"\nindexing (indexing arrays using arrays); however, it can be easier to use\nif you need elements along a given axis. A call such as\n``np.take(arr, indices, axis=3)`` is equivalent to\n``arr[:,:,:,indices,...]``.\n\nExplained without fancy indexing, this is equivalent to the following use\nof `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of\nindices::\n\nNi, Nk = a.shape[:axis], a.shape[axis+1:]\nNj = indices.shape\nfor ii in ndindex(Ni):\nfor jj in ndindex(Nj):\nfor kk in ndindex(Nk):\nout[ii + jj + kk] = a[ii + (indices[jj],) + kk]\n\nParameters\n----------\na : arraylike (Ni..., M, Nk...)\nThe source array.\nindices : arraylike (Nj...)\nThe indices of the values to extract.\n\n.. versionadded:: 1.8.0\n\nAlso allow scalars for indices.\naxis : int, optional\nThe axis over which to select values. By default, the flattened\ninput array is used.\nout : ndarray, optional (Ni..., Nj..., Nk...)\nIf provided, the result will be placed in this array. It should\nbe of the appropriate shape and dtype. Note that `out` is always\nbuffered if `mode='raise'`; use other modes for better performance.\nmode : {'raise', 'wrap', 'clip'}, optional\nSpecifies how out-of-bounds indices will behave.\n\n* 'raise' -- raise an error (default)\n* 'wrap' -- wrap around\n* 'clip' -- clip to the range\n\n'clip' mode means that all indices that are too large are replaced\nby the index that addresses the last element along that axis. Note\nthat this disables indexing with negative numbers.\n\nReturns\n-------\nout : ndarray (Ni..., Nj..., Nk...)\nThe returned array has the same type as `a`.\n\nSee Also\n--------\ncompress : Take elements using a boolean mask\nndarray.take : equivalent method\ntakealongaxis : Take elements by matching the array and the index arrays\n\nNotes\n-----\n\nBy eliminating the inner loop in the description above, and using `s` to\nbuild simple slice objects, `take` can be expressed in terms of applying\nfancy indexing to each 1-d slice::\n\nNi, Nk = a.shape[:axis], a.shape[axis+1:]\nfor ii in ndindex(Ni):\nfor kk in ndindex(Nj):\nout[ii + s[...,] + kk] = a[ii + s[:,] + kk][indices]\n\nFor this reason, it is equivalent to (but faster than) the following use\nof `applyalongaxis`::\n\nout = np.applyalongaxis(lambda a1d: a1d[indices], axis, a)\n\nExamples\n--------\n>>> a = [4, 3, 5, 7, 6, 8]\n>>> indices = [0, 1, 4]\n>>> np.take(a, indices)\narray([4, 3, 6])\n\nIn this example if `a` is an ndarray, \"fancy\" indexing can be used.\n\n>>> a = np.array(a)\n>>> a[indices]\narray([4, 3, 6])\n\nIf `indices` is not one dimensional, the output also has these dimensions.\n\n>>> np.take(a, [[0, 1], [2, 3]])\narray([[4, 3],\n[5, 7]])\n" }, { "name": "take_along_axis", "content": "Take values from the input array by matching 1d index and data slices.\n\nThis iterates over matching 1d slices oriented along the specified axis in\nthe index and data arrays, and uses the former to look up values in the\nlatter. These slices can be different lengths.\n\nFunctions returning an index along an axis, like `argsort` and\n`argpartition`, produce suitable indices for this function.\n\n.. versionadded:: 1.15.0\n\nParameters\n----------\narr : ndarray (Ni..., M, Nk...)\nSource array\nindices : ndarray (Ni..., J, Nk...)\nIndices to take along each 1d slice of `arr`. This must match the\ndimension of arr, but dimensions Ni and Nj only need to broadcast\nagainst `arr`.\naxis : int\nThe axis to take 1d slices along. If axis is None, the input array is\ntreated as if it had first been flattened to 1d, for consistency with\n`sort` and `argsort`.\n\nReturns\n-------\nout: ndarray (Ni..., J, Nk...)\nThe indexed result.\n\nNotes\n-----\nThis is equivalent to (but faster than) the following use of `ndindex` and\n`s`, which sets each of ``ii`` and ``kk`` to a tuple of indices::\n\nNi, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]\nJ = indices.shape[axis] # Need not equal M\nout = np.empty(Ni + (J,) + Nk)\n\nfor ii in ndindex(Ni):\nfor kk in ndindex(Nk):\na1d = a [ii + s[:,] + kk]\nindices1d = indices[ii + s[:,] + kk]\nout1d = out [ii + s[:,] + kk]\nfor j in range(J):\nout1d[j] = a1d[indices1d[j]]\n\nEquivalently, eliminating the inner loop, the last two lines would be::\n\nout1d[:] = a1d[indices1d]\n\nSee Also\n--------\ntake : Take along an axis, using the same indices for every 1d slice\nputalongaxis :\nPut values into the destination array by matching 1d index and data slices\n\nExamples\n--------\n\nFor this sample array\n\n>>> a = np.array([[10, 30, 20], [60, 40, 50]])\n\nWe can sort either by using sort directly, or argsort and this function\n\n>>> np.sort(a, axis=1)\narray([[10, 20, 30],\n[40, 50, 60]])\n>>> ai = np.argsort(a, axis=1); ai\narray([[0, 2, 1],\n[1, 2, 0]])\n>>> np.takealongaxis(a, ai, axis=1)\narray([[10, 20, 30],\n[40, 50, 60]])\n\nThe same works for max and min, if you expand the dimensions:\n\n>>> np.expanddims(np.max(a, axis=1), axis=1)\narray([[30],\n[60]])\n>>> ai = np.expanddims(np.argmax(a, axis=1), axis=1)\n>>> ai\narray([[1],\n[0]])\n>>> np.takealongaxis(a, ai, axis=1)\narray([[30],\n[60]])\n\nIf we want to get the max and min at the same time, we can stack the\nindices first\n\n>>> aimin = np.expanddims(np.argmin(a, axis=1), axis=1)\n>>> aimax = np.expanddims(np.argmax(a, axis=1), axis=1)\n>>> ai = np.concatenate([aimin, aimax], axis=1)\n>>> ai\narray([[0, 1],\n[1, 0]])\n>>> np.takealongaxis(a, ai, axis=1)\narray([[10, 30],\n[40, 60]])\n" }, { "name": "tensordot", "content": "Compute tensor dot product along specified axes.\n\nGiven two tensors, `a` and `b`, and an arraylike object containing\ntwo arraylike objects, ``(aaxes, baxes)``, sum the products of\n`a`'s and `b`'s elements (components) over the axes specified by\n``aaxes`` and ``baxes``. The third argument can be a single non-negative\nintegerlike scalar, ``N``; if it is such, then the last ``N`` dimensions\nof `a` and the first ``N`` dimensions of `b` are summed over.\n\nParameters\n----------\na, b : arraylike\nTensors to \"dot\".\n\naxes : int or (2,) arraylike\n* integerlike\nIf an int N, sum over the last N axes of `a` and the first N axes\nof `b` in order. The sizes of the corresponding axes must match.\n* (2,) arraylike\nOr, a list of axes to be summed over, first sequence applying to `a`,\nsecond to `b`. Both elements arraylike must be of the same length.\n\nReturns\n-------\noutput : ndarray\nThe tensor dot product of the input.\n\nSee Also\n--------\ndot, einsum\n\nNotes\n-----\nThree common use cases are:\n* ``axes = 0`` : tensor product :math:`a\\otimes b`\n* ``axes = 1`` : tensor dot product :math:`a\\cdot b`\n* ``axes = 2`` : (default) tensor double contraction :math:`a:b`\n\nWhen `axes` is integerlike, the sequence for evaluation will be: first\nthe -Nth axis in `a` and 0th axis in `b`, and the -1th axis in `a` and\nNth axis in `b` last.\n\nWhen there is more than one axis to sum over - and they are not the last\n(first) axes of `a` (`b`) - the argument `axes` should consist of\ntwo sequences of the same length, with the first axis to sum over given\nfirst in both sequences, the second axis second, and so forth.\n\nThe shape of the result consists of the non-contracted axes of the\nfirst tensor, followed by the non-contracted axes of the second.\n\nExamples\n--------\nA \"traditional\" example:\n\n>>> a = np.arange(60.).reshape(3,4,5)\n>>> b = np.arange(24.).reshape(4,3,2)\n>>> c = np.tensordot(a,b, axes=([1,0],[0,1]))\n>>> c.shape\n(5, 2)\n>>> c\narray([[4400., 4730.],\n[4532., 4874.],\n[4664., 5018.],\n[4796., 5162.],\n[4928., 5306.]])\n>>> # A slower but equivalent way of computing the same...\n>>> d = np.zeros((5,2))\n>>> for i in range(5):\n... for j in range(2):\n... for k in range(3):\n... for n in range(4):\n... d[i,j] += a[k,n,i] * b[n,k,j]\n>>> c == d\narray([[ True, True],\n[ True, True],\n[ True, True],\n[ True, True],\n[ True, True]])\n\nAn extended example taking advantage of the overloading of + and \\*:\n\n>>> a = np.array(range(1, 9))\n>>> a.shape = (2, 2, 2)\n>>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)\n>>> A.shape = (2, 2)\n>>> a; A\narray([[[1, 2],\n[3, 4]],\n[[5, 6],\n[7, 8]]])\narray([['a', 'b'],\n['c', 'd']], dtype=object)\n\n>>> np.tensordot(a, A) # third argument default is 2 for double-contraction\narray(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)\n\n>>> np.tensordot(a, A, 1)\narray([[['acc', 'bdd'],\n['aaacccc', 'bbbdddd']],\n[['aaaaacccccc', 'bbbbbdddddd'],\n['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)\n\n>>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)\narray([[[[['a', 'b'],\n['c', 'd']],\n...\n\n>>> np.tensordot(a, A, (0, 1))\narray([[['abbbbb', 'cddddd'],\n['aabbbbbb', 'ccdddddd']],\n[['aaabbbbbbb', 'cccddddddd'],\n['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)\n\n>>> np.tensordot(a, A, (2, 1))\narray([[['abb', 'cdd'],\n['aaabbbb', 'cccdddd']],\n[['aaaaabbbbbb', 'cccccdddddd'],\n['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)\n\n>>> np.tensordot(a, A, ((0, 1), (0, 1)))\narray(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)\n\n>>> np.tensordot(a, A, ((2, 1), (1, 0)))\narray(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)\n" }, { "name": "tile", "content": "Construct an array by repeating A the number of times given by reps.\n\nIf `reps` has length ``d``, the result will have dimension of\n``max(d, A.ndim)``.\n\nIf ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new\naxes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,\nor shape (1, 1, 3) for 3-D replication. If this is not the desired\nbehavior, promote `A` to d-dimensions manually before calling this\nfunction.\n\nIf ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it.\nThus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as\n(1, 1, 2, 2).\n\nNote : Although tile may be used for broadcasting, it is strongly\nrecommended to use numpy's broadcasting operations and functions.\n\nParameters\n----------\nA : arraylike\nThe input array.\nreps : arraylike\nThe number of repetitions of `A` along each axis.\n\nReturns\n-------\nc : ndarray\nThe tiled output array.\n\nSee Also\n--------\nrepeat : Repeat elements of an array.\nbroadcastto : Broadcast an array to a new shape\n\nExamples\n--------\n>>> a = np.array([0, 1, 2])\n>>> np.tile(a, 2)\narray([0, 1, 2, 0, 1, 2])\n>>> np.tile(a, (2, 2))\narray([[0, 1, 2, 0, 1, 2],\n[0, 1, 2, 0, 1, 2]])\n>>> np.tile(a, (2, 1, 2))\narray([[[0, 1, 2, 0, 1, 2]],\n[[0, 1, 2, 0, 1, 2]]])\n\n>>> b = np.array([[1, 2], [3, 4]])\n>>> np.tile(b, 2)\narray([[1, 2, 1, 2],\n[3, 4, 3, 4]])\n>>> np.tile(b, (2, 1))\narray([[1, 2],\n[3, 4],\n[1, 2],\n[3, 4]])\n\n>>> c = np.array([1,2,3,4])\n>>> np.tile(c,(4,1))\narray([[1, 2, 3, 4],\n[1, 2, 3, 4],\n[1, 2, 3, 4],\n[1, 2, 3, 4]])\n" }, { "name": "trace", "content": "Return the sum along diagonals of the array.\n\nIf `a` is 2-D, the sum along its diagonal with the given offset\nis returned, i.e., the sum of elements ``a[i,i+offset]`` for all i.\n\nIf `a` has more than two dimensions, then the axes specified by axis1 and\naxis2 are used to determine the 2-D sub-arrays whose traces are returned.\nThe shape of the resulting array is the same as that of `a` with `axis1`\nand `axis2` removed.\n\nParameters\n----------\na : arraylike\nInput array, from which the diagonals are taken.\noffset : int, optional\nOffset of the diagonal from the main diagonal. Can be both positive\nand negative. Defaults to 0.\naxis1, axis2 : int, optional\nAxes to be used as the first and second axis of the 2-D sub-arrays\nfrom which the diagonals should be taken. Defaults are the first two\naxes of `a`.\ndtype : dtype, optional\nDetermines the data-type of the returned array and of the accumulator\nwhere the elements are summed. If dtype has the value None and `a` is\nof integer type of precision less than the default integer\nprecision, then the default integer precision is used. Otherwise,\nthe precision is the same as that of `a`.\nout : ndarray, optional\nArray into which the output is placed. Its type is preserved and\nit must be of the right shape to hold the output.\n\nReturns\n-------\nsumalongdiagonals : ndarray\nIf `a` is 2-D, the sum along the diagonal is returned. If `a` has\nlarger dimensions, then an array of sums along diagonals is returned.\n\nSee Also\n--------\ndiag, diagonal, diagflat\n\nExamples\n--------\n>>> np.trace(np.eye(3))\n3.0\n>>> a = np.arange(8).reshape((2,2,2))\n>>> np.trace(a)\narray([6, 8])\n\n>>> a = np.arange(24).reshape((2,2,2,3))\n>>> np.trace(a).shape\n(2, 3)\n" }, { "name": "transpose", "content": "Reverse or permute the axes of an array; returns the modified array.\n\nFor an array a with two axes, transpose(a) gives the matrix transpose.\n\nRefer to `numpy.ndarray.transpose` for full documentation.\n\nParameters\n----------\na : arraylike\nInput array.\naxes : tuple or list of ints, optional\nIf specified, it must be a tuple or list which contains a permutation of\n[0,1,..,N-1] where N is the number of axes of a. The i'th axis of the\nreturned array will correspond to the axis numbered ``axes[i]`` of the\ninput. If not specified, defaults to ``range(a.ndim)[::-1]``, which\nreverses the order of the axes.\n\nReturns\n-------\np : ndarray\n`a` with its axes permuted. A view is returned whenever\npossible.\n\nSee Also\n--------\nndarray.transpose : Equivalent method\nmoveaxis\nargsort\n\nNotes\n-----\nUse `transpose(a, argsort(axes))` to invert the transposition of tensors\nwhen using the `axes` keyword argument.\n\nTransposing a 1-D array returns an unchanged view of the original array.\n\nExamples\n--------\n>>> x = np.arange(4).reshape((2,2))\n>>> x\narray([[0, 1],\n[2, 3]])\n\n>>> np.transpose(x)\narray([[0, 2],\n[1, 3]])\n\n>>> x = np.ones((1, 2, 3))\n>>> np.transpose(x, (1, 0, 2)).shape\n(2, 1, 3)\n\n>>> x = np.ones((2, 3, 4, 5))\n>>> np.transpose(x).shape\n(5, 4, 3, 2)\n" }, { "name": "trapz", "content": "Integrate along the given axis using the composite trapezoidal rule.\n\nIf `x` is provided, the integration happens in sequence along its\nelements - they are not sorted.\n\nIntegrate `y` (`x`) along each 1d slice on the given axis, compute\n:math:`\\int y(x) dx`.\nWhen `x` is specified, this integrates along the parametric curve,\ncomputing :math:`\\intt y(t) dt =\n\\intt y(t) \\left.\\frac{dx}{dt}\\right|{x=x(t)} dt`.\n\nParameters\n----------\ny : arraylike\nInput array to integrate.\nx : arraylike, optional\nThe sample points corresponding to the `y` values. If `x` is None,\nthe sample points are assumed to be evenly spaced `dx` apart. The\ndefault is None.\ndx : scalar, optional\nThe spacing between sample points when `x` is None. The default is 1.\naxis : int, optional\nThe axis along which to integrate.\n\nReturns\n-------\ntrapz : float or ndarray\nDefinite integral of 'y' = n-dimensional array as approximated along\na single axis by the trapezoidal rule. If 'y' is a 1-dimensional array,\nthen the result is a float. If 'n' is greater than 1, then the result\nis an 'n-1' dimensional array.\n\nSee Also\n--------\nsum, cumsum\n\nNotes\n-----\nImage [2] illustrates trapezoidal rule -- y-axis locations of points\nwill be taken from `y` array, by default x-axis distances between\npoints will be 1.0, alternatively they can be provided with `x` array\nor with `dx` scalar. Return value will be equal to combined area under\nthe red lines.\n\n\nReferences\n----------\n.. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidalrule\n\n.. [2] Illustration image:\nhttps://en.wikipedia.org/wiki/File:Compositetrapezoidalruleillustration.png\n\nExamples\n--------\n>>> np.trapz([1,2,3])\n4.0\n>>> np.trapz([1,2,3], x=[4,6,8])\n8.0\n>>> np.trapz([1,2,3], dx=2)\n8.0\n\nUsing a decreasing `x` corresponds to integrating in reverse:\n\n>>> np.trapz([1,2,3], x=[8,6,4])\n-8.0\n\nMore generally `x` is used to integrate along a parametric curve.\nThis finds the area of a circle, noting we repeat the sample which closes\nthe curve:\n\n>>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)\n>>> np.trapz(np.cos(theta), x=np.sin(theta))\n3.141571941375841\n\n>>> a = np.arange(6).reshape(2, 3)\n>>> a\narray([[0, 1, 2],\n[3, 4, 5]])\n>>> np.trapz(a, axis=0)\narray([1.5, 2.5, 3.5])\n>>> np.trapz(a, axis=1)\narray([2., 8.])\n" }, { "name": "tri", "content": "An array with ones at and below the given diagonal and zeros elsewhere.\n\nParameters\n----------\nN : int\nNumber of rows in the array.\nM : int, optional\nNumber of columns in the array.\nBy default, `M` is taken equal to `N`.\nk : int, optional\nThe sub-diagonal at and below which the array is filled.\n`k` = 0 is the main diagonal, while `k` < 0 is below it,\nand `k` > 0 is above. The default is 0.\ndtype : dtype, optional\nData type of the returned array. The default is float.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\ntri : ndarray of shape (N, M)\nArray with its lower triangle filled with ones and zero elsewhere;\nin other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.\n\nExamples\n--------\n>>> np.tri(3, 5, 2, dtype=int)\narray([[1, 1, 1, 0, 0],\n[1, 1, 1, 1, 0],\n[1, 1, 1, 1, 1]])\n\n>>> np.tri(3, 5, -1)\narray([[0., 0., 0., 0., 0.],\n[1., 0., 0., 0., 0.],\n[1., 1., 0., 0., 0.]])\n" }, { "name": "tril", "content": "Lower triangle of an array.\n\nReturn a copy of an array with elements above the `k`-th diagonal zeroed.\n\nParameters\n----------\nm : arraylike, shape (M, N)\nInput array.\nk : int, optional\nDiagonal above which to zero elements. `k = 0` (the default) is the\nmain diagonal, `k < 0` is below it and `k > 0` is above.\n\nReturns\n-------\ntril : ndarray, shape (M, N)\nLower triangle of `m`, of same shape and data-type as `m`.\n\nSee Also\n--------\ntriu : same thing, only for the upper triangle\n\nExamples\n--------\n>>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)\narray([[ 0, 0, 0],\n[ 4, 0, 0],\n[ 7, 8, 0],\n[10, 11, 12]])\n" }, { "name": "tril_indices", "content": "Return the indices for the lower-triangle of an (n, m) array.\n\nParameters\n----------\nn : int\nThe row dimension of the arrays for which the returned\nindices will be valid.\nk : int, optional\nDiagonal offset (see `tril` for details).\nm : int, optional\n.. versionadded:: 1.9.0\n\nThe column dimension of the arrays for which the returned\narrays will be valid.\nBy default `m` is taken equal to `n`.\n\n\nReturns\n-------\ninds : tuple of arrays\nThe indices for the triangle. The returned tuple contains two arrays,\neach with the indices along one dimension of the array.\n\nSee also\n--------\ntriuindices : similar function, for upper-triangular.\nmaskindices : generic function accepting an arbitrary mask function.\ntril, triu\n\nNotes\n-----\n.. versionadded:: 1.4.0\n\nExamples\n--------\nCompute two different sets of indices to access 4x4 arrays, one for the\nlower triangular part starting at the main diagonal, and one starting two\ndiagonals further right:\n\n>>> il1 = np.trilindices(4)\n>>> il2 = np.trilindices(4, 2)\n\nHere is how they can be used with a sample array:\n\n>>> a = np.arange(16).reshape(4, 4)\n>>> a\narray([[ 0, 1, 2, 3],\n[ 4, 5, 6, 7],\n[ 8, 9, 10, 11],\n[12, 13, 14, 15]])\n\nBoth for indexing:\n\n>>> a[il1]\narray([ 0, 4, 5, ..., 13, 14, 15])\n\nAnd for assigning values:\n\n>>> a[il1] = -1\n>>> a\narray([[-1, 1, 2, 3],\n[-1, -1, 6, 7],\n[-1, -1, -1, 11],\n[-1, -1, -1, -1]])\n\nThese cover almost the whole array (two diagonals right of the main one):\n\n>>> a[il2] = -10\n>>> a\narray([[-10, -10, -10, 3],\n[-10, -10, -10, -10],\n[-10, -10, -10, -10],\n[-10, -10, -10, -10]])\n" }, { "name": "tril_indices_from", "content": "Return the indices for the lower-triangle of arr.\n\nSee `trilindices` for full details.\n\nParameters\n----------\narr : arraylike\nThe indices will be valid for square arrays whose dimensions are\nthe same as arr.\nk : int, optional\nDiagonal offset (see `tril` for details).\n\nSee Also\n--------\ntrilindices, tril\n\nNotes\n-----\n.. versionadded:: 1.4.0\n" }, { "name": "trim_zeros", "content": "Trim the leading and/or trailing zeros from a 1-D array or sequence.\n\nParameters\n----------\nfilt : 1-D array or sequence\nInput array.\ntrim : str, optional\nA string with 'f' representing trim from front and 'b' to trim from\nback. Default is 'fb', trim zeros from both front and back of the\narray.\n\nReturns\n-------\ntrimmed : 1-D array or sequence\nThe result of trimming the input. The input data type is preserved.\n\nExamples\n--------\n>>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))\n>>> np.trimzeros(a)\narray([1, 2, 3, 0, 2, 1])\n\n>>> np.trimzeros(a, 'b')\narray([0, 0, 0, ..., 0, 2, 1])\n\nThe input data type is preserved, list/tuple in means list/tuple out.\n\n>>> np.trimzeros([0, 1, 2, 0])\n[1, 2]\n" }, { "name": "triu", "content": "Upper triangle of an array.\n\nReturn a copy of an array with the elements below the `k`-th diagonal\nzeroed.\n\nPlease refer to the documentation for `tril` for further details.\n\nSee Also\n--------\ntril : lower triangle of an array\n\nExamples\n--------\n>>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)\narray([[ 1, 2, 3],\n[ 4, 5, 6],\n[ 0, 8, 9],\n[ 0, 0, 12]])\n" }, { "name": "triu_indices", "content": "Return the indices for the upper-triangle of an (n, m) array.\n\nParameters\n----------\nn : int\nThe size of the arrays for which the returned indices will\nbe valid.\nk : int, optional\nDiagonal offset (see `triu` for details).\nm : int, optional\n.. versionadded:: 1.9.0\n\nThe column dimension of the arrays for which the returned\narrays will be valid.\nBy default `m` is taken equal to `n`.\n\n\nReturns\n-------\ninds : tuple, shape(2) of ndarrays, shape(`n`)\nThe indices for the triangle. The returned tuple contains two arrays,\neach with the indices along one dimension of the array. Can be used\nto slice a ndarray of shape(`n`, `n`).\n\nSee also\n--------\ntrilindices : similar function, for lower-triangular.\nmaskindices : generic function accepting an arbitrary mask function.\ntriu, tril\n\nNotes\n-----\n.. versionadded:: 1.4.0\n\nExamples\n--------\nCompute two different sets of indices to access 4x4 arrays, one for the\nupper triangular part starting at the main diagonal, and one starting two\ndiagonals further right:\n\n>>> iu1 = np.triuindices(4)\n>>> iu2 = np.triuindices(4, 2)\n\nHere is how they can be used with a sample array:\n\n>>> a = np.arange(16).reshape(4, 4)\n>>> a\narray([[ 0, 1, 2, 3],\n[ 4, 5, 6, 7],\n[ 8, 9, 10, 11],\n[12, 13, 14, 15]])\n\nBoth for indexing:\n\n>>> a[iu1]\narray([ 0, 1, 2, ..., 10, 11, 15])\n\nAnd for assigning values:\n\n>>> a[iu1] = -1\n>>> a\narray([[-1, -1, -1, -1],\n[ 4, -1, -1, -1],\n[ 8, 9, -1, -1],\n[12, 13, 14, -1]])\n\nThese cover only a small part of the whole array (two diagonals right\nof the main one):\n\n>>> a[iu2] = -10\n>>> a\narray([[ -1, -1, -10, -10],\n[ 4, -1, -1, -10],\n[ 8, 9, -1, -1],\n[ 12, 13, 14, -1]])\n" }, { "name": "triu_indices_from", "content": "Return the indices for the upper-triangle of arr.\n\nSee `triuindices` for full details.\n\nParameters\n----------\narr : ndarray, shape(N, N)\nThe indices will be valid for square arrays.\nk : int, optional\nDiagonal offset (see `triu` for details).\n\nReturns\n-------\ntriuindicesfrom : tuple, shape(2) of ndarray, shape(N)\nIndices for the upper-triangle of `arr`.\n\nSee Also\n--------\ntriuindices, triu\n\nNotes\n-----\n.. versionadded:: 1.4.0\n" }, { "name": "typename", "content": "Return a description for the given data type code.\n\nParameters\n----------\nchar : str\nData type code.\n\nReturns\n-------\nout : str\nDescription of the input data type code.\n\nSee Also\n--------\ndtype, typecodes\n\nExamples\n--------\n>>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',\n... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']\n>>> for typechar in typechars:\n... print(typechar, ' : ', np.typename(typechar))\n...\nS1 : character\n? : bool\nB : unsigned char\nD : complex double precision\nG : complex long double precision\nF : complex single precision\nI : unsigned integer\nH : unsigned short\nL : unsigned long integer\nO : object\nQ : unsigned long long integer\nS : string\nU : unicode\nV : void\nb : signed char\nd : double precision\ng : long precision\nf : single precision\ni : integer\nh : short\nl : long integer\nq : long long integer\n" }, { "name": "union1d", "content": "Find the union of two arrays.\n\nReturn the unique, sorted array of values that are in either of the two\ninput arrays.\n\nParameters\n----------\nar1, ar2 : arraylike\nInput arrays. They are flattened if they are not already 1D.\n\nReturns\n-------\nunion1d : ndarray\nUnique, sorted union of the input arrays.\n\nSee Also\n--------\nnumpy.lib.arraysetops : Module with a number of other functions for\nperforming set operations on arrays.\n\nExamples\n--------\n>>> np.union1d([-1, 0, 1], [-2, 0, 2])\narray([-2, -1, 0, 1, 2])\n\nTo find the union of more than two arrays, use functools.reduce:\n\n>>> from functools import reduce\n>>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))\narray([1, 2, 3, 4, 6])\n" }, { "name": "unique", "content": "Find the unique elements of an array.\n\nReturns the sorted unique elements of an array. There are three optional\noutputs in addition to the unique elements:\n\n* the indices of the input array that give the unique values\n* the indices of the unique array that reconstruct the input array\n* the number of times each unique value comes up in the input array\n\nParameters\n----------\nar : arraylike\nInput array. Unless `axis` is specified, this will be flattened if it\nis not already 1-D.\nreturnindex : bool, optional\nIf True, also return the indices of `ar` (along the specified axis,\nif provided, or in the flattened array) that result in the unique array.\nreturninverse : bool, optional\nIf True, also return the indices of the unique array (for the specified\naxis, if provided) that can be used to reconstruct `ar`.\nreturncounts : bool, optional\nIf True, also return the number of times each unique item appears\nin `ar`.\n\n.. versionadded:: 1.9.0\n\naxis : int or None, optional\nThe axis to operate on. If None, `ar` will be flattened. If an integer,\nthe subarrays indexed by the given axis will be flattened and treated\nas the elements of a 1-D array with the dimension of the given axis,\nsee the notes for more details. Object arrays or structured arrays\nthat contain objects are not supported if the `axis` kwarg is used. The\ndefault is None.\n\n.. versionadded:: 1.13.0\n\nReturns\n-------\nunique : ndarray\nThe sorted unique values.\nuniqueindices : ndarray, optional\nThe indices of the first occurrences of the unique values in the\noriginal array. Only provided if `returnindex` is True.\nuniqueinverse : ndarray, optional\nThe indices to reconstruct the original array from the\nunique array. Only provided if `returninverse` is True.\nuniquecounts : ndarray, optional\nThe number of times each of the unique values comes up in the\noriginal array. Only provided if `returncounts` is True.\n\n.. versionadded:: 1.9.0\n\nSee Also\n--------\nnumpy.lib.arraysetops : Module with a number of other functions for\nperforming set operations on arrays.\nrepeat : Repeat elements of an array.\n\nNotes\n-----\nWhen an axis is specified the subarrays indexed by the axis are sorted.\nThis is done by making the specified axis the first dimension of the array\n(move the axis to the first dimension to keep the order of the other axes)\nand then flattening the subarrays in C order. The flattened subarrays are\nthen viewed as a structured type with each element given a label, with the\neffect that we end up with a 1-D array of structured types that can be\ntreated in the same way as any other 1-D array. The result is that the\nflattened subarrays are sorted in lexicographic order starting with the\nfirst element.\n\n.. versionchanged: NumPy 1.21\nIf nan values are in the input array, a single nan is put\nto the end of the sorted unique values.\n\nAlso for complex arrays all NaN values are considered equivalent\n(no matter whether the NaN is in the real or imaginary part).\nAs the representant for the returned array the smallest one in the\nlexicographical order is chosen - see np.sort for how the lexicographical\norder is defined for complex arrays.\n\nExamples\n--------\n>>> np.unique([1, 1, 2, 2, 3, 3])\narray([1, 2, 3])\n>>> a = np.array([[1, 1], [2, 3]])\n>>> np.unique(a)\narray([1, 2, 3])\n\nReturn the unique rows of a 2D array\n\n>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])\n>>> np.unique(a, axis=0)\narray([[1, 0, 0], [2, 3, 4]])\n\nReturn the indices of the original array that give the unique values:\n\n>>> a = np.array(['a', 'b', 'b', 'c', 'a'])\n>>> u, indices = np.unique(a, returnindex=True)\n>>> u\narray(['a', 'b', 'c'], dtype='>> indices\narray([0, 1, 3])\n>>> a[indices]\narray(['a', 'b', 'c'], dtype='>> a = np.array([1, 2, 6, 4, 2, 3, 2])\n>>> u, indices = np.unique(a, returninverse=True)\n>>> u\narray([1, 2, 3, 4, 6])\n>>> indices\narray([0, 1, 4, 3, 1, 2, 1])\n>>> u[indices]\narray([1, 2, 6, 4, 2, 3, 2])\n\nReconstruct the input values from the unique values and counts:\n\n>>> a = np.array([1, 2, 6, 4, 2, 3, 2])\n>>> values, counts = np.unique(a, returncounts=True)\n>>> values\narray([1, 2, 3, 4, 6])\n>>> counts\narray([1, 3, 1, 1, 1])\n>>> np.repeat(values, counts)\narray([1, 2, 2, 2, 3, 4, 6]) # original order not preserved\n" }, { "name": "unpackbits", "content": "unpackbits(a, axis=None, count=None, bitorder='big')\n\nUnpacks elements of a uint8 array into a binary-valued output array.\n\nEach element of `a` represents a bit-field that should be unpacked\ninto a binary-valued output array. The shape of the output array is\neither 1-D (if `axis` is ``None``) or the same shape as the input\narray with unpacking done along the axis specified.\n\nParameters\n----------\na : ndarray, uint8 type\nInput array.\naxis : int, optional\nThe dimension over which bit-unpacking is done.\n``None`` implies unpacking the flattened array.\ncount : int or None, optional\nThe number of elements to unpack along `axis`, provided as a way\nof undoing the effect of packing a size that is not a multiple\nof eight. A non-negative number means to only unpack `count`\nbits. A negative number means to trim off that many bits from\nthe end. ``None`` means to unpack the entire array (the\ndefault). Counts larger than the available number of bits will\nadd zero padding to the output. Negative counts must not\nexceed the available number of bits.\n\n.. versionadded:: 1.17.0\n\nbitorder : {'big', 'little'}, optional\nThe order of the returned bits. 'big' will mimic bin(val),\n``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse\nthe order to ``[1, 1, 0, 0, 0, 0, 0, 0]``.\nDefaults to 'big'.\n\n.. versionadded:: 1.17.0\n\nReturns\n-------\nunpacked : ndarray, uint8 type\nThe elements are binary-valued (0 or 1).\n\nSee Also\n--------\npackbits : Packs the elements of a binary-valued array into bits in\na uint8 array.\n\nExamples\n--------\n>>> a = np.array([[2], [7], [23]], dtype=np.uint8)\n>>> a\narray([[ 2],\n[ 7],\n[23]], dtype=uint8)\n>>> b = np.unpackbits(a, axis=1)\n>>> b\narray([[0, 0, 0, 0, 0, 0, 1, 0],\n[0, 0, 0, 0, 0, 1, 1, 1],\n[0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)\n>>> c = np.unpackbits(a, axis=1, count=-3)\n>>> c\narray([[0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0],\n[0, 0, 0, 1, 0]], dtype=uint8)\n\n>>> p = np.packbits(b, axis=0)\n>>> np.unpackbits(p, axis=0)\narray([[0, 0, 0, 0, 0, 0, 1, 0],\n[0, 0, 0, 0, 0, 1, 1, 1],\n[0, 0, 0, 1, 0, 1, 1, 1],\n[0, 0, 0, 0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0, 0, 0, 0],\n[0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)\n>>> np.arrayequal(b, np.unpackbits(p, axis=0, count=b.shape[0]))\nTrue\n" }, { "name": "unravel_index", "content": "unravelindex(indices, shape, order='C')\n\nConverts a flat index or array of flat indices into a tuple\nof coordinate arrays.\n\nParameters\n----------\nindices : arraylike\nAn integer array whose elements are indices into the flattened\nversion of an array of dimensions ``shape``. Before version 1.6.0,\nthis function accepted just one index value.\nshape : tuple of ints\nThe shape of the array to use for unraveling ``indices``.\n\n.. versionchanged:: 1.16.0\nRenamed from ``dims`` to ``shape``.\n\norder : {'C', 'F'}, optional\nDetermines whether the indices should be viewed as indexing in\nrow-major (C-style) or column-major (Fortran-style) order.\n\n.. versionadded:: 1.6.0\n\nReturns\n-------\nunraveledcoords : tuple of ndarray\nEach array in the tuple has the same shape as the ``indices``\narray.\n\nSee Also\n--------\nravelmultiindex\n\nExamples\n--------\n>>> np.unravelindex([22, 41, 37], (7,6))\n(array([3, 6, 6]), array([4, 5, 1]))\n>>> np.unravelindex([31, 41, 13], (7,6), order='F')\n(array([3, 6, 6]), array([4, 5, 1]))\n\n>>> np.unravelindex(1621, (6,7,8,9))\n(3, 1, 4, 1)\n" }, { "name": "unwrap", "content": "Unwrap by taking the complement of large deltas with respect to the period.\n\nThis unwraps a signal `p` by changing elements which have an absolute\ndifference from their predecessor of more than ``max(discont, period/2)``\nto their `period`-complementary values.\n\nFor the default case where `period` is :math:`2\\pi` and is `discont` is\n:math:`\\pi`, this unwraps a radian phase `p` such that adjacent differences\nare never greater than :math:`\\pi` by adding :math:`2k\\pi` for some\ninteger :math:`k`.\n\nParameters\n----------\np : arraylike\nInput array.\ndiscont : float, optional\nMaximum discontinuity between values, default is ``period/2``.\nValues below ``period/2`` are treated as if they were ``period/2``.\nTo have an effect different from the default, `discont` should be\nlarger than ``period/2``.\naxis : int, optional\nAxis along which unwrap will operate, default is the last axis.\nperiod: float, optional\nSize of the range over which the input wraps. By default, it is\n``2 pi``.\n\n.. versionadded:: 1.21.0\n\nReturns\n-------\nout : ndarray\nOutput array.\n\nSee Also\n--------\nrad2deg, deg2rad\n\nNotes\n-----\nIf the discontinuity in `p` is smaller than ``period/2``,\nbut larger than `discont`, no unwrapping is done because taking\nthe complement would only make the discontinuity larger.\n\nExamples\n--------\n>>> phase = np.linspace(0, np.pi, num=5)\n>>> phase[3:] += np.pi\n>>> phase\narray([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) # may vary\n>>> np.unwrap(phase)\narray([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) # may vary\n>>> np.unwrap([0, 1, 2, -1, 0], period=4)\narray([0, 1, 2, 3, 4])\n>>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6)\narray([1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4)\narray([2, 3, 4, 5, 6, 7, 8, 9])\n>>> phasedeg = np.mod(np.linspace(0 ,720, 19), 360) - 180\n>>> np.unwrap(phasedeg, period=360)\narray([-180., -140., -100., -60., -20., 20., 60., 100., 140.,\n180., 220., 260., 300., 340., 380., 420., 460., 500.,\n540.])\n" }, { "name": "vander", "content": "Generate a Vandermonde matrix.\n\nThe columns of the output matrix are powers of the input vector. The\norder of the powers is determined by the `increasing` boolean argument.\nSpecifically, when `increasing` is False, the `i`-th output column is\nthe input vector raised element-wise to the power of ``N - i - 1``. Such\na matrix with a geometric progression in each row is named for Alexandre-\nTheophile Vandermonde.\n\nParameters\n----------\nx : arraylike\n1-D input array.\nN : int, optional\nNumber of columns in the output. If `N` is not specified, a square\narray is returned (``N = len(x)``).\nincreasing : bool, optional\nOrder of the powers of the columns. If True, the powers increase\nfrom left to right, if False (the default) they are reversed.\n\n.. versionadded:: 1.9.0\n\nReturns\n-------\nout : ndarray\nVandermonde matrix. If `increasing` is False, the first column is\n``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is\nTrue, the columns are ``x^0, x^1, ..., x^(N-1)``.\n\nSee Also\n--------\npolynomial.polynomial.polyvander\n\nExamples\n--------\n>>> x = np.array([1, 2, 3, 5])\n>>> N = 3\n>>> np.vander(x, N)\narray([[ 1, 1, 1],\n[ 4, 2, 1],\n[ 9, 3, 1],\n[25, 5, 1]])\n\n>>> np.columnstack([x(N-1-i) for i in range(N)])\narray([[ 1, 1, 1],\n[ 4, 2, 1],\n[ 9, 3, 1],\n[25, 5, 1]])\n\n>>> x = np.array([1, 2, 3, 5])\n>>> np.vander(x)\narray([[ 1, 1, 1, 1],\n[ 8, 4, 2, 1],\n[ 27, 9, 3, 1],\n[125, 25, 5, 1]])\n>>> np.vander(x, increasing=True)\narray([[ 1, 1, 1, 1],\n[ 1, 2, 4, 8],\n[ 1, 3, 9, 27],\n[ 1, 5, 25, 125]])\n\nThe determinant of a square Vandermonde matrix is the product\nof the differences between the values of the input vector:\n\n>>> np.linalg.det(np.vander(x))\n48.000000000000043 # may vary\n>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)\n48\n" }, { "name": "var", "content": "Compute the variance along the specified axis.\n\nReturns the variance of the array elements, a measure of the spread of a\ndistribution. The variance is computed for the flattened array by\ndefault, otherwise over the specified axis.\n\nParameters\n----------\na : arraylike\nArray containing numbers whose variance is desired. If `a` is not an\narray, a conversion is attempted.\naxis : None or int or tuple of ints, optional\nAxis or axes along which the variance is computed. The default is to\ncompute the variance of the flattened array.\n\n.. versionadded:: 1.7.0\n\nIf this is a tuple of ints, a variance is performed over multiple axes,\ninstead of a single axis or all the axes as before.\ndtype : data-type, optional\nType to use in computing the variance. For arrays of integer type\nthe default is `float64`; for arrays of float types it is the same as\nthe array type.\nout : ndarray, optional\nAlternate output array in which to place the result. It must have\nthe same shape as the expected output, but the type is cast if\nnecessary.\nddof : int, optional\n\"Delta Degrees of Freedom\": the divisor used in the calculation is\n``N - ddof``, where ``N`` represents the number of elements. By\ndefault `ddof` is zero.\nkeepdims : bool, optional\nIf this is set to True, the axes which are reduced are left\nin the result as dimensions with size one. With this option,\nthe result will broadcast correctly against the input array.\n\nIf the default value is passed, then `keepdims` will not be\npassed through to the `var` method of sub-classes of\n`ndarray`, however any non-default value will be. If the\nsub-class' method does not implement `keepdims` any\nexceptions will be raised.\n\nwhere : arraylike of bool, optional\nElements to include in the variance. See `~numpy.ufunc.reduce` for\ndetails.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nvariance : ndarray, see dtype parameter above\nIf ``out=None``, returns a new array containing the variance;\notherwise, a reference to the output array is returned.\n\nSee Also\n--------\nstd, mean, nanmean, nanstd, nanvar\n:ref:`ufuncs-output-type`\n\nNotes\n-----\nThe variance is the average of the squared deviations from the mean,\ni.e., ``var = mean(x)``, where ``x = abs(a - a.mean())2``.\n\nThe mean is typically calculated as ``x.sum() / N``, where ``N = len(x)``.\nIf, however, `ddof` is specified, the divisor ``N - ddof`` is used\ninstead. In standard statistical practice, ``ddof=1`` provides an\nunbiased estimator of the variance of a hypothetical infinite population.\n``ddof=0`` provides a maximum likelihood estimate of the variance for\nnormally distributed variables.\n\nNote that for complex numbers, the absolute value is taken before\nsquaring, so that the result is always real and nonnegative.\n\nFor floating-point input, the variance is computed using the same\nprecision the input has. Depending on the input data, this can cause\nthe results to be inaccurate, especially for `float32` (see example\nbelow). Specifying a higher-accuracy accumulator using the ``dtype``\nkeyword can alleviate this issue.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, 4]])\n>>> np.var(a)\n1.25\n>>> np.var(a, axis=0)\narray([1., 1.])\n>>> np.var(a, axis=1)\narray([0.25, 0.25])\n\nIn single precision, var() can be inaccurate:\n\n>>> a = np.zeros((2, 512*512), dtype=np.float32)\n>>> a[0, :] = 1.0\n>>> a[1, :] = 0.1\n>>> np.var(a)\n0.20250003\n\nComputing the variance in float64 is more accurate:\n\n>>> np.var(a, dtype=np.float64)\n0.20249999932944759 # may vary\n>>> ((1-0.55)2 + (0.1-0.55)2)/2\n0.2025\n\nSpecifying a where argument:\n\n>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])\n>>> np.var(a)\n6.833333333333333 # may vary\n>>> np.var(a, where=[[True], [True], [False]])\n4.0\n" }, { "name": "vdot", "content": "vdot(a, b)\n\nReturn the dot product of two vectors.\n\nThe vdot(`a`, `b`) function handles complex numbers differently than\ndot(`a`, `b`). If the first argument is complex the complex conjugate\nof the first argument is used for the calculation of the dot product.\n\nNote that `vdot` handles multidimensional arrays differently than `dot`:\nit does *not* perform a matrix product, but flattens input arguments\nto 1-D vectors first. Consequently, it should only be used for vectors.\n\nParameters\n----------\na : arraylike\nIf `a` is complex the complex conjugate is taken before calculation\nof the dot product.\nb : arraylike\nSecond argument to the dot product.\n\nReturns\n-------\noutput : ndarray\nDot product of `a` and `b`. Can be an int, float, or\ncomplex depending on the types of `a` and `b`.\n\nSee Also\n--------\ndot : Return the dot product without using the complex conjugate of the\nfirst argument.\n\nExamples\n--------\n>>> a = np.array([1+2j,3+4j])\n>>> b = np.array([5+6j,7+8j])\n>>> np.vdot(a, b)\n(70-8j)\n>>> np.vdot(b, a)\n(70+8j)\n\nNote that higher-dimensional arrays are flattened!\n\n>>> a = np.array([[1, 4], [5, 6]])\n>>> b = np.array([[4, 1], [2, 2]])\n>>> np.vdot(a, b)\n30\n>>> np.vdot(b, a)\n30\n>>> 1*4 + 4*1 + 5*2 + 6*2\n30\n" }, { "name": "vsplit", "content": "Split an array into multiple sub-arrays vertically (row-wise).\n\nPlease refer to the ``split`` documentation. ``vsplit`` is equivalent\nto ``split`` with `axis=0` (default), the array is always split along the\nfirst axis regardless of the array dimension.\n\nSee Also\n--------\nsplit : Split an array into multiple sub-arrays of equal size.\n\nExamples\n--------\n>>> x = np.arange(16.0).reshape(4, 4)\n>>> x\narray([[ 0., 1., 2., 3.],\n[ 4., 5., 6., 7.],\n[ 8., 9., 10., 11.],\n[12., 13., 14., 15.]])\n>>> np.vsplit(x, 2)\n[array([[0., 1., 2., 3.],\n[4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.],\n[12., 13., 14., 15.]])]\n>>> np.vsplit(x, np.array([3, 6]))\n[array([[ 0., 1., 2., 3.],\n[ 4., 5., 6., 7.],\n[ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]\n\nWith a higher dimensional array the split is still along the first axis.\n\n>>> x = np.arange(8.0).reshape(2, 2, 2)\n>>> x\narray([[[0., 1.],\n[2., 3.]],\n[[4., 5.],\n[6., 7.]]])\n>>> np.vsplit(x, 2)\n[array([[[0., 1.],\n[2., 3.]]]), array([[[4., 5.],\n[6., 7.]]])]\n" }, { "name": "vstack", "content": "Stack arrays in sequence vertically (row wise).\n\nThis is equivalent to concatenation along the first axis after 1-D arrays\nof shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by\n`vsplit`.\n\nThis function makes most sense for arrays with up to 3 dimensions. For\ninstance, for pixel-data with a height (first axis), width (second axis),\nand r/g/b channels (third axis). The functions `concatenate`, `stack` and\n`block` provide more general stacking and concatenation operations.\n\nParameters\n----------\ntup : sequence of ndarrays\nThe arrays must have the same shape along all but the first axis.\n1-D arrays must have the same length.\n\nReturns\n-------\nstacked : ndarray\nThe array formed by stacking the given arrays, will be at least 2-D.\n\nSee Also\n--------\nconcatenate : Join a sequence of arrays along an existing axis.\nstack : Join a sequence of arrays along a new axis.\nblock : Assemble an nd-array from nested lists of blocks.\nhstack : Stack arrays in sequence horizontally (column wise).\ndstack : Stack arrays in sequence depth wise (along third axis).\ncolumnstack : Stack 1-D arrays as columns into a 2-D array.\nvsplit : Split an array into multiple sub-arrays vertically (row-wise).\n\nExamples\n--------\n>>> a = np.array([1, 2, 3])\n>>> b = np.array([4, 5, 6])\n>>> np.vstack((a,b))\narray([[1, 2, 3],\n[4, 5, 6]])\n\n>>> a = np.array([[1], [2], [3]])\n>>> b = np.array([[4], [5], [6]])\n>>> np.vstack((a,b))\narray([[1],\n[2],\n[3],\n[4],\n[5],\n[6]])\n" }, { "name": "where", "content": "where(condition, [x, y])\n\nReturn elements chosen from `x` or `y` depending on `condition`.\n\n.. note::\nWhen only `condition` is provided, this function is a shorthand for\n``np.asarray(condition).nonzero()``. Using `nonzero` directly should be\npreferred, as it behaves correctly for subclasses. The rest of this\ndocumentation covers only the case where all three arguments are\nprovided.\n\nParameters\n----------\ncondition : arraylike, bool\nWhere True, yield `x`, otherwise yield `y`.\nx, y : arraylike\nValues from which to choose. `x`, `y` and `condition` need to be\nbroadcastable to some shape.\n\nReturns\n-------\nout : ndarray\nAn array with elements from `x` where `condition` is True, and elements\nfrom `y` elsewhere.\n\nSee Also\n--------\nchoose\nnonzero : The function that is called when x and y are omitted\n\nNotes\n-----\nIf all the arrays are 1-D, `where` is equivalent to::\n\n[xv if c else yv\nfor c, xv, yv in zip(condition, x, y)]\n\nExamples\n--------\n>>> a = np.arange(10)\n>>> a\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n>>> np.where(a < 5, a, 10*a)\narray([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])\n\nThis can be used on multidimensional arrays too:\n\n>>> np.where([[True, False], [True, True]],\n... [[1, 2], [3, 4]],\n... [[9, 8], [7, 6]])\narray([[1, 8],\n[3, 4]])\n\nThe shapes of x, y, and the condition are broadcast together:\n\n>>> x, y = np.ogrid[:3, :4]\n>>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast\narray([[10, 0, 0, 0],\n[10, 11, 1, 1],\n[10, 11, 12, 2]])\n\n>>> a = np.array([[0, 1, 2],\n... [0, 2, 4],\n... [0, 3, 6]])\n>>> np.where(a < 4, a, -1) # -1 is broadcast\narray([[ 0, 1, 2],\n[ 0, 2, -1],\n[ 0, 3, -1]])\n" }, { "name": "who", "content": "Print the NumPy arrays in the given dictionary.\n\nIf there is no dictionary passed in or `vardict` is None then returns\nNumPy arrays in the globals() dictionary (all NumPy arrays in the\nnamespace).\n\nParameters\n----------\nvardict : dict, optional\nA dictionary possibly containing ndarrays. Default is globals().\n\nReturns\n-------\nout : None\nReturns 'None'.\n\nNotes\n-----\nPrints out the name, shape, bytes and type of all of the ndarrays\npresent in `vardict`.\n\nExamples\n--------\n>>> a = np.arange(10)\n>>> b = np.ones(20)\n>>> np.who()\nName Shape Bytes Type\n===========================================================\na 10 80 int64\nb 20 160 float64\nUpper bound on total bytes = 240\n\n>>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',\n... 'idx':5}\n>>> np.who(d)\nName Shape Bytes Type\n===========================================================\nx 2 16 float64\ny 3 24 float64\nUpper bound on total bytes = 40\n" }, { "name": "zeros", "content": "zeros(shape, dtype=float, order='C', *, like=None)\n\nReturn a new array of given shape and type, filled with zeros.\n\nParameters\n----------\nshape : int or tuple of ints\nShape of the new array, e.g., ``(2, 3)`` or ``2``.\ndtype : data-type, optional\nThe desired data-type for the array, e.g., `numpy.int8`. Default is\n`numpy.float64`.\norder : {'C', 'F'}, optional, default: 'C'\nWhether to store multi-dimensional data in row-major\n(C-style) or column-major (Fortran-style) order in\nmemory.\nlike : arraylike\nReference object to allow the creation of arrays which are not\nNumPy arrays. If an array-like passed in as ``like`` supports\nthe ``arrayfunction`` protocol, the result will be defined\nby it. In this case, it ensures the creation of an array object\ncompatible with that passed in via this argument.\n\n.. versionadded:: 1.20.0\n\nReturns\n-------\nout : ndarray\nArray of zeros with the given shape, dtype, and order.\n\nSee Also\n--------\nzeroslike : Return an array of zeros with shape and type of input.\nempty : Return a new uninitialized array.\nones : Return a new array setting values to one.\nfull : Return a new array of given shape filled with value.\n\nExamples\n--------\n>>> np.zeros(5)\narray([ 0., 0., 0., 0., 0.])\n\n>>> np.zeros((5,), dtype=int)\narray([0, 0, 0, 0, 0])\n\n>>> np.zeros((2, 1))\narray([[ 0.],\n[ 0.]])\n\n>>> s = (2,2)\n>>> np.zeros(s)\narray([[ 0., 0.],\n[ 0., 0.]])\n\n>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype\narray([(0, 0), (0, 0)],\ndtype=[('x', '>> x = np.arange(6)\n>>> x = x.reshape((2, 3))\n>>> x\narray([[0, 1, 2],\n[3, 4, 5]])\n>>> np.zeroslike(x)\narray([[0, 0, 0],\n[0, 0, 0]])\n\n>>> y = np.arange(3, dtype=float)\n>>> y\narray([0., 1., 2.])\n>>> np.zeroslike(y)\narray([0., 0., 0.])\n" } ] }, "DATA": { "content": "ALLOWTHREADS = 1\nBUFSIZE = 8192\nCLIP = 0\nERRCALL = 3\nERRDEFAULT = 521\nERRIGNORE = 0\nERRLOG = 5\nERRPRINT = 4\nERRRAISE = 2\nERRWARN = 1\nFLOATINGPOINTSUPPORT = 1\nFPEDIVIDEBYZERO = 1\nFPEINVALID = 8\nFPEOVERFLOW = 2\nFPEUNDERFLOW = 4\nFalse = False\nInf = inf\nInfinity = inf\nMAXDIMS = 32\nMAYSHAREBOUNDS = 0\nMAYSHAREEXACT = -1\nNAN = nan\nNINF = -inf\nNZERO = -0.0\nNaN = nan\nPINF = inf\nPZERO = 0.0\nRAISE = 2\nSHIFTDIVIDEBYZERO = 0\nSHIFTINVALID = 9\nSHIFTOVERFLOW = 3\nSHIFTUNDERFLOW = 6\nScalarType = (, , , \nNUMPYSETUP = False\nall = ['ModuleDeprecationWarning', 'VisibleDeprecationWarning', '...\ndeprecatedattrs = {'bool': (, '`np.bool` is a depre...\nexpiredfunctions = {'fv': 'In accordance with NEP 32, the functio...\ngitversion = 'c3d0a09342c08c466984654bc4738af595fba896'\nabsolute = \nabsolute(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCalculate the absolute value element-wise.\n\n``np.abs`` is a shorthand for this function.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nabsolute : ndarray\nAn ndarray containing the absolute value of\neach element in `x`. For complex input, ``a + ib``, the\nabsolute value is :math:`\\sqrt{ a^2 + b^2 }`.\nThis is a scalar if `x` is a scalar.\n\nExamples\n--------\n>>> x = np.array([-1.2, 1.2])\n>>> np.absolute(x)\narray([ 1.2, 1.2])\n>>> np.absolute(1.2 + 1j)\n1.5620499351813308\n\nPlot the function over ``[-10, 10]``:\n\n>>> import matplotlib.pyplot as plt\n\n>>> x = np.linspace(start=-10, stop=10, num=101)\n>>> plt.plot(x, np.absolute(x))\n>>> plt.show()\n\nPlot the function over the complex plane:\n\n>>> xx = x + 1j * x[:, np.newaxis]\n>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')\n>>> plt.show()\n\nThe `abs` function can be used as a shorthand for ``np.absolute`` on\nndarrays.\n\n>>> x = np.array([-1.2, 1.2])\n>>> abs(x)\narray([1.2, 1.2])\n\nadd = \nadd(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nAdd arguments element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nThe arrays to be added.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nadd : ndarray or scalar\nThe sum of `x1` and `x2`, element-wise.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nNotes\n-----\nEquivalent to `x1` + `x2` in terms of array broadcasting.\n\nExamples\n--------\n>>> np.add(1.0, 4.0)\n5.0\n>>> x1 = np.arange(9.0).reshape((3, 3))\n>>> x2 = np.arange(3.0)\n>>> np.add(x1, x2)\narray([[ 0., 2., 4.],\n[ 3., 5., 7.],\n[ 6., 8., 10.]])\n\nThe ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays.\n\n>>> x1 = np.arange(9.0).reshape((3, 3))\n>>> x2 = np.arange(3.0)\n>>> x1 + x2\narray([[ 0., 2., 4.],\n[ 3., 5., 7.],\n[ 6., 8., 10.]])\n\narccos = \narccos(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nTrigonometric inverse cosine, element-wise.\n\nThe inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``.\n\nParameters\n----------\nx : arraylike\n`x`-coordinate on the unit circle.\nFor real arguments, the domain is [-1, 1].\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nangle : ndarray\nThe angle of the ray intersecting the unit circle at the given\n`x`-coordinate in radians [0, pi].\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\ncos, arctan, arcsin, emath.arccos\n\nNotes\n-----\n`arccos` is a multivalued function: for each `x` there are infinitely\nmany numbers `z` such that ``cos(z) = x``. The convention is to return\nthe angle `z` whose real part lies in `[0, pi]`.\n\nFor real-valued input data types, `arccos` always returns real output.\nFor each value that cannot be expressed as a real number or infinity,\nit yields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `arccos` is a complex analytic function that\nhas branch cuts ``[-inf, -1]`` and `[1, inf]` and is continuous from\nabove on the former and from below on the latter.\n\nThe inverse `cos` is also known as `acos` or cos^-1.\n\nReferences\n----------\nM. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",\n10th printing, 1964, pp. 79. http://www.math.sfu.ca/~cbm/aands/\n\nExamples\n--------\nWe expect the arccos of 1 to be 0, and of -1 to be pi:\n\n>>> np.arccos([1, -1])\narray([ 0. , 3.14159265])\n\nPlot arccos:\n\n>>> import matplotlib.pyplot as plt\n>>> x = np.linspace(-1, 1, num=100)\n>>> plt.plot(x, np.arccos(x))\n>>> plt.axis('tight')\n>>> plt.show()\n\narccosh = \narccosh(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nInverse hyperbolic cosine, element-wise.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\narccosh : ndarray\nArray of the same shape as `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\n\ncosh, arcsinh, sinh, arctanh, tanh\n\nNotes\n-----\n`arccosh` is a multivalued function: for each `x` there are infinitely\nmany numbers `z` such that `cosh(z) = x`. The convention is to return the\n`z` whose imaginary part lies in ``[-pi, pi]`` and the real part in\n``[0, inf]``.\n\nFor real-valued input data types, `arccosh` always returns real output.\nFor each value that cannot be expressed as a real number or infinity, it\nyields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `arccosh` is a complex analytical function that\nhas a branch cut `[-inf, 1]` and is continuous from above on it.\n\nReferences\n----------\n.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",\n10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/\n.. [2] Wikipedia, \"Inverse hyperbolic function\",\nhttps://en.wikipedia.org/wiki/Arccosh\n\nExamples\n--------\n>>> np.arccosh([np.e, 10.0])\narray([ 1.65745445, 2.99322285])\n>>> np.arccosh(1)\n0.0\n\narcsin = \narcsin(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nInverse sine, element-wise.\n\nParameters\n----------\nx : arraylike\n`y`-coordinate on the unit circle.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nangle : ndarray\nThe inverse sine of each element in `x`, in radians and in the\nclosed interval ``[-pi/2, pi/2]``.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nsin, cos, arccos, tan, arctan, arctan2, emath.arcsin\n\nNotes\n-----\n`arcsin` is a multivalued function: for each `x` there are infinitely\nmany numbers `z` such that :math:`sin(z) = x`. The convention is to\nreturn the angle `z` whose real part lies in [-pi/2, pi/2].\n\nFor real-valued input data types, *arcsin* always returns real output.\nFor each value that cannot be expressed as a real number or infinity,\nit yields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `arcsin` is a complex analytic function that\nhas, by convention, the branch cuts [-inf, -1] and [1, inf] and is\ncontinuous from above on the former and from below on the latter.\n\nThe inverse sine is also known as `asin` or sin^{-1}.\n\nReferences\n----------\nAbramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,\n10th printing, New York: Dover, 1964, pp. 79ff.\nhttp://www.math.sfu.ca/~cbm/aands/\n\nExamples\n--------\n>>> np.arcsin(1) # pi/2\n1.5707963267948966\n>>> np.arcsin(-1) # -pi/2\n-1.5707963267948966\n>>> np.arcsin(0)\n0.0\n\narcsinh = \narcsinh(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nInverse hyperbolic sine element-wise.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nArray of the same shape as `x`.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\n`arcsinh` is a multivalued function: for each `x` there are infinitely\nmany numbers `z` such that `sinh(z) = x`. The convention is to return the\n`z` whose imaginary part lies in `[-pi/2, pi/2]`.\n\nFor real-valued input data types, `arcsinh` always returns real output.\nFor each value that cannot be expressed as a real number or infinity, it\nreturns ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `arccos` is a complex analytical function that\nhas branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from\nthe right on the former and from the left on the latter.\n\nThe inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``.\n\nReferences\n----------\n.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",\n10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/\n.. [2] Wikipedia, \"Inverse hyperbolic function\",\nhttps://en.wikipedia.org/wiki/Arcsinh\n\nExamples\n--------\n>>> np.arcsinh(np.array([np.e, 10.0]))\narray([ 1.72538256, 2.99822295])\n\narctan = \narctan(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nTrigonometric inverse tangent, element-wise.\n\nThe inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``.\n\nParameters\n----------\nx : arraylike\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOut has the same shape as `x`. Its real part is in\n``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\narctan2 : The \"four quadrant\" arctan of the angle formed by (`x`, `y`)\nand the positive `x`-axis.\nangle : Argument of complex values.\n\nNotes\n-----\n`arctan` is a multi-valued function: for each `x` there are infinitely\nmany numbers `z` such that tan(`z`) = `x`. The convention is to return\nthe angle `z` whose real part lies in [-pi/2, pi/2].\n\nFor real-valued input data types, `arctan` always returns real output.\nFor each value that cannot be expressed as a real number or infinity,\nit yields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `arctan` is a complex analytic function that\nhas [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous\nfrom the left on the former and from the right on the latter.\n\nThe inverse tangent is also known as `atan` or tan^{-1}.\n\nReferences\n----------\nAbramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,\n10th printing, New York: Dover, 1964, pp. 79.\nhttp://www.math.sfu.ca/~cbm/aands/\n\nExamples\n--------\nWe expect the arctan of 0 to be 0, and of 1 to be pi/4:\n\n>>> np.arctan([0, 1])\narray([ 0. , 0.78539816])\n\n>>> np.pi/4\n0.78539816339744828\n\nPlot arctan:\n\n>>> import matplotlib.pyplot as plt\n>>> x = np.linspace(-10, 10)\n>>> plt.plot(x, np.arctan(x))\n>>> plt.axis('tight')\n>>> plt.show()\n\narctan2 = \narctan2(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nElement-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.\n\nThe quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is\nthe signed angle in radians between the ray ending at the origin and\npassing through the point (1,0), and the ray ending at the origin and\npassing through the point (`x2`, `x1`). (Note the role reversal: the\n\"`y`-coordinate\" is the first function parameter, the \"`x`-coordinate\"\nis the second.) By IEEE convention, this function is defined for\n`x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see\nNotes for specific values).\n\nThis function is not defined for complex-valued arguments; for the\nso-called argument of complex values, use `angle`.\n\nParameters\n----------\nx1 : arraylike, real-valued\n`y`-coordinates.\nx2 : arraylike, real-valued\n`x`-coordinates.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nangle : ndarray\nArray of angles in radians, in the range ``[-pi, pi]``.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\narctan, tan, angle\n\nNotes\n-----\n*arctan2* is identical to the `atan2` function of the underlying\nC library. The following special values are defined in the C\nstandard: [1]\n\n====== ====== ================\n`x1` `x2` `arctan2(x1,x2)`\n====== ====== ================\n+/- 0 +0 +/- 0\n+/- 0 -0 +/- pi\n> 0 +/-inf +0 / +pi\n< 0 +/-inf -0 / -pi\n+/-inf +inf +/- (pi/4)\n+/-inf -inf +/- (3*pi/4)\n====== ====== ================\n\nNote that +0 and -0 are distinct floating point numbers, as are +inf\nand -inf.\n\nReferences\n----------\n.. [1] ISO/IEC standard 9899:1999, \"Programming language C.\"\n\nExamples\n--------\nConsider four points in different quadrants:\n\n>>> x = np.array([-1, +1, +1, -1])\n>>> y = np.array([-1, -1, +1, +1])\n>>> np.arctan2(y, x) * 180 / np.pi\narray([-135., -45., 45., 135.])\n\nNote the order of the parameters. `arctan2` is defined also when `x2` = 0\nand at several other special points, obtaining values in\nthe range ``[-pi, pi]``:\n\n>>> np.arctan2([1., -1.], [0., 0.])\narray([ 1.57079633, -1.57079633])\n>>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])\narray([ 0. , 3.14159265, 0.78539816])\n\narctanh = \narctanh(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nInverse hyperbolic tangent element-wise.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nArray of the same shape as `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nemath.arctanh\n\nNotes\n-----\n`arctanh` is a multivalued function: for each `x` there are infinitely\nmany numbers `z` such that ``tanh(z) = x``. The convention is to return\nthe `z` whose imaginary part lies in `[-pi/2, pi/2]`.\n\nFor real-valued input data types, `arctanh` always returns real output.\nFor each value that cannot be expressed as a real number or infinity,\nit yields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `arctanh` is a complex analytical function\nthat has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from\nabove on the former and from below on the latter.\n\nThe inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.\n\nReferences\n----------\n.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",\n10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/\n.. [2] Wikipedia, \"Inverse hyperbolic function\",\nhttps://en.wikipedia.org/wiki/Arctanh\n\nExamples\n--------\n>>> np.arctanh([0, -0.5])\narray([ 0. , -0.54930614])\n\nbitwiseand = \nbitwiseand(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the bit-wise AND of two arrays element-wise.\n\nComputes the bit-wise AND of the underlying binary representation of\nthe integers in the input arrays. This ufunc implements the C/Python\noperator ``&``.\n\nParameters\n----------\nx1, x2 : arraylike\nOnly integer and boolean types are handled.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nResult.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogicaland\nbitwiseor\nbitwisexor\nbinaryrepr :\nReturn the binary representation of the input number as a string.\n\nExamples\n--------\nThe number 13 is represented by ``00001101``. Likewise, 17 is\nrepresented by ``00010001``. The bit-wise AND of 13 and 17 is\ntherefore ``000000001``, or 1:\n\n>>> np.bitwiseand(13, 17)\n1\n\n>>> np.bitwiseand(14, 13)\n12\n>>> np.binaryrepr(12)\n'1100'\n>>> np.bitwiseand([14,3], 13)\narray([12, 1])\n\n>>> np.bitwiseand([11,7], [4,25])\narray([0, 1])\n>>> np.bitwiseand(np.array([2,5,255]), np.array([3,14,16]))\narray([ 2, 4, 16])\n>>> np.bitwiseand([True, True], [False, True])\narray([False, True])\n\nThe ``&`` operator can be used as a shorthand for ``np.bitwiseand`` on\nndarrays.\n\n>>> x1 = np.array([2, 5, 255])\n>>> x2 = np.array([3, 14, 16])\n>>> x1 & x2\narray([ 2, 4, 16])\n\nbitwisenot = \ninvert(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute bit-wise inversion, or bit-wise NOT, element-wise.\n\nComputes the bit-wise NOT of the underlying binary representation of\nthe integers in the input arrays. This ufunc implements the C/Python\noperator ``~``.\n\nFor signed integer inputs, the two's complement is returned. In a\ntwo's-complement system negative numbers are represented by the two's\ncomplement of the absolute value. This is the most common method of\nrepresenting signed integers on computers [1]. A N-bit\ntwo's-complement system can represent every integer in the range\n:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.\n\nParameters\n----------\nx : arraylike\nOnly integer and boolean types are handled.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nResult.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nbitwiseand, bitwiseor, bitwisexor\nlogicalnot\nbinaryrepr :\nReturn the binary representation of the input number as a string.\n\nNotes\n-----\n`bitwisenot` is an alias for `invert`:\n\n>>> np.bitwisenot is np.invert\nTrue\n\nReferences\n----------\n.. [1] Wikipedia, \"Two's complement\",\nhttps://en.wikipedia.org/wiki/Two'scomplement\n\nExamples\n--------\nWe've seen that 13 is represented by ``00001101``.\nThe invert or bit-wise NOT of 13 is then:\n\n>>> x = np.invert(np.array(13, dtype=np.uint8))\n>>> x\n242\n>>> np.binaryrepr(x, width=8)\n'11110010'\n\nThe result depends on the bit-width:\n\n>>> x = np.invert(np.array(13, dtype=np.uint16))\n>>> x\n65522\n>>> np.binaryrepr(x, width=16)\n'1111111111110010'\n\nWhen using signed integer types the result is the two's complement of\nthe result for the unsigned type:\n\n>>> np.invert(np.array([13], dtype=np.int8))\narray([-14], dtype=int8)\n>>> np.binaryrepr(-14, width=8)\n'11110010'\n\nBooleans are accepted as well:\n\n>>> np.invert(np.array([True, False]))\narray([False, True])\n\nThe ``~`` operator can be used as a shorthand for ``np.invert`` on\nndarrays.\n\n>>> x1 = np.array([True, False])\n>>> ~x1\narray([False, True])\n\nbitwiseor = \nbitwiseor(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the bit-wise OR of two arrays element-wise.\n\nComputes the bit-wise OR of the underlying binary representation of\nthe integers in the input arrays. This ufunc implements the C/Python\noperator ``|``.\n\nParameters\n----------\nx1, x2 : arraylike\nOnly integer and boolean types are handled.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nResult.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogicalor\nbitwiseand\nbitwisexor\nbinaryrepr :\nReturn the binary representation of the input number as a string.\n\nExamples\n--------\nThe number 13 has the binaray representation ``00001101``. Likewise,\n16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is\nthen ``000111011``, or 29:\n\n>>> np.bitwiseor(13, 16)\n29\n>>> np.binaryrepr(29)\n'11101'\n\n>>> np.bitwiseor(32, 2)\n34\n>>> np.bitwiseor([33, 4], 1)\narray([33, 5])\n>>> np.bitwiseor([33, 4], [1, 2])\narray([33, 6])\n\n>>> np.bitwiseor(np.array([2, 5, 255]), np.array([4, 4, 4]))\narray([ 6, 5, 255])\n>>> np.array([2, 5, 255]) | np.array([4, 4, 4])\narray([ 6, 5, 255])\n>>> np.bitwiseor(np.array([2, 5, 255, 2147483647], dtype=np.int32),\n... np.array([4, 4, 4, 2147483647], dtype=np.int32))\narray([ 6, 5, 255, 2147483647])\n>>> np.bitwiseor([True, True], [False, True])\narray([ True, True])\n\nThe ``|`` operator can be used as a shorthand for ``np.bitwiseor`` on\nndarrays.\n\n>>> x1 = np.array([2, 5, 255])\n>>> x2 = np.array([4, 4, 4])\n>>> x1 | x2\narray([ 6, 5, 255])\n\nbitwisexor = \nbitwisexor(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the bit-wise XOR of two arrays element-wise.\n\nComputes the bit-wise XOR of the underlying binary representation of\nthe integers in the input arrays. This ufunc implements the C/Python\noperator ``^``.\n\nParameters\n----------\nx1, x2 : arraylike\nOnly integer and boolean types are handled.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nResult.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogicalxor\nbitwiseand\nbitwiseor\nbinaryrepr :\nReturn the binary representation of the input number as a string.\n\nExamples\n--------\nThe number 13 is represented by ``00001101``. Likewise, 17 is\nrepresented by ``00010001``. The bit-wise XOR of 13 and 17 is\ntherefore ``00011100``, or 28:\n\n>>> np.bitwisexor(13, 17)\n28\n>>> np.binaryrepr(28)\n'11100'\n\n>>> np.bitwisexor(31, 5)\n26\n>>> np.bitwisexor([31,3], 5)\narray([26, 6])\n\n>>> np.bitwisexor([31,3], [5,6])\narray([26, 5])\n>>> np.bitwisexor([True, True], [False, True])\narray([ True, False])\n\nThe ``^`` operator can be used as a shorthand for ``np.bitwisexor`` on\nndarrays.\n\n>>> x1 = np.array([True, True])\n>>> x2 = np.array([False, True])\n>>> x1 ^ x2\narray([ True, False])\n\nc = \ncast = {: at 0...y.int16'>: <...\ncbrt = \ncbrt(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the cube-root of an array, element-wise.\n\n.. versionadded:: 1.10.0\n\nParameters\n----------\nx : arraylike\nThe values whose cube-roots are required.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nAn array of the same shape as `x`, containing the cube\ncube-root of each element in `x`.\nIf `out` was provided, `y` is a reference to it.\nThis is a scalar if `x` is a scalar.\n\n\nExamples\n--------\n>>> np.cbrt([1,8,27])\narray([ 1., 2., 3.])\n\nceil = \nceil(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the ceiling of the input, element-wise.\n\nThe ceil of the scalar `x` is the smallest integer `i`, such that\n``i >= x``. It is often denoted as :math:`\\lceil x \\rceil`.\n\nParameters\n----------\nx : arraylike\nInput data.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe ceiling of each element in `x`, with `float` dtype.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nfloor, trunc, rint, fix\n\nExamples\n--------\n>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])\n>>> np.ceil(a)\narray([-1., -1., -0., 1., 2., 2., 2.])\n\nconj = \nconjugate(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the complex conjugate, element-wise.\n\nThe complex conjugate of a complex number is obtained by changing the\nsign of its imaginary part.\n\nParameters\n----------\nx : arraylike\nInput value.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe complex conjugate of `x`, with same dtype as `y`.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\n`conj` is an alias for `conjugate`:\n\n>>> np.conj is np.conjugate\nTrue\n\nExamples\n--------\n>>> np.conjugate(1+2j)\n(1-2j)\n\n>>> x = np.eye(2) + 1j * np.eye(2)\n>>> np.conjugate(x)\narray([[ 1.-1.j, 0.-0.j],\n[ 0.-0.j, 1.-1.j]])\n\nconjugate = \nconjugate(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the complex conjugate, element-wise.\n\nThe complex conjugate of a complex number is obtained by changing the\nsign of its imaginary part.\n\nParameters\n----------\nx : arraylike\nInput value.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe complex conjugate of `x`, with same dtype as `y`.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\n`conj` is an alias for `conjugate`:\n\n>>> np.conj is np.conjugate\nTrue\n\nExamples\n--------\n>>> np.conjugate(1+2j)\n(1-2j)\n\n>>> x = np.eye(2) + 1j * np.eye(2)\n>>> np.conjugate(x)\narray([[ 1.-1.j, 0.-0.j],\n[ 0.-0.j, 1.-1.j]])\n\ncopysign = \ncopysign(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nChange the sign of x1 to that of x2, element-wise.\n\nIf `x2` is a scalar, its sign will be copied to all elements of `x1`.\n\nParameters\n----------\nx1 : arraylike\nValues to change the sign of.\nx2 : arraylike\nThe sign of `x2` is copied to `x1`.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nThe values of `x1` with the sign of `x2`.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nExamples\n--------\n>>> np.copysign(1.3, -1)\n-1.3\n>>> 1/np.copysign(0, 1)\ninf\n>>> 1/np.copysign(0, -1)", "subsections": [ { "name": "-inf", "content": ">>> np.copysign([-1, 0, 1], -1.1)\narray([-1., -0., -1.])\n>>> np.copysign([-1, 0, 1], np.arange(3)-1)\narray([-1., 0., 1.])\n\ncos = \ncos(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCosine element-wise.\n\nParameters\n----------\nx : arraylike\nInput array in radians.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe corresponding cosine values.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nIf `out` is provided, the function writes the result into it,\nand returns a reference to `out`. (See Examples)\n\nReferences\n----------\nM. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.\nNew York, NY: Dover, 1972.\n\nExamples\n--------\n>>> np.cos(np.array([0, np.pi/2, np.pi]))\narray([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00])\n>>>\n>>> # Example of providing the optional output parameter\n>>> out1 = np.array([0], dtype='d')\n>>> out2 = np.cos([0.1], out1)\n>>> out2 is out1\nTrue\n>>>\n>>> # Example of ValueError due to provision of shape mis-matched `out`\n>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))\nTraceback (most recent call last):\nFile \"\", line 1, in \nValueError: operands could not be broadcast together with shapes (3,3) (2,2)\n\ncosh = \ncosh(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nHyperbolic cosine, element-wise.\n\nEquivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array of same shape as `x`.\nThis is a scalar if `x` is a scalar.\n\nExamples\n--------\n>>> np.cosh(0)\n1.0\n\nThe hyperbolic cosine describes the shape of a hanging cable:\n\n>>> import matplotlib.pyplot as plt\n>>> x = np.linspace(-4, 4, 1000)\n>>> plt.plot(x, np.cosh(x))\n>>> plt.show()\n\ndeg2rad = \ndeg2rad(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nConvert angles from degrees to radians.\n\nParameters\n----------\nx : arraylike\nAngles in degrees.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe corresponding angle in radians.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nrad2deg : Convert angles from radians to degrees.\nunwrap : Remove large jumps in angle by wrapping.\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\n``deg2rad(x)`` is ``x * pi / 180``.\n\nExamples\n--------\n>>> np.deg2rad(180)\n3.1415926535897931\n\ndegrees = \ndegrees(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nConvert angles from radians to degrees.\n\nParameters\n----------\nx : arraylike\nInput array in radians.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray of floats\nThe corresponding degree values; if `out` was supplied this is a\nreference to it.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nrad2deg : equivalent function\n\nExamples\n--------\nConvert a radian array to degrees\n\n>>> rad = np.arange(12.)*np.pi/6\n>>> np.degrees(rad)\narray([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,\n270., 300., 330.])\n\n>>> out = np.zeros((rad.shape))\n>>> r = np.degrees(rad, out)\n>>> np.all(r == out)\nTrue\n\ndivide = \ntruedivide(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturns a true division of the inputs, element-wise.\n\nInstead of the Python traditional 'floor division', this returns a true\ndivision. True division adjusts the output type to present the best\nanswer, regardless of input types.\n\nParameters\n----------\nx1 : arraylike\nDividend array.\nx2 : arraylike\nDivisor array.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nThis is a scalar if both `x1` and `x2` are scalars.\n\nNotes\n-----\nIn Python, ``//`` is the floor division operator and ``/`` the\ntrue division operator. The ``truedivide(x1, x2)`` function is\nequivalent to true division in Python.\n\nExamples\n--------\n>>> x = np.arange(5)\n>>> np.truedivide(x, 4)\narray([ 0. , 0.25, 0.5 , 0.75, 1. ])\n\n>>> x/4\narray([ 0. , 0.25, 0.5 , 0.75, 1. ])\n\n>>> x//4\narray([0, 0, 0, 0, 1])\n\nThe ``/`` operator can be used as a shorthand for ``np.truedivide`` on\nndarrays.\n\n>>> x = np.arange(5)\n>>> x / 4\narray([0. , 0.25, 0.5 , 0.75, 1. ])\n\ndivmod = \ndivmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn element-wise quotient and remainder simultaneously.\n\n.. versionadded:: 1.13.0\n\n``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster\nbecause it avoids redundant work. It is used to implement the Python\nbuilt-in function ``divmod`` on NumPy arrays.\n\nParameters\n----------\nx1 : arraylike\nDividend array.\nx2 : arraylike\nDivisor array.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout1 : ndarray\nElement-wise quotient resulting from floor division.\nThis is a scalar if both `x1` and `x2` are scalars.\nout2 : ndarray\nElement-wise remainder from floor division.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nfloordivide : Equivalent to Python's ``//`` operator.\nremainder : Equivalent to Python's ``%`` operator.\nmodf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return\nvalues switched.\n\nExamples\n--------\n>>> np.divmod(np.arange(5), 3)\n(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))\n\nThe `divmod` function can be used as a shorthand for ``np.divmod`` on\nndarrays.\n\n>>> x = np.arange(5)\n>>> divmod(x, 3)\n(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))\n\ne = 2.718281828459045\nequal = \nequal(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn (x1 == x2) element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array, element-wise comparison of `x1` and `x2`.\nTypically of type bool, unless ``dtype=object`` is passed.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nnotequal, greaterequal, lessequal, greater, less\n\nExamples\n--------\n>>> np.equal([0, 1, 3], np.arange(3))\narray([ True, True, False])\n\nWhat is compared are values, not types. So an int (1) and an array of\nlength one can evaluate as True:\n\n>>> np.equal(1, np.ones(1))\narray([ True])\n\nThe ``==`` operator can be used as a shorthand for ``np.equal`` on\nndarrays.\n\n>>> a = np.array([2, 4, 6])\n>>> b = np.array([2, 4, 2])\n>>> a == b\narray([ True, True, False])\n\neulergamma = 0.5772156649015329\nexp = \nexp(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCalculate the exponential of all elements in the input array.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array, element-wise exponential of `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nexpm1 : Calculate ``exp(x) - 1`` for all elements in the array.\nexp2 : Calculate ``2x`` for all elements in the array.\n\nNotes\n-----\nThe irrational number ``e`` is also known as Euler's number. It is\napproximately 2.718281, and is the base of the natural logarithm,\n``ln`` (this means that, if :math:`x = \\ln y = \\loge y`,\nthen :math:`e^x = y`. For real input, ``exp(x)`` is always positive.\n\nFor complex arguments, ``x = a + ib``, we can write\n:math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already\nknown (it is the real argument, described above). The second term,\n:math:`e^{ib}`, is :math:`\\cos b + i \\sin b`, a function with\nmagnitude 1 and a periodic phase.\n\nReferences\n----------\n.. [1] Wikipedia, \"Exponential function\",\nhttps://en.wikipedia.org/wiki/Exponentialfunction\n.. [2] M. Abramovitz and I. A. Stegun, \"Handbook of Mathematical Functions\nwith Formulas, Graphs, and Mathematical Tables,\" Dover, 1964, p. 69,\nhttp://www.math.sfu.ca/~cbm/aands/page69.htm\n\nExamples\n--------\nPlot the magnitude and phase of ``exp(x)`` in the complex plane:\n\n>>> import matplotlib.pyplot as plt\n\n>>> x = np.linspace(-2*np.pi, 2*np.pi, 100)\n>>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane\n>>> out = np.exp(xx)\n\n>>> plt.subplot(121)\n>>> plt.imshow(np.abs(out),\n... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')\n>>> plt.title('Magnitude of exp(x)')\n\n>>> plt.subplot(122)\n>>> plt.imshow(np.angle(out),\n... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv')\n>>> plt.title('Phase (angle) of exp(x)')\n>>> plt.show()\n\nexp2 = \nexp2(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCalculate `2p` for all `p` in the input array.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nElement-wise 2 to the power `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\npower\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\n\n\nExamples\n--------\n>>> np.exp2([2, 3])\narray([ 4., 8.])\n\nexpm1 = \nexpm1(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCalculate ``exp(x) - 1`` for all elements in the array.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nElement-wise exponential minus one: ``out = exp(x) - 1``.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nlog1p : ``log(1 + x)``, the inverse of expm1.\n\n\nNotes\n-----\nThis function provides greater precision than ``exp(x) - 1``\nfor small values of ``x``.\n\nExamples\n--------\nThe true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to\nabout 32 significant digits. This example shows the superiority of\nexpm1 in this case.\n\n>>> np.expm1(1e-10)\n1.00000000005e-10\n>>> np.exp(1e-10) - 1\n1.000000082740371e-10\n\nfabs = \nfabs(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the absolute values element-wise.\n\nThis function returns the absolute values (positive magnitude) of the\ndata in `x`. Complex values are not handled, use `absolute` to find the\nabsolute values of complex data.\n\nParameters\n----------\nx : arraylike\nThe array of numbers for which the absolute values are required. If\n`x` is a scalar, the result `y` will also be a scalar.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe absolute values of `x`, the returned values are always floats.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nabsolute : Absolute values including `complex` types.\n\nExamples\n--------\n>>> np.fabs(-1)\n1.0\n>>> np.fabs([-1.2, 1.2])\narray([ 1.2, 1.2])\n\nfloatpower = \nfloatpower(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nFirst array elements raised to powers from second array, element-wise.\n\nRaise each base in `x1` to the positionally-corresponding power in `x2`.\n`x1` and `x2` must be broadcastable to the same shape. This differs from\nthe power function in that integers, float16, and float32 are promoted to\nfloats with a minimum precision of float64 so that the result is always\ninexact. The intent is that the function will return a usable result for\nnegative powers and seldom overflow for positive powers.\n\n.. versionadded:: 1.12.0\n\nParameters\n----------\nx1 : arraylike\nThe bases.\nx2 : arraylike\nThe exponents.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe bases in `x1` raised to the exponents in `x2`.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\npower : power function that preserves type\n\nExamples\n--------\nCube each element in a list.\n\n>>> x1 = range(6)\n>>> x1\n[0, 1, 2, 3, 4, 5]\n>>> np.floatpower(x1, 3)\narray([ 0., 1., 8., 27., 64., 125.])\n\nRaise the bases to different exponents.\n\n>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]\n>>> np.floatpower(x1, x2)\narray([ 0., 1., 8., 27., 16., 5.])\n\nThe effect of broadcasting.\n\n>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])\n>>> x2\narray([[1, 2, 3, 3, 2, 1],\n[1, 2, 3, 3, 2, 1]])\n>>> np.floatpower(x1, x2)\narray([[ 0., 1., 8., 27., 16., 5.],\n[ 0., 1., 8., 27., 16., 5.]])\n\nfloor = \nfloor(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the floor of the input, element-wise.\n\nThe floor of the scalar `x` is the largest integer `i`, such that\n`i <= x`. It is often denoted as :math:`\\lfloor x \\rfloor`.\n\nParameters\n----------\nx : arraylike\nInput data.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe floor of each element in `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nceil, trunc, rint, fix\n\nNotes\n-----\nSome spreadsheet programs calculate the \"floor-towards-zero\", where\n``floor(-2.5) == -2``. NumPy instead uses the definition of\n`floor` where `floor(-2.5) == -3`. The \"floor-towards-zero\"\nfunction is called ``fix`` in NumPy.\n\nExamples\n--------\n>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])\n>>> np.floor(a)\narray([-2., -2., -1., 0., 1., 1., 2.])\n\nfloordivide = \nfloordivide(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the largest integer smaller or equal to the division of the inputs.\nIt is equivalent to the Python ``//`` operator and pairs with the\nPython ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)``\nup to roundoff.\n\nParameters\n----------\nx1 : arraylike\nNumerator.\nx2 : arraylike\nDenominator.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\ny = floor(`x1`/`x2`)\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nremainder : Remainder complementary to floordivide.\ndivmod : Simultaneous floor division and remainder.\ndivide : Standard division.\nfloor : Round a number to the nearest integer toward minus infinity.\nceil : Round a number to the nearest integer toward infinity.\n\nExamples\n--------\n>>> np.floordivide(7,3)\n2\n>>> np.floordivide([1., 2., 3., 4.], 2.5)\narray([ 0., 0., 1., 1.])\n\nThe ``//`` operator can be used as a shorthand for ``np.floordivide``\non ndarrays.\n\n>>> x1 = np.array([1., 2., 3., 4.])\n>>> x1 // 2.5\narray([0., 0., 1., 1.])\n\nfmax = \nfmax(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nElement-wise maximum of array elements.\n\nCompare two arrays and returns a new array containing the element-wise\nmaxima. If one of the elements being compared is a NaN, then the\nnon-nan element is returned. If both elements are NaNs then the first\nis returned. The latter distinction is important for complex NaNs,\nwhich are defined as at least one of the real or imaginary parts being\na NaN. The net effect is that NaNs are ignored when possible.\n\nParameters\n----------\nx1, x2 : arraylike\nThe arrays holding the elements to be compared.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe maximum of `x1` and `x2`, element-wise.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nfmin :\nElement-wise minimum of two arrays, ignores NaNs.\nmaximum :\nElement-wise maximum of two arrays, propagates NaNs.\namax :\nThe maximum value of an array along a given axis, propagates NaNs.\nnanmax :\nThe maximum value of an array along a given axis, ignores NaNs.\n\nminimum, amin, nanmin\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\nThe fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither\nx1 nor x2 are NaNs, but it is faster and does proper broadcasting.\n\nExamples\n--------\n>>> np.fmax([2, 3, 4], [1, 5, 2])\narray([ 2., 5., 4.])\n\n>>> np.fmax(np.eye(2), [0.5, 2])\narray([[ 1. , 2. ],\n[ 0.5, 2. ]])\n\n>>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan])\narray([ 0., 0., nan])\n\nfmin = \nfmin(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nElement-wise minimum of array elements.\n\nCompare two arrays and returns a new array containing the element-wise\nminima. If one of the elements being compared is a NaN, then the\nnon-nan element is returned. If both elements are NaNs then the first\nis returned. The latter distinction is important for complex NaNs,\nwhich are defined as at least one of the real or imaginary parts being\na NaN. The net effect is that NaNs are ignored when possible.\n\nParameters\n----------\nx1, x2 : arraylike\nThe arrays holding the elements to be compared.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe minimum of `x1` and `x2`, element-wise.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nfmax :\nElement-wise maximum of two arrays, ignores NaNs.\nminimum :\nElement-wise minimum of two arrays, propagates NaNs.\namin :\nThe minimum value of an array along a given axis, propagates NaNs.\nnanmin :\nThe minimum value of an array along a given axis, ignores NaNs.\n\nmaximum, amax, nanmax\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\nThe fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither\nx1 nor x2 are NaNs, but it is faster and does proper broadcasting.\n\nExamples\n--------\n>>> np.fmin([2, 3, 4], [1, 5, 2])\narray([1, 3, 2])\n\n>>> np.fmin(np.eye(2), [0.5, 2])\narray([[ 0.5, 0. ],\n[ 0. , 1. ]])\n\n>>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan])\narray([ 0., 0., nan])\n\nfmod = \nfmod(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the element-wise remainder of division.\n\nThis is the NumPy implementation of the C library function fmod, the\nremainder has the same sign as the dividend `x1`. It is equivalent to\nthe Matlab(TM) ``rem`` function and should not be confused with the\nPython modulus operator ``x1 % x2``.\n\nParameters\n----------\nx1 : arraylike\nDividend.\nx2 : arraylike\nDivisor.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : arraylike\nThe remainder of the division of `x1` by `x2`.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nremainder : Equivalent to the Python ``%`` operator.\ndivide\n\nNotes\n-----\nThe result of the modulo operation for negative dividend and divisors\nis bound by conventions. For `fmod`, the sign of result is the sign of\nthe dividend, while for `remainder` the sign of the result is the sign\nof the divisor. The `fmod` function is equivalent to the Matlab(TM)\n``rem`` function.\n\nExamples\n--------\n>>> np.fmod([-3, -2, -1, 1, 2, 3], 2)\narray([-1, 0, -1, 1, 0, 1])\n>>> np.remainder([-3, -2, -1, 1, 2, 3], 2)\narray([1, 0, 1, 1, 0, 1])\n\n>>> np.fmod([5, 3], [2, 2.])\narray([ 1., 1.])\n>>> a = np.arange(-3, 3).reshape(3, 2)\n>>> a\narray([[-3, -2],\n[-1, 0],\n[ 1, 2]])\n>>> np.fmod(a, [2,2])\narray([[-1, 0],\n[-1, 0],\n[ 1, 0]])\n\nfrexp = \nfrexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nDecompose the elements of x into mantissa and twos exponent.\n\nReturns (`mantissa`, `exponent`), where `x = mantissa * 2exponent``.\nThe mantissa lies in the open interval(-1, 1), while the twos\nexponent is a signed integer.\n\nParameters\n----------\nx : arraylike\nArray of numbers to be decomposed.\nout1 : ndarray, optional\nOutput array for the mantissa. Must have the same shape as `x`.\nout2 : ndarray, optional\nOutput array for the exponent. Must have the same shape as `x`.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nmantissa : ndarray\nFloating values between -1 and 1.\nThis is a scalar if `x` is a scalar.\nexponent : ndarray\nInteger exponents of 2.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nldexp : Compute ``y = x1 * 2x2``, the inverse of `frexp`.\n\nNotes\n-----\nComplex dtypes are not supported, they will raise a TypeError.\n\nExamples\n--------\n>>> x = np.arange(9)\n>>> y1, y2 = np.frexp(x)\n>>> y1\narray([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875,\n0.5 ])\n>>> y2\narray([0, 1, 2, 2, 3, 3, 3, 3, 4])\n>>> y1 * 2y2\narray([ 0., 1., 2., 3., 4., 5., 6., 7., 8.])\n\ngcd = \ngcd(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturns the greatest common divisor of ``|x1|`` and ``|x2|``\n\nParameters\n----------\nx1, x2 : arraylike, int\nArrays of values.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\n\nReturns\n-------\ny : ndarray or scalar\nThe greatest common divisor of the absolute value of the inputs\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlcm : The lowest common multiple\n\nExamples\n--------\n>>> np.gcd(12, 20)\n4\n>>> np.gcd.reduce([15, 25, 35])\n5\n>>> np.gcd(np.arange(6), 20)\narray([20, 1, 2, 1, 4, 5])\n\ngreater = \ngreater(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the truth value of (x1 > x2) element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array, element-wise comparison of `x1` and `x2`.\nTypically of type bool, unless ``dtype=object`` is passed.\nThis is a scalar if both `x1` and `x2` are scalars.\n\n\nSee Also\n--------\ngreaterequal, less, lessequal, equal, notequal\n\nExamples\n--------\n>>> np.greater([4,2],[2,2])\narray([ True, False])\n\nThe ``>`` operator can be used as a shorthand for ``np.greater`` on\nndarrays.\n\n>>> a = np.array([4, 2])\n>>> b = np.array([2, 2])\n>>> a > b\narray([ True, False])\n\ngreaterequal = \ngreaterequal(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the truth value of (x1 >= x2) element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : bool or ndarray of bool\nOutput array, element-wise comparison of `x1` and `x2`.\nTypically of type bool, unless ``dtype=object`` is passed.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\ngreater, less, lessequal, equal, notequal\n\nExamples\n--------\n>>> np.greaterequal([4, 2, 1], [2, 2, 2])\narray([ True, True, False])\n\nThe ``>=`` operator can be used as a shorthand for ``np.greaterequal``\non ndarrays.\n\n>>> a = np.array([4, 2, 1])\n>>> b = np.array([2, 2, 2])\n>>> a >= b\narray([ True, True, False])\n\nheaviside = \nheaviside(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the Heaviside step function.\n\nThe Heaviside step function is defined as::\n\n0 if x1 < 0\nheaviside(x1, x2) = x2 if x1 == 0\n1 if x1 > 0\n\nwhere `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used.\n\nParameters\n----------\nx1 : arraylike\nInput values.\nx2 : arraylike\nThe value of the function when x1 is 0.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nThe output array, element-wise Heaviside step function of `x1`.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nNotes\n-----\n.. versionadded:: 1.13.0\n\nReferences\n----------\n.. Wikipedia, \"Heaviside step function\",\nhttps://en.wikipedia.org/wiki/Heavisidestepfunction\n\nExamples\n--------\n>>> np.heaviside([-1.5, 0, 2.0], 0.5)\narray([ 0. , 0.5, 1. ])\n>>> np.heaviside([-1.5, 0, 2.0], 1)\narray([ 0., 1., 1.])\n\nhypot = \nhypot(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nGiven the \"legs\" of a right triangle, return its hypotenuse.\n\nEquivalent to ``sqrt(x12 + x22)``, element-wise. If `x1` or\n`x2` is scalarlike (i.e., unambiguously cast-able to a scalar type),\nit is broadcast for use with each element of the other argument.\n(See Examples)\n\nParameters\n----------\nx1, x2 : arraylike\nLeg of the triangle(s).\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nz : ndarray\nThe hypotenuse of the triangle(s).\nThis is a scalar if both `x1` and `x2` are scalars.\n\nExamples\n--------\n>>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))\narray([[ 5., 5., 5.],\n[ 5., 5., 5.],\n[ 5., 5., 5.]])\n\nExample showing broadcast of scalarlike argument:\n\n>>> np.hypot(3*np.ones((3, 3)), [4])\narray([[ 5., 5., 5.],\n[ 5., 5., 5.],\n[ 5., 5., 5.]])\n\nindexexp = \ninf = inf\ninfty = inf\ninvert = \ninvert(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute bit-wise inversion, or bit-wise NOT, element-wise.\n\nComputes the bit-wise NOT of the underlying binary representation of\nthe integers in the input arrays. This ufunc implements the C/Python\noperator ``~``.\n\nFor signed integer inputs, the two's complement is returned. In a\ntwo's-complement system negative numbers are represented by the two's\ncomplement of the absolute value. This is the most common method of\nrepresenting signed integers on computers [1]. A N-bit\ntwo's-complement system can represent every integer in the range\n:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.\n\nParameters\n----------\nx : arraylike\nOnly integer and boolean types are handled.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nResult.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nbitwiseand, bitwiseor, bitwisexor\nlogicalnot\nbinaryrepr :\nReturn the binary representation of the input number as a string.\n\nNotes\n-----\n`bitwisenot` is an alias for `invert`:\n\n>>> np.bitwisenot is np.invert\nTrue\n\nReferences\n----------\n.. [1] Wikipedia, \"Two's complement\",\nhttps://en.wikipedia.org/wiki/Two'scomplement\n\nExamples\n--------\nWe've seen that 13 is represented by ``00001101``.\nThe invert or bit-wise NOT of 13 is then:\n\n>>> x = np.invert(np.array(13, dtype=np.uint8))\n>>> x\n242\n>>> np.binaryrepr(x, width=8)\n'11110010'\n\nThe result depends on the bit-width:\n\n>>> x = np.invert(np.array(13, dtype=np.uint16))\n>>> x\n65522\n>>> np.binaryrepr(x, width=16)\n'1111111111110010'\n\nWhen using signed integer types the result is the two's complement of\nthe result for the unsigned type:\n\n>>> np.invert(np.array([13], dtype=np.int8))\narray([-14], dtype=int8)\n>>> np.binaryrepr(-14, width=8)\n'11110010'\n\nBooleans are accepted as well:\n\n>>> np.invert(np.array([True, False]))\narray([False, True])\n\nThe ``~`` operator can be used as a shorthand for ``np.invert`` on\nndarrays.\n\n>>> x1 = np.array([True, False])\n>>> ~x1\narray([False, True])\n\nisfinite = \nisfinite(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nTest element-wise for finiteness (not infinity or not Not a Number).\n\nThe result is returned as a boolean array.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray, bool\nTrue where ``x`` is not positive infinity, negative infinity,\nor NaN; false otherwise.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nisinf, isneginf, isposinf, isnan\n\nNotes\n-----\nNot a Number, positive infinity and negative infinity are considered\nto be non-finite.\n\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754). This means that Not a Number is not equivalent to infinity.\nAlso that positive infinity is not equivalent to negative infinity. But\ninfinity is equivalent to positive infinity. Errors result if the\nsecond argument is also supplied when `x` is a scalar input, or if\nfirst and second arguments have different shapes.\n\nExamples\n--------\n>>> np.isfinite(1)\nTrue\n>>> np.isfinite(0)\nTrue\n>>> np.isfinite(np.nan)\nFalse\n>>> np.isfinite(np.inf)\nFalse\n>>> np.isfinite(np.NINF)\nFalse\n>>> np.isfinite([np.log(-1.),1.,np.log(0)])\narray([False, True, False])\n\n>>> x = np.array([-np.inf, 0., np.inf])\n>>> y = np.array([2, 2, 2])\n>>> np.isfinite(x, y)\narray([0, 1, 0])\n>>> y\narray([0, 1, 0])\n\nisinf = \nisinf(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nTest element-wise for positive or negative infinity.\n\nReturns a boolean array of the same shape as `x`, True where ``x ==\n+/-inf``, otherwise False.\n\nParameters\n----------\nx : arraylike\nInput values\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : bool (scalar) or boolean ndarray\nTrue where ``x`` is positive or negative infinity, false otherwise.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nisneginf, isposinf, isnan, isfinite\n\nNotes\n-----\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754).\n\nErrors result if the second argument is supplied when the first\nargument is a scalar, or if the first and second arguments have\ndifferent shapes.\n\nExamples\n--------\n>>> np.isinf(np.inf)\nTrue\n>>> np.isinf(np.nan)\nFalse\n>>> np.isinf(np.NINF)\nTrue\n>>> np.isinf([np.inf, -np.inf, 1.0, np.nan])\narray([ True, True, False, False])\n\n>>> x = np.array([-np.inf, 0., np.inf])\n>>> y = np.array([2, 2, 2])\n>>> np.isinf(x, y)\narray([1, 0, 1])\n>>> y\narray([1, 0, 1])\n\nisnan = \nisnan(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nTest element-wise for NaN and return result as a boolean array.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or bool\nTrue where ``x`` is NaN, false otherwise.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nisinf, isneginf, isposinf, isfinite, isnat\n\nNotes\n-----\nNumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754). This means that Not a Number is not equivalent to infinity.\n\nExamples\n--------\n>>> np.isnan(np.nan)\nTrue\n>>> np.isnan(np.inf)\nFalse\n>>> np.isnan([np.log(-1.),1.,np.log(0)])\narray([ True, False, False])\n\nisnat = \nisnat(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nTest element-wise for NaT (not a time) and return result as a boolean array.\n\n.. versionadded:: 1.13.0\n\nParameters\n----------\nx : arraylike\nInput array with datetime or timedelta data type.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or bool\nTrue where ``x`` is NaT, false otherwise.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nisnan, isinf, isneginf, isposinf, isfinite\n\nExamples\n--------\n>>> np.isnat(np.datetime64(\"NaT\"))\nTrue\n>>> np.isnat(np.datetime64(\"2016-01-01\"))\nFalse\n>>> np.isnat(np.array([\"NaT\", \"2016-01-01\"], dtype=\"datetime64[ns]\"))\narray([ True, False])\n\nlcm = \nlcm(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturns the lowest common multiple of ``|x1|`` and ``|x2|``\n\nParameters\n----------\nx1, x2 : arraylike, int\nArrays of values.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\n\nReturns\n-------\ny : ndarray or scalar\nThe lowest common multiple of the absolute value of the inputs\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\ngcd : The greatest common divisor\n\nExamples\n--------\n>>> np.lcm(12, 20)\n60\n>>> np.lcm.reduce([3, 12, 20])\n60\n>>> np.lcm.reduce([40, 12, 20])\n120\n>>> np.lcm(np.arange(6), 20)\narray([ 0, 20, 20, 60, 20, 20])\n\nldexp = \nldexp(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturns x1 * 2x2, element-wise.\n\nThe mantissas `x1` and twos exponents `x2` are used to construct\nfloating point numbers ``x1 * 2x2``.\n\nParameters\n----------\nx1 : arraylike\nArray of multipliers.\nx2 : arraylike, int\nArray of twos exponents.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe result of ``x1 * 2x2``.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nfrexp : Return (y1, y2) from ``x = y1 * 2y2``, inverse to `ldexp`.\n\nNotes\n-----\nComplex dtypes are not supported, they will raise a TypeError.\n\n`ldexp` is useful as the inverse of `frexp`, if used by itself it is\nmore clear to simply use the expression ``x1 * 2x2``.\n\nExamples\n--------\n>>> np.ldexp(5, np.arange(4))\narray([ 5., 10., 20., 40.], dtype=float16)\n\n>>> x = np.arange(6)\n>>> np.ldexp(*np.frexp(x))\narray([ 0., 1., 2., 3., 4., 5.])\n\nleftshift = \nleftshift(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nShift the bits of an integer to the left.\n\nBits are shifted to the left by appending `x2` 0s at the right of `x1`.\nSince the internal representation of numbers is in binary format, this\noperation is equivalent to multiplying `x1` by ``2x2``.\n\nParameters\n----------\nx1 : arraylike of integer type\nInput values.\nx2 : arraylike of integer type\nNumber of zeros to append to `x1`. Has to be non-negative.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : array of integer type\nReturn `x1` with bits shifted `x2` times to the left.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nrightshift : Shift the bits of an integer to the right.\nbinaryrepr : Return the binary representation of the input number\nas a string.\n\nExamples\n--------\n>>> np.binaryrepr(5)\n'101'\n>>> np.leftshift(5, 2)\n20\n>>> np.binaryrepr(20)\n'10100'\n\n>>> np.leftshift(5, [1,2,3])\narray([10, 20, 40])\n\nNote that the dtype of the second argument may change the dtype of the\nresult and can lead to unexpected results in some cases (see\n:ref:`Casting Rules `):\n\n>>> a = np.leftshift(np.uint8(255), 1) # Expect 254\n>>> print(a, type(a)) # Unexpected result due to upcasting\n510 \n>>> b = np.leftshift(np.uint8(255), np.uint8(1))\n>>> print(b, type(b))\n254 \n\nThe ``<<`` operator can be used as a shorthand for ``np.leftshift`` on\nndarrays.\n\n>>> x1 = 5\n>>> x2 = np.array([1, 2, 3])\n>>> x1 << x2\narray([10, 20, 40])\n\nless = \nless(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the truth value of (x1 < x2) element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array, element-wise comparison of `x1` and `x2`.\nTypically of type bool, unless ``dtype=object`` is passed.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\ngreater, lessequal, greaterequal, equal, notequal\n\nExamples\n--------\n>>> np.less([1, 2], [2, 2])\narray([ True, False])\n\nThe ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays.\n\n>>> a = np.array([1, 2])\n>>> b = np.array([2, 2])\n>>> a < b\narray([ True, False])\n\nlessequal = \nlessequal(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the truth value of (x1 <= x2) element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array, element-wise comparison of `x1` and `x2`.\nTypically of type bool, unless ``dtype=object`` is passed.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\ngreater, less, greaterequal, equal, notequal\n\nExamples\n--------\n>>> np.lessequal([4, 2, 1], [2, 2, 2])\narray([False, True, True])\n\nThe ``<=`` operator can be used as a shorthand for ``np.lessequal`` on\nndarrays.\n\n>>> a = np.array([4, 2, 1])\n>>> b = np.array([2, 2, 2])\n>>> a <= b\narray([False, True, True])\n\nlittleendian = True\nlog = \nlog(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nNatural logarithm, element-wise.\n\nThe natural logarithm `log` is the inverse of the exponential function,\nso that `log(exp(x)) = x`. The natural logarithm is logarithm in base\n`e`.\n\nParameters\n----------\nx : arraylike\nInput value.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe natural logarithm of `x`, element-wise.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nlog10, log2, log1p, emath.log\n\nNotes\n-----\nLogarithm is a multivalued function: for each `x` there is an infinite\nnumber of `z` such that `exp(z) = x`. The convention is to return the\n`z` whose imaginary part lies in `[-pi, pi]`.\n\nFor real-valued input data types, `log` always returns real output. For\neach value that cannot be expressed as a real number or infinity, it\nyields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `log` is a complex analytical function that\nhas a branch cut `[-inf, 0]` and is continuous from above on it. `log`\nhandles the floating-point negative zero as an infinitesimal negative\nnumber, conforming to the C99 standard.\n\nReferences\n----------\n.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",\n10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/\n.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm\n\nExamples\n--------\n>>> np.log([1, np.e, np.e2, 0])\narray([ 0., 1., 2., -Inf])\n\nlog10 = \nlog10(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the base 10 logarithm of the input array, element-wise.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe logarithm to the base 10 of `x`, element-wise. NaNs are\nreturned where x is negative.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nemath.log10\n\nNotes\n-----\nLogarithm is a multivalued function: for each `x` there is an infinite\nnumber of `z` such that `10z = x`. The convention is to return the\n`z` whose imaginary part lies in `[-pi, pi]`.\n\nFor real-valued input data types, `log10` always returns real output.\nFor each value that cannot be expressed as a real number or infinity,\nit yields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `log10` is a complex analytical function that\nhas a branch cut `[-inf, 0]` and is continuous from above on it.\n`log10` handles the floating-point negative zero as an infinitesimal\nnegative number, conforming to the C99 standard.\n\nReferences\n----------\n.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",\n10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/\n.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm\n\nExamples\n--------\n>>> np.log10([1e-15, -3.])\narray([-15., nan])\n\nlog1p = \nlog1p(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the natural logarithm of one plus the input array, element-wise.\n\nCalculates ``log(1 + x)``.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nNatural logarithm of `1 + x`, element-wise.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nexpm1 : ``exp(x) - 1``, the inverse of `log1p`.\n\nNotes\n-----\nFor real-valued input, `log1p` is accurate also for `x` so small\nthat `1 + x == 1` in floating-point accuracy.\n\nLogarithm is a multivalued function: for each `x` there is an infinite\nnumber of `z` such that `exp(z) = 1 + x`. The convention is to return\nthe `z` whose imaginary part lies in `[-pi, pi]`.\n\nFor real-valued input data types, `log1p` always returns real output.\nFor each value that cannot be expressed as a real number or infinity,\nit yields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `log1p` is a complex analytical function that\nhas a branch cut `[-inf, -1]` and is continuous from above on it.\n`log1p` handles the floating-point negative zero as an infinitesimal\nnegative number, conforming to the C99 standard.\n\nReferences\n----------\n.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",\n10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/\n.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm\n\nExamples\n--------\n>>> np.log1p(1e-99)\n1e-99\n>>> np.log(1 + 1e-99)\n0.0\n\nlog2 = \nlog2(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nBase-2 logarithm of `x`.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nBase-2 logarithm of `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nlog, log10, log1p, emath.log2\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\nLogarithm is a multivalued function: for each `x` there is an infinite\nnumber of `z` such that `2z = x`. The convention is to return the `z`\nwhose imaginary part lies in `[-pi, pi]`.\n\nFor real-valued input data types, `log2` always returns real output.\nFor each value that cannot be expressed as a real number or infinity,\nit yields ``nan`` and sets the `invalid` floating point error flag.\n\nFor complex-valued input, `log2` is a complex analytical function that\nhas a branch cut `[-inf, 0]` and is continuous from above on it. `log2`\nhandles the floating-point negative zero as an infinitesimal negative\nnumber, conforming to the C99 standard.\n\nExamples\n--------\n>>> x = np.array([0, 1, 2, 24])\n>>> np.log2(x)\narray([-Inf, 0., 1., 4.])\n\n>>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])\n>>> np.log2(xi)\narray([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j])\n\nlogaddexp = \nlogaddexp(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nLogarithm of the sum of exponentiations of the inputs.\n\nCalculates ``log(exp(x1) + exp(x2))``. This function is useful in\nstatistics where the calculated probabilities of events may be so small\nas to exceed the range of normal floating point numbers. In such cases\nthe logarithm of the calculated probability is stored. This function\nallows adding probabilities stored in such a fashion.\n\nParameters\n----------\nx1, x2 : arraylike\nInput values.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nresult : ndarray\nLogarithm of ``exp(x1) + exp(x2)``.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\nExamples\n--------\n>>> prob1 = np.log(1e-50)\n>>> prob2 = np.log(2.5e-50)\n>>> prob12 = np.logaddexp(prob1, prob2)\n>>> prob12\n-113.87649168120691\n>>> np.exp(prob12)\n3.5000000000000057e-50\n\nlogaddexp2 = \nlogaddexp2(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nLogarithm of the sum of exponentiations of the inputs in base-2.\n\nCalculates ``log2(2x1 + 2x2)``. This function is useful in machine\nlearning when the calculated probabilities of events may be so small as\nto exceed the range of normal floating point numbers. In such cases\nthe base-2 logarithm of the calculated probability can be used instead.\nThis function allows adding probabilities stored in such a fashion.\n\nParameters\n----------\nx1, x2 : arraylike\nInput values.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nresult : ndarray\nBase-2 logarithm of ``2x1 + 2x2``.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogaddexp: Logarithm of the sum of exponentiations of the inputs.\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\nExamples\n--------\n>>> prob1 = np.log2(1e-50)\n>>> prob2 = np.log2(2.5e-50)\n>>> prob12 = np.logaddexp2(prob1, prob2)\n>>> prob1, prob2, prob12\n(-166.09640474436813, -164.77447664948076, -164.28904982231052)\n>>> 2prob12\n3.4999999999999914e-50\n\nlogicaland = \nlogicaland(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the truth value of x1 AND x2 element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or bool\nBoolean result of the logical AND operation applied to the elements\nof `x1` and `x2`; the shape is determined by broadcasting.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogicalor, logicalnot, logicalxor\nbitwiseand\n\nExamples\n--------\n>>> np.logicaland(True, False)\nFalse\n>>> np.logicaland([True, False], [False, False])\narray([False, False])\n\n>>> x = np.arange(5)\n>>> np.logicaland(x>1, x<4)\narray([False, False, True, True, False])\n\n\nThe ``&`` operator can be used as a shorthand for ``np.logicaland`` on\nboolean ndarrays.\n\n>>> a = np.array([True, False])\n>>> b = np.array([False, False])\n>>> a & b\narray([False, False])\n\nlogicalnot = \nlogicalnot(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the truth value of NOT x element-wise.\n\nParameters\n----------\nx : arraylike\nLogical NOT is applied to the elements of `x`.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : bool or ndarray of bool\nBoolean result with the same shape as `x` of the NOT operation\non elements of `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nlogicaland, logicalor, logicalxor\n\nExamples\n--------\n>>> np.logicalnot(3)\nFalse\n>>> np.logicalnot([True, False, 0, 1])\narray([False, True, True, False])\n\n>>> x = np.arange(5)\n>>> np.logicalnot(x<3)\narray([False, False, False, True, True])\n\nlogicalor = \nlogicalor(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the truth value of x1 OR x2 element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nLogical OR is applied to the elements of `x1` and `x2`.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or bool\nBoolean result of the logical OR operation applied to the elements\nof `x1` and `x2`; the shape is determined by broadcasting.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogicaland, logicalnot, logicalxor\nbitwiseor\n\nExamples\n--------\n>>> np.logicalor(True, False)\nTrue\n>>> np.logicalor([True, False], [False, False])\narray([ True, False])\n\n>>> x = np.arange(5)\n>>> np.logicalor(x < 1, x > 3)\narray([ True, False, False, False, True])\n\nThe ``|`` operator can be used as a shorthand for ``np.logicalor`` on\nboolean ndarrays.\n\n>>> a = np.array([True, False])\n>>> b = np.array([False, False])\n>>> a | b\narray([ True, False])\n\nlogicalxor = \nlogicalxor(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute the truth value of x1 XOR x2, element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nLogical XOR is applied to the elements of `x1` and `x2`.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : bool or ndarray of bool\nBoolean result of the logical XOR operation applied to the elements\nof `x1` and `x2`; the shape is determined by broadcasting.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nlogicaland, logicalor, logicalnot, bitwisexor\n\nExamples\n--------\n>>> np.logicalxor(True, False)\nTrue\n>>> np.logicalxor([True, True, False, False], [True, False, True, False])\narray([False, True, True, False])\n\n>>> x = np.arange(5)\n>>> np.logicalxor(x < 1, x > 3)\narray([ True, False, False, False, True])\n\nSimple example showing support of broadcasting\n\n>>> np.logicalxor(0, np.eye(2))\narray([[ True, False],\n[False, True]])\n\nmatmul = \nmatmul(x1, x2, /, out=None, *, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis])\n\nMatrix product of two arrays.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays, scalars not allowed.\nout : ndarray, optional\nA location into which the result is stored. If provided, it must have\na shape that matches the signature `(n,k),(k,m)->(n,m)`. If not\nprovided or None, a freshly-allocated array is returned.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\n.. versionadded:: 1.16\nNow handles ufunc kwargs\n\nReturns\n-------\ny : ndarray\nThe matrix product of the inputs.\nThis is a scalar only when both x1, x2 are 1-d vectors.\n\nRaises\n------\nValueError\nIf the last dimension of `x1` is not the same size as\nthe second-to-last dimension of `x2`.\n\nIf a scalar value is passed in.\n\nSee Also\n--------\nvdot : Complex-conjugating dot product.\ntensordot : Sum products over arbitrary axes.\neinsum : Einstein summation convention.\ndot : alternative matrix product with different broadcasting rules.\n\nNotes\n-----\n\nThe behavior depends on the arguments in the following way.\n\n- If both arguments are 2-D they are multiplied like conventional\nmatrices.\n- If either argument is N-D, N > 2, it is treated as a stack of\nmatrices residing in the last two indexes and broadcast accordingly.\n- If the first argument is 1-D, it is promoted to a matrix by\nprepending a 1 to its dimensions. After matrix multiplication\nthe prepended 1 is removed.\n- If the second argument is 1-D, it is promoted to a matrix by\nappending a 1 to its dimensions. After matrix multiplication\nthe appended 1 is removed.\n\n``matmul`` differs from ``dot`` in two important ways:\n\n- Multiplication by scalars is not allowed, use ``*`` instead.\n- Stacks of matrices are broadcast together as if the matrices\nwere elements, respecting the signature ``(n,k),(k,m)->(n,m)``:\n\n>>> a = np.ones([9, 5, 7, 4])\n>>> c = np.ones([9, 5, 4, 3])\n>>> np.dot(a, c).shape\n(9, 5, 7, 9, 5, 3)\n>>> np.matmul(a, c).shape\n(9, 5, 7, 3)\n>>> # n is 7, k is 4, m is 3\n\nThe matmul function implements the semantics of the ``@`` operator introduced\nin Python 3.5 following :pep:`465`.\n\nExamples\n--------\nFor 2-D arrays it is the matrix product:\n\n>>> a = np.array([[1, 0],\n... [0, 1]])\n>>> b = np.array([[4, 1],\n... [2, 2]])\n>>> np.matmul(a, b)\narray([[4, 1],\n[2, 2]])\n\nFor 2-D mixed with 1-D, the result is the usual.\n\n>>> a = np.array([[1, 0],\n... [0, 1]])\n>>> b = np.array([1, 2])\n>>> np.matmul(a, b)\narray([1, 2])\n>>> np.matmul(b, a)\narray([1, 2])\n\n\nBroadcasting is conventional for stacks of arrays\n\n>>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))\n>>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))\n>>> np.matmul(a,b).shape\n(2, 2, 2)\n>>> np.matmul(a, b)[0, 1, 1]\n98\n>>> sum(a[0, 1, :] * b[0 , :, 1])\n98\n\nVector, vector returns the scalar inner product, but neither argument\nis complex-conjugated:\n\n>>> np.matmul([2j, 3j], [2j, 3j])\n(-13+0j)\n\nScalar multiplication raises an error.\n\n>>> np.matmul([1,2], 3)\nTraceback (most recent call last):\n...\nValueError: matmul: Input operand 1 does not have enough dimensions ...\n\nThe ``@`` operator can be used as a shorthand for ``np.matmul`` on\nndarrays.\n\n>>> x1 = np.array([2j, 3j])\n>>> x2 = np.array([2j, 3j])\n>>> x1 @ x2\n(-13+0j)\n\n.. versionadded:: 1.10.0\n\nmaximum = \nmaximum(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nElement-wise maximum of array elements.\n\nCompare two arrays and returns a new array containing the element-wise\nmaxima. If one of the elements being compared is a NaN, then that\nelement is returned. If both elements are NaNs then the first is\nreturned. The latter distinction is important for complex NaNs, which\nare defined as at least one of the real or imaginary parts being a NaN.\nThe net effect is that NaNs are propagated.\n\nParameters\n----------\nx1, x2 : arraylike\nThe arrays holding the elements to be compared.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe maximum of `x1` and `x2`, element-wise.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nminimum :\nElement-wise minimum of two arrays, propagates NaNs.\nfmax :\nElement-wise maximum of two arrays, ignores NaNs.\namax :\nThe maximum value of an array along a given axis, propagates NaNs.\nnanmax :\nThe maximum value of an array along a given axis, ignores NaNs.\n\nfmin, amin, nanmin\n\nNotes\n-----\nThe maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when\nneither x1 nor x2 are nans, but it is faster and does proper\nbroadcasting.\n\nExamples\n--------\n>>> np.maximum([2, 3, 4], [1, 5, 2])\narray([2, 5, 4])\n\n>>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting\narray([[ 1. , 2. ],\n[ 0.5, 2. ]])\n\n>>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])\narray([nan, nan, nan])\n>>> np.maximum(np.Inf, 1)\ninf\n\nmgrid = \nminimum = \nminimum(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nElement-wise minimum of array elements.\n\nCompare two arrays and returns a new array containing the element-wise\nminima. If one of the elements being compared is a NaN, then that\nelement is returned. If both elements are NaNs then the first is\nreturned. The latter distinction is important for complex NaNs, which\nare defined as at least one of the real or imaginary parts being a NaN.\nThe net effect is that NaNs are propagated.\n\nParameters\n----------\nx1, x2 : arraylike\nThe arrays holding the elements to be compared.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe minimum of `x1` and `x2`, element-wise.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nmaximum :\nElement-wise maximum of two arrays, propagates NaNs.\nfmin :\nElement-wise minimum of two arrays, ignores NaNs.\namin :\nThe minimum value of an array along a given axis, propagates NaNs.\nnanmin :\nThe minimum value of an array along a given axis, ignores NaNs.\n\nfmax, amax, nanmax\n\nNotes\n-----\nThe minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when\nneither x1 nor x2 are NaNs, but it is faster and does proper\nbroadcasting.\n\nExamples\n--------\n>>> np.minimum([2, 3, 4], [1, 5, 2])\narray([1, 3, 2])\n\n>>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting\narray([[ 0.5, 0. ],\n[ 0. , 1. ]])\n\n>>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])\narray([nan, nan, nan])\n>>> np.minimum(-np.Inf, 1)" }, { "name": "-inf", "content": "mod = \nremainder(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn element-wise remainder of division.\n\nComputes the remainder complementary to the `floordivide` function. It is\nequivalent to the Python modulus operator``x1 % x2`` and has the same sign\nas the divisor `x2`. The MATLAB function equivalent to ``np.remainder``\nis ``mod``.\n\n.. warning::\n\nThis should not be confused with:\n\n* Python 3.7's `math.remainder` and C's ``remainder``, which\ncomputes the IEEE remainder, which are the complement to\n``round(x1 / x2)``.\n* The MATLAB ``rem`` function and or the C ``%`` operator which is the\ncomplement to ``int(x1 / x2)``.\n\nParameters\n----------\nx1 : arraylike\nDividend array.\nx2 : arraylike\nDivisor array.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe element-wise remainder of the quotient ``floordivide(x1, x2)``.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nfloordivide : Equivalent of Python ``//`` operator.\ndivmod : Simultaneous floor division and remainder.\nfmod : Equivalent of the MATLAB ``rem`` function.\ndivide, floor\n\nNotes\n-----\nReturns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)\nintegers.\n``mod`` is an alias of ``remainder``.\n\nExamples\n--------\n>>> np.remainder([4, 7], [2, 3])\narray([0, 1])\n>>> np.remainder(np.arange(7), 5)\narray([0, 1, 2, 3, 4, 0, 1])\n\nThe ``%`` operator can be used as a shorthand for ``np.remainder`` on\nndarrays.\n\n>>> x1 = np.arange(7)\n>>> x1 % 5\narray([0, 1, 2, 3, 4, 0, 1])\n\nmodf = \nmodf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the fractional and integral parts of an array, element-wise.\n\nThe fractional and integral parts are negative if the given number is\nnegative.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny1 : ndarray\nFractional part of `x`.\nThis is a scalar if `x` is a scalar.\ny2 : ndarray\nIntegral part of `x`.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nFor integer input the return values are floats.\n\nSee Also\n--------\ndivmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values\nswitched, except it always has a positive remainder.\n\nExamples\n--------\n>>> np.modf([0, 3.5])\n(array([ 0. , 0.5]), array([ 0., 3.]))\n>>> np.modf(-0.5)\n(-0.5, -0)\n\nmultiply = \nmultiply(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nMultiply arguments element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays to be multiplied.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe product of `x1` and `x2`, element-wise.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nNotes\n-----\nEquivalent to `x1` * `x2` in terms of array broadcasting.\n\nExamples\n--------\n>>> np.multiply(2.0, 4.0)\n8.0\n\n>>> x1 = np.arange(9.0).reshape((3, 3))\n>>> x2 = np.arange(3.0)\n>>> np.multiply(x1, x2)\narray([[ 0., 1., 4.],\n[ 0., 4., 10.],\n[ 0., 7., 16.]])\n\nThe ``*`` operator can be used as a shorthand for ``np.multiply`` on\nndarrays.\n\n>>> x1 = np.arange(9.0).reshape((3, 3))\n>>> x2 = np.arange(3.0)\n>>> x1 * x2\narray([[ 0., 1., 4.],\n[ 0., 4., 10.],\n[ 0., 7., 16.]])\n\nnan = nan\nnbytes = {: 1, :....datetime6...\nnegative = \nnegative(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nNumerical negative, element-wise.\n\nParameters\n----------\nx : arraylike or scalar\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nReturned array or scalar: `y = -x`.\nThis is a scalar if `x` is a scalar.\n\nExamples\n--------\n>>> np.negative([1.,-1.])\narray([-1., 1.])\n\nThe unary ``-`` operator can be used as a shorthand for ``np.negative`` on\nndarrays.\n\n>>> x1 = np.array(([1., -1.]))\n>>> -x1\narray([-1., 1.])\n\nnewaxis = None\nnextafter = \nnextafter(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the next floating-point value after x1 towards x2, element-wise.\n\nParameters\n----------\nx1 : arraylike\nValues to find the next representable value of.\nx2 : arraylike\nThe direction where to look for the next representable value of `x1`.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nThe next representable values of `x1` in the direction of `x2`.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nExamples\n--------\n>>> eps = np.finfo(np.float64).eps\n>>> np.nextafter(1, 2) == eps + 1\nTrue\n>>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]\narray([ True, True])\n\nnotequal = \nnotequal(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn (x1 != x2) element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nInput arrays.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array, element-wise comparison of `x1` and `x2`.\nTypically of type bool, unless ``dtype=object`` is passed.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nequal, greater, greaterequal, less, lessequal\n\nExamples\n--------\n>>> np.notequal([1.,2.], [1., 3.])\narray([False, True])\n>>> np.notequal([1, 2], [[1, 3],[1, 4]])\narray([[False, True],\n[False, True]])\n\nThe ``!=`` operator can be used as a shorthand for ``np.notequal`` on\nndarrays.\n\n>>> a = np.array([1., 2.])\n>>> b = np.array([1., 3.])\n>>> a != b\narray([False, True])\n\nogrid = \npi = 3.141592653589793\npositive = \npositive(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nNumerical positive, element-wise.\n\n.. versionadded:: 1.13.0\n\nParameters\n----------\nx : arraylike or scalar\nInput array.\n\nReturns\n-------\ny : ndarray or scalar\nReturned array or scalar: `y = +x`.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nEquivalent to `x.copy()`, but only defined for types that support\narithmetic.\n\nExamples\n--------\n\n>>> x1 = np.array(([1., -1.]))\n>>> np.positive(x1)\narray([ 1., -1.])\n\nThe unary ``+`` operator can be used as a shorthand for ``np.positive`` on\nndarrays.\n\n>>> x1 = np.array(([1., -1.]))\n>>> +x1\narray([ 1., -1.])\n\npower = \npower(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nFirst array elements raised to powers from second array, element-wise.\n\nRaise each base in `x1` to the positionally-corresponding power in\n`x2`. `x1` and `x2` must be broadcastable to the same shape. Note that an\ninteger type raised to a negative integer power will raise a ValueError.\n\nParameters\n----------\nx1 : arraylike\nThe bases.\nx2 : arraylike\nThe exponents.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe bases in `x1` raised to the exponents in `x2`.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nfloatpower : power function that promotes integers to float\n\nExamples\n--------\nCube each element in an array.\n\n>>> x1 = np.arange(6)\n>>> x1\n[0, 1, 2, 3, 4, 5]\n>>> np.power(x1, 3)\narray([ 0, 1, 8, 27, 64, 125])\n\nRaise the bases to different exponents.\n\n>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]\n>>> np.power(x1, x2)\narray([ 0., 1., 8., 27., 16., 5.])\n\nThe effect of broadcasting.\n\n>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])\n>>> x2\narray([[1, 2, 3, 3, 2, 1],\n[1, 2, 3, 3, 2, 1]])\n>>> np.power(x1, x2)\narray([[ 0, 1, 8, 27, 16, 5],\n[ 0, 1, 8, 27, 16, 5]])\n\nThe ```` operator can be used as a shorthand for ``np.power`` on\nndarrays.\n\n>>> x2 = np.array([1, 2, 3, 3, 2, 1])\n>>> x1 = np.arange(6)\n>>> x1 x2\narray([ 0, 1, 8, 27, 16, 5])\n\nr = \nrad2deg = \nrad2deg(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nConvert angles from radians to degrees.\n\nParameters\n----------\nx : arraylike\nAngle in radians.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe corresponding angle in degrees.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\ndeg2rad : Convert angles from degrees to radians.\nunwrap : Remove large jumps in angle by wrapping.\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\nrad2deg(x) is ``180 * x / pi``.\n\nExamples\n--------\n>>> np.rad2deg(np.pi/2)\n90.0\n\nradians = \nradians(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nConvert angles from degrees to radians.\n\nParameters\n----------\nx : arraylike\nInput array in degrees.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe corresponding radian values.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\ndeg2rad : equivalent function\n\nExamples\n--------\nConvert a degree array to radians\n\n>>> deg = np.arange(12.) * 30.\n>>> np.radians(deg)\narray([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 ,\n2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898,\n5.23598776, 5.75958653])\n\n>>> out = np.zeros((deg.shape))\n>>> ret = np.radians(deg, out)\n>>> ret is out\nTrue\n\nreciprocal = \nreciprocal(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the reciprocal of the argument, element-wise.\n\nCalculates ``1/x``.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nReturn array.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\n.. note::\nThis function is not designed to work with integers.\n\nFor integer arguments with absolute value larger than 1 the result is\nalways zero because of the way Python handles integer division. For\ninteger zero the result is an overflow.\n\nExamples\n--------\n>>> np.reciprocal(2.)\n0.5\n>>> np.reciprocal([1, 2., 3.33])\narray([ 1. , 0.5 , 0.3003003])\n\nremainder = \nremainder(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn element-wise remainder of division.\n\nComputes the remainder complementary to the `floordivide` function. It is\nequivalent to the Python modulus operator``x1 % x2`` and has the same sign\nas the divisor `x2`. The MATLAB function equivalent to ``np.remainder``\nis ``mod``.\n\n.. warning::\n\nThis should not be confused with:\n\n* Python 3.7's `math.remainder` and C's ``remainder``, which\ncomputes the IEEE remainder, which are the complement to\n``round(x1 / x2)``.\n* The MATLAB ``rem`` function and or the C ``%`` operator which is the\ncomplement to ``int(x1 / x2)``.\n\nParameters\n----------\nx1 : arraylike\nDividend array.\nx2 : arraylike\nDivisor array.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe element-wise remainder of the quotient ``floordivide(x1, x2)``.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nfloordivide : Equivalent of Python ``//`` operator.\ndivmod : Simultaneous floor division and remainder.\nfmod : Equivalent of the MATLAB ``rem`` function.\ndivide, floor\n\nNotes\n-----\nReturns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)\nintegers.\n``mod`` is an alias of ``remainder``.\n\nExamples\n--------\n>>> np.remainder([4, 7], [2, 3])\narray([0, 1])\n>>> np.remainder(np.arange(7), 5)\narray([0, 1, 2, 3, 4, 0, 1])\n\nThe ``%`` operator can be used as a shorthand for ``np.remainder`` on\nndarrays.\n\n>>> x1 = np.arange(7)\n>>> x1 % 5\narray([0, 1, 2, 3, 4, 0, 1])\n\nrightshift = \nrightshift(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nShift the bits of an integer to the right.\n\nBits are shifted to the right `x2`. Because the internal\nrepresentation of numbers is in binary format, this operation is\nequivalent to dividing `x1` by ``2x2``.\n\nParameters\n----------\nx1 : arraylike, int\nInput values.\nx2 : arraylike, int\nNumber of bits to remove at the right of `x1`.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray, int\nReturn `x1` with bits shifted `x2` times to the right.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nSee Also\n--------\nleftshift : Shift the bits of an integer to the left.\nbinaryrepr : Return the binary representation of the input number\nas a string.\n\nExamples\n--------\n>>> np.binaryrepr(10)\n'1010'\n>>> np.rightshift(10, 1)\n5\n>>> np.binaryrepr(5)\n'101'\n\n>>> np.rightshift(10, [1,2,3])\narray([5, 2, 1])\n\nThe ``>>`` operator can be used as a shorthand for ``np.rightshift`` on\nndarrays.\n\n>>> x1 = 10\n>>> x2 = np.array([1,2,3])\n>>> x1 >> x2\narray([5, 2, 1])\n\nrint = \nrint(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nRound elements of the array to the nearest integer.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nOutput array is same shape and type as `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nfix, ceil, floor, trunc\n\nNotes\n-----\nFor values exactly halfway between rounded decimal values, NumPy\nrounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,\n-0.5 and 0.5 round to 0.0, etc.\n\nExamples\n--------\n>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])\n>>> np.rint(a)\narray([-2., -2., -0., 0., 2., 2., 2.])\n\ns = \nsctypeDict = {'?': , 0: , 'b...\nsctypes = {'complex': [, \nsign(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturns an element-wise indication of the sign of a number.\n\nThe `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan\nis returned for nan inputs.\n\nFor complex inputs, the `sign` function returns\n``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``.\n\ncomplex(nan, 0) is returned for complex nan inputs.\n\nParameters\n----------\nx : arraylike\nInput values.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe sign of `x`.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nThere is more than one definition of sign in common use for complex\nnumbers. The definition used here is equivalent to :math:`x/\\sqrt{x*x}`\nwhich is different from a common alternative, :math:`x/|x|`.\n\nExamples\n--------\n>>> np.sign([-5., 4.5])\narray([-1., 1.])\n>>> np.sign(0)\n0\n>>> np.sign(5-2j)\n(1+0j)\n\nsignbit = \nsignbit(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturns element-wise True where signbit is set (less than zero).\n\nParameters\n----------\nx : arraylike\nThe input value(s).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nresult : ndarray of bool\nOutput array, or reference to `out` if that was supplied.\nThis is a scalar if `x` is a scalar.\n\nExamples\n--------\n>>> np.signbit(-1.2)\nTrue\n>>> np.signbit(np.array([1, -2.3, 2.1]))\narray([False, True, False])\n\nsin = \nsin(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nTrigonometric sine, element-wise.\n\nParameters\n----------\nx : arraylike\nAngle, in radians (:math:`2 \\pi` rad equals 360 degrees).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : arraylike\nThe sine of each element of x.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\narcsin, sinh, cos\n\nNotes\n-----\nThe sine is one of the fundamental functions of trigonometry (the\nmathematical study of triangles). Consider a circle of radius 1\ncentered on the origin. A ray comes in from the :math:`+x` axis, makes\nan angle at the origin (measured counter-clockwise from that axis), and\ndeparts from the origin. The :math:`y` coordinate of the outgoing\nray's intersection with the unit circle is the sine of that angle. It\nranges from -1 for :math:`x=3\\pi / 2` to +1 for :math:`\\pi / 2.` The\nfunction has zeroes where the angle is a multiple of :math:`\\pi`.\nSines of angles between :math:`\\pi` and :math:`2\\pi` are negative.\nThe numerous properties of the sine and related functions are included\nin any standard trigonometry text.\n\nExamples\n--------\nPrint sine of one angle:\n\n>>> np.sin(np.pi/2.)\n1.0\n\nPrint sines of an array of angles given in degrees:\n\n>>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )\narray([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ])\n\nPlot the sine function:\n\n>>> import matplotlib.pylab as plt\n>>> x = np.linspace(-np.pi, np.pi, 201)\n>>> plt.plot(x, np.sin(x))\n>>> plt.xlabel('Angle [rad]')\n>>> plt.ylabel('sin(x)')\n>>> plt.axis('tight')\n>>> plt.show()\n\nsinh = \nsinh(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nHyperbolic sine, element-wise.\n\nEquivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or\n``-1j * np.sin(1j*x)``.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe corresponding hyperbolic sine values.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nIf `out` is provided, the function writes the result into it,\nand returns a reference to `out`. (See Examples)\n\nReferences\n----------\nM. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.\nNew York, NY: Dover, 1972, pg. 83.\n\nExamples\n--------\n>>> np.sinh(0)\n0.0\n>>> np.sinh(np.pi*1j/2)\n1j\n>>> np.sinh(np.pi*1j) # (exact value is 0)\n1.2246063538223773e-016j\n>>> # Discrepancy due to vagaries of floating point arithmetic.\n\n>>> # Example of providing the optional output parameter\n>>> out1 = np.array([0], dtype='d')\n>>> out2 = np.sinh([0.1], out1)\n>>> out2 is out1\nTrue\n\n>>> # Example of ValueError due to provision of shape mis-matched `out`\n>>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))\nTraceback (most recent call last):\nFile \"\", line 1, in \nValueError: operands could not be broadcast together with shapes (3,3) (2,2)\n\nspacing = \nspacing(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the distance between x and the nearest adjacent number.\n\nParameters\n----------\nx : arraylike\nValues to find the spacing of.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nThe spacing of values of `x`.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nIt can be considered as a generalization of EPS:\n``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there\nshould not be any representable number between ``x + spacing(x)`` and\nx for any finite x.\n\nSpacing of +- inf and NaN is NaN.\n\nExamples\n--------\n>>> np.spacing(1) == np.finfo(np.float64).eps\nTrue\n\nsqrt = \nsqrt(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the non-negative square-root of an array, element-wise.\n\nParameters\n----------\nx : arraylike\nThe values whose square-roots are required.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nAn array of the same shape as `x`, containing the positive\nsquare-root of each element in `x`. If any element in `x` is\ncomplex, a complex array is returned (and the square-roots of\nnegative reals are calculated). If all of the elements in `x`\nare real, so is `y`, with negative elements returning ``nan``.\nIf `out` was provided, `y` is a reference to it.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nlib.scimath.sqrt\nA version which returns complex numbers when given negative reals.\n\nNotes\n-----\n*sqrt* has--consistent with common convention--as its branch cut the\nreal \"interval\" [`-inf`, 0), and is continuous from above on it.\nA branch cut is a curve in the complex plane across which a given\ncomplex function fails to be continuous.\n\nExamples\n--------\n>>> np.sqrt([1,4,9])\narray([ 1., 2., 3.])\n\n>>> np.sqrt([4, -1, -3+4J])\narray([ 2.+0.j, 0.+1.j, 1.+2.j])\n\n>>> np.sqrt([4, -1, np.inf])\narray([ 2., nan, inf])\n\nsquare = \nsquare(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the element-wise square of the input.\n\nParameters\n----------\nx : arraylike\nInput data.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nElement-wise `x*x`, of the same shape and dtype as `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nnumpy.linalg.matrixpower\nsqrt\npower\n\nExamples\n--------\n>>> np.square([-1j, 1])\narray([-1.-0.j, 1.+0.j])\n\nsubtract = \nsubtract(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nSubtract arguments, element-wise.\n\nParameters\n----------\nx1, x2 : arraylike\nThe arrays to be subtracted from each other.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe difference of `x1` and `x2`, element-wise.\nThis is a scalar if both `x1` and `x2` are scalars.\n\nNotes\n-----\nEquivalent to ``x1 - x2`` in terms of array broadcasting.\n\nExamples\n--------\n>>> np.subtract(1.0, 4.0)\n-3.0\n\n>>> x1 = np.arange(9.0).reshape((3, 3))\n>>> x2 = np.arange(3.0)\n>>> np.subtract(x1, x2)\narray([[ 0., 0., 0.],\n[ 3., 3., 3.],\n[ 6., 6., 6.]])\n\nThe ``-`` operator can be used as a shorthand for ``np.subtract`` on\nndarrays.\n\n>>> x1 = np.arange(9.0).reshape((3, 3))\n>>> x2 = np.arange(3.0)\n>>> x1 - x2\narray([[0., 0., 0.],\n[3., 3., 3.],\n[6., 6., 6.]])\n\ntan = \ntan(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute tangent element-wise.\n\nEquivalent to ``np.sin(x)/np.cos(x)`` element-wise.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe corresponding tangent values.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nIf `out` is provided, the function writes the result into it,\nand returns a reference to `out`. (See Examples)\n\nReferences\n----------\nM. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.\nNew York, NY: Dover, 1972.\n\nExamples\n--------\n>>> from math import pi\n>>> np.tan(np.array([-pi,pi/2,pi]))\narray([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16])\n>>>\n>>> # Example of providing the optional output parameter illustrating\n>>> # that what is returned is a reference to said parameter\n>>> out1 = np.array([0], dtype='d')\n>>> out2 = np.cos([0.1], out1)\n>>> out2 is out1\nTrue\n>>>\n>>> # Example of ValueError due to provision of shape mis-matched `out`\n>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))\nTraceback (most recent call last):\nFile \"\", line 1, in \nValueError: operands could not be broadcast together with shapes (3,3) (2,2)\n\ntanh = \ntanh(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nCompute hyperbolic tangent element-wise.\n\nEquivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``.\n\nParameters\n----------\nx : arraylike\nInput array.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray\nThe corresponding hyperbolic tangent values.\nThis is a scalar if `x` is a scalar.\n\nNotes\n-----\nIf `out` is provided, the function writes the result into it,\nand returns a reference to `out`. (See Examples)\n\nReferences\n----------\n.. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.\nNew York, NY: Dover, 1972, pg. 83.\nhttp://www.math.sfu.ca/~cbm/aands/\n\n.. [2] Wikipedia, \"Hyperbolic function\",\nhttps://en.wikipedia.org/wiki/Hyperbolicfunction\n\nExamples\n--------\n>>> np.tanh((0, np.pi*1j, np.pi*1j/2))\narray([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j])\n\n>>> # Example of providing the optional output parameter illustrating\n>>> # that what is returned is a reference to said parameter\n>>> out1 = np.array([0], dtype='d')\n>>> out2 = np.tanh([0.1], out1)\n>>> out2 is out1\nTrue\n\n>>> # Example of ValueError due to provision of shape mis-matched `out`\n>>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))\nTraceback (most recent call last):\nFile \"\", line 1, in \nValueError: operands could not be broadcast together with shapes (3,3) (2,2)\n\ntracemallocdomain = 389047\ntruedivide = \ntruedivide(x1, x2, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturns a true division of the inputs, element-wise.\n\nInstead of the Python traditional 'floor division', this returns a true\ndivision. True division adjusts the output type to present the best\nanswer, regardless of input types.\n\nParameters\n----------\nx1 : arraylike\nDividend array.\nx2 : arraylike\nDivisor array.\nIf ``x1.shape != x2.shape``, they must be broadcastable to a common\nshape (which becomes the shape of the output).\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\nout : ndarray or scalar\nThis is a scalar if both `x1` and `x2` are scalars.\n\nNotes\n-----\nIn Python, ``//`` is the floor division operator and ``/`` the\ntrue division operator. The ``truedivide(x1, x2)`` function is\nequivalent to true division in Python.\n\nExamples\n--------\n>>> x = np.arange(5)\n>>> np.truedivide(x, 4)\narray([ 0. , 0.25, 0.5 , 0.75, 1. ])\n\n>>> x/4\narray([ 0. , 0.25, 0.5 , 0.75, 1. ])\n\n>>> x//4\narray([0, 0, 0, 0, 1])\n\nThe ``/`` operator can be used as a shorthand for ``np.truedivide`` on\nndarrays.\n\n>>> x = np.arange(5)\n>>> x / 4\narray([0. , 0.25, 0.5 , 0.75, 1. ])\n\ntrunc = \ntrunc(x, /, out=None, *, where=True, casting='samekind', order='K', dtype=None, subok=True[, signature, extobj])\n\nReturn the truncated value of the input, element-wise.\n\nThe truncated value of the scalar `x` is the nearest integer `i` which\nis closer to zero than `x` is. In short, the fractional part of the\nsigned number `x` is discarded.\n\nParameters\n----------\nx : arraylike\nInput data.\nout : ndarray, None, or tuple of ndarray and None, optional\nA location into which the result is stored. If provided, it must have\na shape that the inputs broadcast to. If not provided or None,\na freshly-allocated array is returned. A tuple (possible only as a\nkeyword argument) must have length equal to the number of outputs.\nwhere : arraylike, optional\nThis condition is broadcast over the input. At locations where the\ncondition is True, the `out` array will be set to the ufunc result.\nElsewhere, the `out` array will retain its original value.\nNote that if an uninitialized `out` array is created via the default\n``out=None``, locations within it where the condition is False will\nremain uninitialized.\nkwargs\nFor other keyword-only arguments, see the\n:ref:`ufunc docs `.\n\nReturns\n-------\ny : ndarray or scalar\nThe truncated value of each element in `x`.\nThis is a scalar if `x` is a scalar.\n\nSee Also\n--------\nceil, floor, rint, fix\n\nNotes\n-----\n.. versionadded:: 1.3.0\n\nExamples\n--------\n>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])\n>>> np.trunc(a)\narray([-1., -1., -0., 0., 1., 1., 2.])\n\ntypecodes = {'All': '?bhilqpBHILQPefdgFDGSUVOMm', 'AllFloat': 'efdgFDG...\n" } ] }, "VERSION": { "content": "1.21.5\n", "subsections": [] }, "FILE": { "content": "/usr/lib/python3/dist-packages/numpy/init.py\n\n", "subsections": [] } }, "summary": "numpy", "flags": [], "examples": [], "see_also": [] }