{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"## Tutorial\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is a text!"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World!\n"
]
}
],
"source": [
"\n",
"print (\"Hello World!\")"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Populating the interactive namespace from numpy and matplotlib\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"WARNING: pylab import has clobbered these variables: ['f']\n",
"`%matplotlib` prevents importing * from pylab and numpy\n"
]
}
],
"source": [
"%pylab inline"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"%quickref\n",
"\n",
"x = 10\n",
"x?\n"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on int object:\n",
"\n",
"class int(object)\n",
" | int(x=0) -> integer\n",
" | int(x, base=10) -> integer\n",
" | \n",
" | Convert a number or string to an integer, or return 0 if no arguments\n",
" | are given. If x is a number, return x.__int__(). For floating point\n",
" | numbers, this truncates towards zero.\n",
" | \n",
" | If x is not a number or if base is given, then x must be a string,\n",
" | bytes, or bytearray instance representing an integer literal in the\n",
" | given base. The literal can be preceded by '+' or '-' and be surrounded\n",
" | by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.\n",
" | Base 0 means to interpret the base from the string as an integer literal.\n",
" | >>> int('0b100', base=0)\n",
" | 4\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",
" | self != 0\n",
" | \n",
" | __ceil__(...)\n",
" | Ceiling of an Integral returns itself.\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",
" | __floor__(...)\n",
" | Flooring an Integral returns itself.\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",
" | __getattribute__(self, name, /)\n",
" | Return getattr(self, name).\n",
" | \n",
" | __getnewargs__(...)\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",
" | __sizeof__(...)\n",
" | Returns size 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",
" | __trunc__(...)\n",
" | Truncating an Integral returns itself.\n",
" | \n",
" | __xor__(self, value, /)\n",
" | Return self^value.\n",
" | \n",
" | bit_length(...)\n",
" | int.bit_length() -> int\n",
" | \n",
" | Number of bits necessary to represent self in binary.\n",
" | >>> bin(37)\n",
" | '0b100101'\n",
" | >>> (37).bit_length()\n",
" | 6\n",
" | \n",
" | conjugate(...)\n",
" | Returns self, the complex conjugate of any int.\n",
" | \n",
" | from_bytes(...) from builtins.type\n",
" | int.from_bytes(bytes, byteorder, *, signed=False) -> int\n",
" | \n",
" | Return the integer represented by the given array of bytes.\n",
" | \n",
" | The bytes argument must be a bytes-like object (e.g. bytes or bytearray).\n",
" | \n",
" | The byteorder argument determines the byte order used to represent the\n",
" | integer. If byteorder is 'big', the most significant byte is at the\n",
" | beginning of the byte array. If byteorder is 'little', the most\n",
" | significant byte is at the end of the byte array. To request the native\n",
" | byte order of the host system, use `sys.byteorder' as the byte order value.\n",
" | \n",
" | The signed keyword-only argument indicates whether two's complement is\n",
" | used to represent the integer.\n",
" | \n",
" | to_bytes(...)\n",
" | int.to_bytes(length, byteorder, *, signed=False) -> bytes\n",
" | \n",
" | Return an array of bytes representing an integer.\n",
" | \n",
" | The integer is represented using length bytes. An OverflowError is\n",
" | raised if the integer is not representable with the given number of\n",
" | bytes.\n",
" | \n",
" | The byteorder argument determines the byte order used to represent the\n",
" | integer. If byteorder is 'big', the most significant byte is at the\n",
" | beginning of the byte array. If byteorder is 'little', the most\n",
" | significant byte is at the end of the byte array. To request the native\n",
" | byte order of the host system, use `sys.byteorder' as the byte order value.\n",
" | \n",
" | The signed keyword-only argument determines whether two's complement is\n",
" | used to represent the integer. If signed is False and a negative integer\n",
" | is given, an OverflowError is raised.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors defined here:\n",
" | \n",
" | denominator\n",
" | the denominator of a rational number in lowest terms\n",
" | \n",
" | imag\n",
" | the imaginary part of a complex number\n",
" | \n",
" | numerator\n",
" | the numerator of a rational number in lowest terms\n",
" | \n",
" | real\n",
" | the real part of a complex number\n",
"\n"
]
}
],
"source": [
"help(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Send commands to your operating system."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Datentr„ger in Laufwerk C: ist System\n",
" Volumeseriennummer: 9492-2740\n",
"\n",
" Verzeichnis von C:\\Users\\wagnerca\\Dropbox\\LEHRE\\LV CompSocSci Koblenz Slides\\2017-uebung\\tutorials\n",
"\n",
"26.04.2017 14:23 .\n",
"26.04.2017 14:23 ..\n",
"24.04.2017 13:37 .ipynb_checkpoints\n",
"26.04.2017 10:07 141 data.txt\n",
"15.06.2016 16:38 223.771 network-epidemics-tutorial.ipynb\n",
"07.06.2016 15:08 56.413 network-epidemics-tutorial-fariba.ipynb\n",
"07.06.2016 18:03 15.793 networks-null-models.ipynb\n",
"24.04.2017 13:36 232.559 Pandas-Stats-Tutorial.ipynb\n",
"06.06.2016 17:10 115.165 SIR-tutorial.ipynb\n",
"26.04.2017 14:23 test\n",
"26.04.2017 11:20 60 test.txt\n",
"26.04.2017 14:21 42.962 Tutorial-basic-python.ipynb\n",
" 8 Datei(en), 686.864 Bytes\n",
" 4 Verzeichnis(se), 285.576.638.464 Bytes frei\n"
]
}
],
"source": [
"%mkdir test\n",
"%ls"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"{'ACPATH': 'C:\\\\Program Files (x86)\\\\Lenovo\\\\Access Connections\\\\',\n",
" 'ALLUSERSPROFILE': 'C:\\\\ProgramData',\n",
" 'APPDATA': 'C:\\\\Users\\\\wagnerca\\\\AppData\\\\Roaming',\n",
" 'ASL.LOG': 'Destination=file',\n",
" 'CLICOLOR': '1',\n",
" 'COMMONPROGRAMFILES': 'C:\\\\Program Files\\\\Common Files',\n",
" 'COMMONPROGRAMFILES(X86)': 'C:\\\\Program Files (x86)\\\\Common Files',\n",
" 'COMMONPROGRAMW6432': 'C:\\\\Program Files\\\\Common Files',\n",
" 'COMMPATH': 'C:\\\\Program Files\\\\Lenovo\\\\Communications Utility',\n",
" 'COMPUTERNAME': 'KOL16003',\n",
" 'COMSPEC': 'C:\\\\Windows\\\\system32\\\\cmd.exe',\n",
" 'EXECIGNORE': '*.dll',\n",
" 'FP_NO_HOST_CHECK': 'NO',\n",
" 'GIT_PAGER': 'cat',\n",
" 'HOME': 'C:\\\\cygwin64\\\\home\\\\wagnerca',\n",
" 'HOMEDRIVE': 'C:',\n",
" 'HOMEPATH': '\\\\Users\\\\wagnerca',\n",
" 'HOSTNAME': 'KOL16003',\n",
" 'INFOPATH': '/usr/local/info:/usr/share/info:/usr/info',\n",
" 'IPY_INTERRUPT_EVENT': '1372',\n",
" 'JPY_INTERRUPT_EVENT': '1372',\n",
" 'JPY_PARENT_PID': '1368',\n",
" 'LANG': 'de_DE.UTF-8',\n",
" 'LOCALAPPDATA': 'C:\\\\Users\\\\wagnerca\\\\AppData\\\\Local',\n",
" 'LOGONSERVER': '\\\\\\\\SVKODC03',\n",
" 'NUMBER_OF_PROCESSORS': '4',\n",
" 'OLDPWD': '/cygdrive/c/Users/wagnerca/Dropbox/LEHRE',\n",
" 'ORIGINAL_PATH': '/cygdrive/c/ProgramData/Oracle/Java/javapath:/cygdrive/c/Program Files (x86)/Intel/iCLS Client:/cygdrive/c/Program Files/Intel/iCLS Client:/cygdrive/c/Windows/system32:/cygdrive/c/Windows:/cygdrive/c/Windows/System32/Wbem:/cygdrive/c/Windows/System32/WindowsPowerShell/v1.0:/cygdrive/c/Program Files/Intel/WiFi/bin:/cygdrive/c/Program Files/Common Files/Intel/WirelessCommon:/cygdrive/c/Program Files/Lenovo/Fingerprint Manager Pro:/cygdrive/c/Program Files/Intel/Intel(R) Management Engine Components/DAL:/cygdrive/c/Program Files (x86)/Intel/Intel(R) Management Engine Components/DAL:/cygdrive/c/Program Files/Intel/Intel(R) Management Engine Components/IPT:/cygdrive/c/Program Files (x86)/Intel/Intel(R) Management Engine Components/IPT:/cygdrive/c/Program Files (x86)/Lenovo/Access Connections:/cygdrive/c/Program Files/Git/cmd:/cygdrive/c/Program Files (x86)/Windows Kits/8.1/Windows Performance Toolkit:/cygdrive/c/Program Files (x86)/Skype/Phone:/cygdrive/c/Users/wagnerca/AppData/Local/Continuum/Anaconda3:/cygdrive/c/Users/wagnerca/AppData/Local/Continuum/Anaconda3/Scripts:/cygdrive/c/Users/wagnerca/AppData/Local/Continuum/Anaconda3/Library/bin',\n",
" 'OS': 'Windows_NT',\n",
" 'PAGER': 'cat',\n",
" 'PATH': 'C:\\\\Users\\\\wagnerca\\\\AppData\\\\Local\\\\Continuum\\\\Anaconda3\\\\Library\\\\bin;C:\\\\Users\\\\wagnerca\\\\AppData\\\\Local\\\\Continuum\\\\Anaconda3\\\\Library\\\\bin;C:\\\\cygwin64\\\\usr\\\\local\\\\bin;C:\\\\cygwin64\\\\bin;C:\\\\ProgramData\\\\Oracle\\\\Java\\\\javapath;C:\\\\Program Files (x86)\\\\Intel\\\\iCLS Client;C:\\\\Program Files\\\\Intel\\\\iCLS Client;C:\\\\Windows\\\\system32;C:\\\\Windows;C:\\\\Windows\\\\System32\\\\Wbem;C:\\\\Windows\\\\System32\\\\WindowsPowerShell\\\\v1.0;C:\\\\Program Files\\\\Intel\\\\WiFi\\\\bin;C:\\\\Program Files\\\\Common Files\\\\Intel\\\\WirelessCommon;C:\\\\Program Files\\\\Lenovo\\\\Fingerprint Manager Pro;C:\\\\Program Files\\\\Intel\\\\Intel(R) Management Engine Components\\\\DAL;C:\\\\Program Files (x86)\\\\Intel\\\\Intel(R) Management Engine Components\\\\DAL;C:\\\\Program Files\\\\Intel\\\\Intel(R) Management Engine Components\\\\IPT;C:\\\\Program Files (x86)\\\\Intel\\\\Intel(R) Management Engine Components\\\\IPT;C:\\\\Program Files (x86)\\\\Lenovo\\\\Access Connections;C:\\\\Program Files\\\\Git\\\\cmd;C:\\\\Program Files (x86)\\\\Windows Kits\\\\8.1\\\\Windows Performance Toolkit;C:\\\\Program Files (x86)\\\\Skype\\\\Phone;C:\\\\Users\\\\wagnerca\\\\AppData\\\\Local\\\\Continuum\\\\Anaconda3;C:\\\\Users\\\\wagnerca\\\\AppData\\\\Local\\\\Continuum\\\\Anaconda3\\\\Scripts;C:\\\\Users\\\\wagnerca\\\\AppData\\\\Local\\\\Continuum\\\\Anaconda3\\\\Library\\\\bin;C:\\\\cygwin64\\\\lib\\\\lapack',\n",
" 'PATHEXT': '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC',\n",
" 'PRINTER': 'Send To OneNote 2016',\n",
" 'PROCESSOR_ARCHITECTURE': 'AMD64',\n",
" 'PROCESSOR_IDENTIFIER': 'Intel64 Family 6 Model 61 Stepping 4, GenuineIntel',\n",
" 'PROCESSOR_LEVEL': '6',\n",
" 'PROCESSOR_REVISION': '3d04',\n",
" 'PROFILEREAD': 'true',\n",
" 'PROGRAMDATA': 'C:\\\\ProgramData',\n",
" 'PROGRAMFILES': 'C:\\\\Program Files',\n",
" 'PROGRAMFILES(X86)': 'C:\\\\Program Files (x86)',\n",
" 'PROGRAMW6432': 'C:\\\\Program Files',\n",
" 'PS1': '\\\\[\\\\e]0;\\\\w\\\\a\\\\]\\\\n\\\\[\\\\e[32m\\\\]\\\\u@\\\\h \\\\[\\\\e[33m\\\\]\\\\w\\\\[\\\\e[0m\\\\]\\\\n\\\\$ ',\n",
" 'PSMODULEPATH': 'C:\\\\Windows\\\\system32\\\\WindowsPowerShell\\\\v1.0\\\\Modules\\\\',\n",
" 'PUBLIC': 'C:\\\\Users\\\\Public',\n",
" 'PWD': '/cygdrive/c/Users/wagnerca/Dropbox/LEHRE/LV CompSocSci Koblenz Slides',\n",
" 'SESSIONNAME': 'Console',\n",
" 'SHELL': '/bin/bash',\n",
" 'SHLVL': '1',\n",
" 'SYSTEMDRIVE': 'C:',\n",
" 'SYSTEMROOT': 'C:\\\\Windows',\n",
" 'TEMP': 'C:\\\\cygwin64\\\\tmp',\n",
" 'TERM': 'xterm-color',\n",
" 'TMP': 'C:\\\\cygwin64\\\\tmp',\n",
" 'TVT': 'C:\\\\Program Files (x86)\\\\Lenovo',\n",
" 'TZ': 'Europe/Berlin',\n",
" 'USER': 'wagnerca',\n",
" 'USERDNSDOMAIN': 'GESIS.INTRA',\n",
" 'USERDOMAIN': 'GESIS',\n",
" 'USERNAME': 'wagnerca',\n",
" 'USERPROFILE': 'C:\\\\Users\\\\wagnerca',\n",
" 'VS140COMNTOOLS': 'C:\\\\Program Files (x86)\\\\Microsoft Visual Studio 14.0\\\\Common7\\\\Tools\\\\',\n",
" 'WINDIR': 'C:\\\\Windows',\n",
" 'WINDOWS_TRACING_FLAGS': '3',\n",
" 'WINDOWS_TRACING_LOGFILE': 'C:\\\\BVTBin\\\\Tests\\\\installpackage\\\\csilogfile.log',\n",
" '_': '/cygdrive/c/Users/wagnerca/AppData/Local/Continuum/Anaconda3/Scripts/ipython'}"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\n",
"%env"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"%%bash \n",
"echo \"Hello World!\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"AWK is standard feature of most unix systems and is a programming language for text processing.\n",
"\n",
"awk pattern {action}"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"col1row1 col2row1 col3row1 \n",
"col1row2 col2row2 col3row2\n",
"col1row3 col2row3 col3row3\n",
"col1row4 col2row4 col3row4\n",
"col1row5 col2row5 col3row5\n"
]
}
],
"source": [
"%%bash\n",
"awk '{print;}' data.txt"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"col1row1\n",
"col3row1\n",
"col1row2\n",
"col3row2\n",
"col1row3\n",
"col3row3\n",
"col1row4\n",
"col3row4\n",
"col1row5\n",
"col3row5\n"
]
}
],
"source": [
"%%bash\n",
"awk '{print $1; print $3;}' data.txt"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"$1\t$3\n",
"$1\t$3\n",
"$1\t$3\n",
"$1\t$3\n",
"$1\t$3\n"
]
}
],
"source": [
"%%bash\n",
"awk '{print \"$1\\t$3\";}' data.txt # inside quotes $ sign is not a special character"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"col1row1\tcol3row1\n",
"col1row2\tcol3row2\n",
"col1row3\tcol3row3\n",
"col1row4\tcol3row4\n",
"col1row5\tcol3row5\n"
]
}
],
"source": [
"%%bash\n",
"awk '{print $1\"\\t\"$3;}' data.txt # inside quotes $ sign is not a special character"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Autocompletion via Tab-Space"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import numpy as np\n",
"# load package"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# ready to explore!\n",
"# if it doesnt work look at pyreadline\n",
"np.st"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on package numpy:\n",
"\n",
"NAME\n",
" numpy\n",
"\n",
"DESCRIPTION\n",
" NumPy\n",
" =====\n",
" \n",
" Provides\n",
" 1. An array object of arbitrary homogeneous items\n",
" 2. Fast mathematical operations over arrays\n",
" 3. Linear Algebra, Fourier Transforms, Random Number Generation\n",
" \n",
" How to use the documentation\n",
" ----------------------------\n",
" Documentation is available in two forms: docstrings provided\n",
" with the code, and a loose standing reference guide, available from\n",
" `the NumPy homepage `_.\n",
" \n",
" We recommend exploring the docstrings using\n",
" `IPython `_, an advanced Python shell with\n",
" TAB-completion and introspection capabilities. See below for further\n",
" instructions.\n",
" \n",
" The docstring examples assume that `numpy` has been imported as `np`::\n",
" \n",
" >>> import numpy as np\n",
" \n",
" Code snippets are indicated by three greater-than signs::\n",
" \n",
" >>> x = 42\n",
" >>> x = x + 1\n",
" \n",
" Use the built-in ``help`` function to view a function's docstring::\n",
" \n",
" >>> help(np.sort)\n",
" ... # doctest: +SKIP\n",
" \n",
" For some objects, ``np.info(obj)`` may provide additional help. This is\n",
" particularly true if you see the line \"Help on ufunc object:\" at the top\n",
" of the help() page. Ufuncs are implemented in C, not Python, for speed.\n",
" The native Python help() does not know how to view their help, but our\n",
" np.info() function does.\n",
" \n",
" To search for documents containing a keyword, do::\n",
" \n",
" >>> np.lookfor('keyword')\n",
" ... # doctest: +SKIP\n",
" \n",
" General-purpose documents like a glossary and help on the basic concepts\n",
" of numpy are available under the ``doc`` sub-module::\n",
" \n",
" >>> from numpy import doc\n",
" >>> help(doc)\n",
" ... # doctest: +SKIP\n",
" \n",
" Available subpackages\n",
" ---------------------\n",
" doc\n",
" Topical documentation on broadcasting, indexing, etc.\n",
" lib\n",
" Basic functions used by several sub-packages.\n",
" random\n",
" Core Random Tools\n",
" linalg\n",
" Core Linear Algebra Tools\n",
" fft\n",
" Core FFT routines\n",
" polynomial\n",
" Polynomial tools\n",
" testing\n",
" Numpy testing tools\n",
" f2py\n",
" Fortran to Python Interface Generator.\n",
" distutils\n",
" Enhancements to distutils with support for\n",
" Fortran compilers support and more.\n",
" \n",
" Utilities\n",
" ---------\n",
" test\n",
" Run numpy unittests\n",
" show_config\n",
" Show numpy build configuration\n",
" dual\n",
" Overwrite certain functions with high-performance Scipy tools\n",
" matlib\n",
" Make everything matrices.\n",
" __version__\n",
" Numpy version string\n",
" \n",
" Viewing documentation using IPython\n",
" -----------------------------------\n",
" Start IPython with the NumPy profile (``ipython -p numpy``), which will\n",
" import `numpy` under the alias `np`. Then, use the ``cpaste`` command to\n",
" paste 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\n",
" down the list. To view the docstring for a function, use\n",
" ``np.cos?`` (to view the docstring) and ``np.cos??`` (to view\n",
" the source code).\n",
" \n",
" Copies vs. in-place operation\n",
" -----------------------------\n",
" Most 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\n",
" available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.\n",
" Exceptions to this rule are documented.\n",
"\n",
"PACKAGE CONTENTS\n",
" __config__\n",
" _import_tools\n",
" add_newdocs\n",
" compat (package)\n",
" core (package)\n",
" ctypeslib\n",
" distutils (package)\n",
" doc (package)\n",
" dual\n",
" f2py (package)\n",
" fft (package)\n",
" lib (package)\n",
" linalg (package)\n",
" ma (package)\n",
" matlib\n",
" matrixlib (package)\n",
" polynomial (package)\n",
" random (package)\n",
" setup\n",
" testing (package)\n",
" version\n",
"\n",
"SUBMODULES\n",
" _mat\n",
" char\n",
" emath\n",
" rec\n",
"\n",
"CLASSES\n",
" builtins.DeprecationWarning(builtins.Warning)\n",
" ModuleDeprecationWarning\n",
" builtins.RuntimeError(builtins.Exception)\n",
" numpy.core._internal.TooHardError\n",
" builtins.RuntimeWarning(builtins.Warning)\n",
" numpy.core.numeric.ComplexWarning\n",
" builtins.UserWarning(builtins.Warning)\n",
" VisibleDeprecationWarning\n",
" numpy.lib.polynomial.RankWarning\n",
" builtins.bytes(builtins.object)\n",
" bytes_(builtins.bytes, character)\n",
" builtins.object\n",
" builtins.int\n",
" builtins.str\n",
" str_(builtins.str, character)\n",
" broadcast\n",
" busdaycalendar\n",
" dtype\n",
" flatiter\n",
" generic\n",
" bool_\n",
" datetime64\n",
" flexible\n",
" character\n",
" bytes_(builtins.bytes, character)\n",
" void\n",
" record\n",
" number\n",
" inexact\n",
" complexfloating\n",
" complex128(complexfloating, builtins.complex)\n",
" complex128\n",
" complex64\n",
" floating\n",
" float16\n",
" float32\n",
" float64(floating, builtins.float)\n",
" float64\n",
" integer\n",
" signedinteger\n",
" int16\n",
" int32\n",
" int32\n",
" int64\n",
" int8\n",
" timedelta64\n",
" unsignedinteger\n",
" uint16\n",
" uint32\n",
" uint32\n",
" uint64\n",
" uint8\n",
" object_\n",
" ndarray\n",
" recarray\n",
" numpy.core.defchararray.chararray\n",
" numpy.core.memmap.memmap\n",
" numpy.matrixlib.defmatrix.matrix\n",
" nditer\n",
" ufunc\n",
" numpy._import_tools.PackageLoader\n",
" numpy.core.getlimits.finfo\n",
" numpy.core.getlimits.iinfo\n",
" numpy.core.machar.MachAr\n",
" numpy.core.numeric.errstate\n",
" numpy.core.records.format_parser\n",
" numpy.lib._datasource.DataSource\n",
" numpy.lib.function_base.vectorize\n",
" numpy.lib.index_tricks.ndenumerate\n",
" numpy.lib.index_tricks.ndindex\n",
" numpy.lib.polynomial.poly1d\n",
" \n",
" class ComplexWarning(builtins.RuntimeWarning)\n",
" | 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",
" | __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",
" | with_traceback(...)\n",
" | Exception.with_traceback(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",
" | __suppress_context__\n",
" | \n",
" | __traceback__\n",
" | \n",
" | args\n",
" \n",
" class DataSource(builtins.object)\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 = 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 = DataSource('/home/guido')\n",
" | >>> urlname = 'http://www.google.com/index.html'\n",
" | >>> gfile = ds.open('http://www.google.com/index.html') # remote file\n",
" | >>> ds.abspath(urlname)\n",
" | '/home/guido/www.google.com/site/index.html'\n",
" | \n",
" | >>> ds = DataSource(None) # use with temporary file\n",
" | >>> ds.open('/home/guido/foobar.txt')\n",
" | \n",
" | >>> ds.abspath('/home/guido/foobar.txt')\n",
" | '/tmp/tmpy4pgsP/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')\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",
" | \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",
" \n",
" class MachAr(builtins.object)\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 ``beta**machep`` (floating point precision)\n",
" | negep : int\n",
" | Exponent of the smallest power of `ibeta` that, substracted\n",
" | from 1.0, gives something different from 1.0.\n",
" | epsneg : float\n",
" | Floating-point number ``beta**negep``.\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 ``beta**minexp`` (the smallest [in\n",
" | magnitude] usable floating value).\n",
" | maxexp : int\n",
" | Smallest (positive) power of `ibeta` that causes overflow.\n",
" | xmax : float\n",
" | ``(1-epsneg) * beta**maxexp`` (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",
" | float_conv : function, optional\n",
" | Function that converts an integer or integer array to a float\n",
" | or float array. Default is `float`.\n",
" | int_conv : function, optional\n",
" | Function that converts a float or float array to an integer or\n",
" | integer array. Default is `int`.\n",
" | float_to_float : 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",
" | float_to_str : 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, float_conv=, int_conv=, float_to_float=, float_to_str= at 0x000000000466B400>, title='Python floating point number')\n",
" | float_conv - convert integer to float (array)\n",
" | int_conv - convert float (array) to integer\n",
" | float_to_float - convert float array to float\n",
" | float_to_str - 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",
" \n",
" class ModuleDeprecationWarning(builtins.DeprecationWarning)\n",
" | 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",
" | __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",
" | with_traceback(...)\n",
" | Exception.with_traceback(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",
" | __suppress_context__\n",
" | \n",
" | __traceback__\n",
" | \n",
" | args\n",
" \n",
" class PackageLoader(builtins.object)\n",
" | Methods defined here:\n",
" | \n",
" | __call__(self, *packages, **options)\n",
" | Load one or more packages into parent package top-level namespace.\n",
" | \n",
" | This function is intended to shorten the need to import many\n",
" | subpackages, say of scipy, constantly with statements such as\n",
" | \n",
" | import scipy.linalg, scipy.fftpack, scipy.etc...\n",
" | \n",
" | Instead, you can say:\n",
" | \n",
" | import scipy\n",
" | scipy.pkgload('linalg','fftpack',...)\n",
" | \n",
" | or\n",
" | \n",
" | scipy.pkgload()\n",
" | \n",
" | to load all of them in one call.\n",
" | \n",
" | If a name which doesn't exist in scipy's namespace is\n",
" | given, a warning is shown.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | *packages : arg-tuple\n",
" | the names (one or more strings) of all the modules one\n",
" | wishes to load into the top-level namespace.\n",
" | verbose= : integer\n",
" | verbosity level [default: -1].\n",
" | verbose=-1 will suspend also warnings.\n",
" | force= : bool\n",
" | when True, force reloading loaded packages [default: False].\n",
" | postpone= : bool\n",
" | when True, don't load packages [default: False]\n",
" | \n",
" | __init__(self, verbose=False, infunc=False)\n",
" | Manages loading packages.\n",
" | \n",
" | error(self, mess)\n",
" | \n",
" | get_pkgdocs(self)\n",
" | Return documentation summary of subpackages.\n",
" | \n",
" | log(self, mess)\n",
" | \n",
" | warn(self, mess)\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",
" class RankWarning(builtins.UserWarning)\n",
" | 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",
" | __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",
" | with_traceback(...)\n",
" | Exception.with_traceback(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",
" | __suppress_context__\n",
" | \n",
" | __traceback__\n",
" | \n",
" | args\n",
" \n",
" class TooHardError(builtins.RuntimeError)\n",
" | Unspecified run-time error.\n",
" | \n",
" | 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",
" | __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",
" | with_traceback(...)\n",
" | Exception.with_traceback(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",
" | __suppress_context__\n",
" | \n",
" | __traceback__\n",
" | \n",
" | args\n",
" \n",
" class VisibleDeprecationWarning(builtins.UserWarning)\n",
" | 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",
" | __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",
" | with_traceback(...)\n",
" | Exception.with_traceback(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",
" | __suppress_context__\n",
" | \n",
" | __traceback__\n",
" | \n",
" | args\n",
" \n",
" bool8 = class bool_(generic)\n",
" | Numpy's Boolean type. Character code: ``?``. Alias: 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",
" | self != 0\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",
" | __sizeof__() -> int\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",
" | all(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" class bool_(generic)\n",
" | Numpy's Boolean type. Character code: ``?``. Alias: 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",
" | self != 0\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",
" | __sizeof__() -> int\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",
" | all(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" class broadcast(builtins.object)\n",
" | Produce an object that mimics broadcasting.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | in1, in2, ... : array_like\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",
" | Examples\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",
" | __new__(*args, **kwargs) from builtins.type\n",
" | Create and return a new object. See help(type) for accurate signature.\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",
" | >>> b.next(), b.next(), b.next()\n",
" | ((1, 4), (2, 4), (3, 4))\n",
" | >>> b.index\n",
" | 3\n",
" | >>> b.reset()\n",
" | >>> b.index\n",
" | 0\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",
" | >>> b.next(), b.next(), b.next()\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",
" | >>> row.next(), col.next()\n",
" | (1, 4)\n",
" | \n",
" | nd\n",
" | Number of dimensions 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.nd\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",
" \n",
" class busdaycalendar(builtins.object)\n",
" | 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 array_like 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 : array_like 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",
" | is_busday : Returns a boolean array indicating valid days.\n",
" | busday_offset : Applies an offset counted in valid days.\n",
" | busday_count : 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], dtype='bool')\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",
" | __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",
" \n",
" byte = class int8(signedinteger)\n",
" | 8-bit integer. Character code ``b``. C char compatible.\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",
" | __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",
" | __rxor__(self, value, /)\n",
" | Return value^self.\n",
" | \n",
" | __setstate__(...)\n",
" | \n",
" | __sizeof__(...)\n",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" bytes0 = class bytes_(builtins.bytes, character)\n",
" | bytes(iterable_of_ints) -> bytes\n",
" | bytes(string, encoding[, errors]) -> bytes\n",
" | bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\n",
" | bytes(int) -> bytes object of size given by the parameter initialized with null bytes\n",
" | bytes() -> empty bytes object\n",
" | \n",
" | Construct an immutable array of bytes from:\n",
" | - an iterable yielding integers in range(256)\n",
" | - a text string encoded using the specified encoding\n",
" | - any object implementing the buffer API.\n",
" | - an integer\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(...)\n",
" | B.center(width[, fillchar]) -> copy of B\n",
" | \n",
" | Return B centered in a string of length width. Padding is\n",
" | done using the specified fill character (default is a space).\n",
" | \n",
" | count(...)\n",
" | B.count(sub[, start[, end]]) -> int\n",
" | \n",
" | Return the number of non-overlapping occurrences of substring sub in\n",
" | string 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.register_error 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(...)\n",
" | B.expandtabs(tabsize=8) -> copy of B\n",
" | \n",
" | Return a copy of B where all tab characters are expanded using spaces.\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 substring 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",
" | 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",
" | hex(...)\n",
" | B.hex() -> string\n",
" | \n",
" | Create a string of hexadecimal numbers from a bytes object.\n",
" | Example: b'\\xb9\\x01\\xef'.hex() -> 'b901ef'.\n",
" | \n",
" | index(...)\n",
" | B.index(sub[, start[, end]]) -> int\n",
" | \n",
" | Like B.find() but raise ValueError when the substring 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",
" | 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, iterable_of_bytes, /)\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(...)\n",
" | B.ljust(width[, fillchar]) -> copy of B\n",
" | \n",
" | Return B left justified in a string of length width. Padding is\n",
" | done using the specified fill character (default is a space).\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",
" | 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 substring 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",
" | Like B.rfind() but raise ValueError when the substring is not found.\n",
" | \n",
" | rjust(...)\n",
" | B.rjust(width[, fillchar]) -> copy of B\n",
" | \n",
" | Return B right justified in a string of length width. Padding is\n",
" | done using the specified fill character (default is a space)\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 and 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(...)\n",
" | translate(table, [deletechars])\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 deletechars 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(...)\n",
" | B.zfill(width) -> copy of B\n",
" | \n",
" | Pad a numeric string B with zeros on the left, to fill a field\n",
" | of the specified width. B is never truncated.\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__(|type) return 0-dim array\n",
" | \n",
" | __array_wrap__(...)\n",
" | sc.__array_wrap__(obj) return scalar from array\n",
" | \n",
" | __bool__(self, /)\n",
" | self != 0\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" class bytes_(builtins.bytes, character)\n",
" | bytes(iterable_of_ints) -> bytes\n",
" | bytes(string, encoding[, errors]) -> bytes\n",
" | bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\n",
" | bytes(int) -> bytes object of size given by the parameter initialized with null bytes\n",
" | bytes() -> empty bytes object\n",
" | \n",
" | Construct an immutable array of bytes from:\n",
" | - an iterable yielding integers in range(256)\n",
" | - a text string encoded using the specified encoding\n",
" | - any object implementing the buffer API.\n",
" | - an integer\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(...)\n",
" | B.center(width[, fillchar]) -> copy of B\n",
" | \n",
" | Return B centered in a string of length width. Padding is\n",
" | done using the specified fill character (default is a space).\n",
" | \n",
" | count(...)\n",
" | B.count(sub[, start[, end]]) -> int\n",
" | \n",
" | Return the number of non-overlapping occurrences of substring sub in\n",
" | string 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.register_error 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(...)\n",
" | B.expandtabs(tabsize=8) -> copy of B\n",
" | \n",
" | Return a copy of B where all tab characters are expanded using spaces.\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 substring 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",
" | 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",
" | hex(...)\n",
" | B.hex() -> string\n",
" | \n",
" | Create a string of hexadecimal numbers from a bytes object.\n",
" | Example: b'\\xb9\\x01\\xef'.hex() -> 'b901ef'.\n",
" | \n",
" | index(...)\n",
" | B.index(sub[, start[, end]]) -> int\n",
" | \n",
" | Like B.find() but raise ValueError when the substring 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",
" | 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, iterable_of_bytes, /)\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(...)\n",
" | B.ljust(width[, fillchar]) -> copy of B\n",
" | \n",
" | Return B left justified in a string of length width. Padding is\n",
" | done using the specified fill character (default is a space).\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",
" | 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 substring 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",
" | Like B.rfind() but raise ValueError when the substring is not found.\n",
" | \n",
" | rjust(...)\n",
" | B.rjust(width[, fillchar]) -> copy of B\n",
" | \n",
" | Return B right justified in a string of length width. Padding is\n",
" | done using the specified fill character (default is a space)\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 and 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(...)\n",
" | translate(table, [deletechars])\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 deletechars 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(...)\n",
" | B.zfill(width) -> copy of B\n",
" | \n",
" | Pad a numeric string B with zeros on the left, to fill a field\n",
" | of the specified width. B is never truncated.\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__(|type) return 0-dim array\n",
" | \n",
" | __array_wrap__(...)\n",
" | sc.__array_wrap__(obj) return scalar from array\n",
" | \n",
" | __bool__(self, /)\n",
" | self != 0\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" cdouble = class complex128(complexfloating, builtins.complex)\n",
" | Composed of two 64 bit floats\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",
" | __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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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__(...)\n",
" \n",
" cfloat = class complex128(complexfloating, builtins.complex)\n",
" | Composed of two 64 bit floats\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",
" | __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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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__(...)\n",
" \n",
" class character(flexible)\n",
" | Base class for numpy scalar types.\n",
" | \n",
" | Class from which most (all?) numpy scalar types are derived. For\n",
" | consistency, exposes the same API as `ndarray`, despite many\n",
" | consequent attributes being either \"get-only,\" or completely irrelevant.\n",
" | This is the class from which it is strongly suggested users should derive\n",
" | custom 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__(|type) return 0-dim array\n",
" | \n",
" | __array_wrap__(...)\n",
" | sc.__array_wrap__(obj) return scalar from array\n",
" | \n",
" | __bool__(self, /)\n",
" | self != 0\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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",
" \n",
" class chararray(numpy.ndarray)\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='Fortran'``, 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 : int, 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 : array_like 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([['a', 'a', 'a'],\n",
" | ['a', 'a', 'a'],\n",
" | ['a', 'a', 'a']],\n",
" | dtype='|S1')\n",
" | \n",
" | >>> charar = np.chararray(charar.shape, itemsize=5)\n",
" | >>> charar[:] = 'abc'\n",
" | >>> charar\n",
" | chararray([['abc', 'abc', 'abc'],\n",
" | ['abc', 'abc', 'abc'],\n",
" | ['abc', 'abc', 'abc']],\n",
" | dtype='|S5')\n",
" | \n",
" | Method resolution order:\n",
" | chararray\n",
" | numpy.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 array_likes of str or unicode.\n",
" | \n",
" | See also\n",
" | --------\n",
" | add\n",
" | \n",
" | __array_finalize__(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",
" | greater_equal\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",
" | less_equal\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",
" | (iterpolation), element-wise for a pair of array_likes 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",
" | not_equal\n",
" | \n",
" | __radd__(self, other)\n",
" | Return (other + self), that is string concatenation,\n",
" | element-wise for a pair of array_likes 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='quicksort', order=None)\n",
" | a.argsort(axis=-1, kind='quicksort', 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 numpy.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",
" | __array_prepare__(...)\n",
" | a.__array_prepare__(obj) -> Object of same type as ndarray object obj.\n",
" | \n",
" | __array_wrap__(...)\n",
" | a.__array_wrap__(obj) -> Object of same type as ndarray object a.\n",
" | \n",
" | __bool__(self, /)\n",
" | self != 0\n",
" | \n",
" | __contains__(self, key, /)\n",
" | Return key in self.\n",
" | \n",
" | __copy__(...)\n",
" | a.__copy__([order])\n",
" | \n",
" | Return a copy of the array.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | order : {'C', 'F', 'A'}, optional\n",
" | If order is 'C' (False) then the result is contiguous (default).\n",
" | If order is 'Fortran' (True) then the result has fortran order.\n",
" | If order is 'Any' (None) then the result has fortran order\n",
" | only if the array already is in fortran order.\n",
" | \n",
" | __deepcopy__(...)\n",
" | a.__deepcopy__() -> Deep copy of array.\n",
" | \n",
" | Used if 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",
" | __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__(version, shape, dtype, isfortran, rawdata)\n",
" | \n",
" | For unpickling.\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",
" | __sizeof__() -> int\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)\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)\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 of `a`.\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', 'same_kind', '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",
" | * 'same_kind' 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",
" | arr_t : ndarray\n",
" | Unless `copy` is False and the other conditions for returning the input\n",
" | array are satisfied (see description for `copy` input parameter), `arr_t`\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",
" | Starting in NumPy 1.9, astype method now returns an error if the string\n",
" | dtype to cast to is not long enough in 'safe' casting mode to hold the max\n",
" | value of integer/float array that is being casted. Previously the casting\n",
" | was allowed even if the result was truncated.\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)\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",
" | \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",
" | >>> map(hex, A)\n",
" | ['0x1', '0x100', '0x2233']\n",
" | >>> A.byteswap(True)\n",
" | array([ 256, 1, 13090], dtype=int16)\n",
" | >>> map(hex, A)\n",
" | ['0x100', '0x1', '0x3322']\n",
" | \n",
" | Arrays of strings are not swapped\n",
" | \n",
" | >>> A = np.array(['ceg', 'fac'])\n",
" | >>> A.byteswap()\n",
" | array(['ceg', 'fac'],\n",
" | dtype='|S3')\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)\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.)\n",
" | \n",
" | See also\n",
" | --------\n",
" | numpy.copy\n",
" | numpy.copyto\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['C_CONTIGUOUS']\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\n",
" | A string naming the dump file.\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",
" | * int_type: this argument is interpreted as a flat index into\n",
" | the array, specifying which element to copy and return.\n",
" | \n",
" | * tuple of int_types: functions as does a single int_type 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",
" | >>> x = np.random.randint(9, size=(3, 3))\n",
" | >>> x\n",
" | array([[3, 1, 7],\n",
" | [2, 8, 3],\n",
" | [8, 5, 3]])\n",
" | >>> x.item(3)\n",
" | 2\n",
" | >>> x.item(7)\n",
" | 5\n",
" | >>> x.item((0, 1))\n",
" | 1\n",
" | >>> x.item((2, 2))\n",
" | 3\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",
" | >>> x = np.random.randint(9, size=(3, 3))\n",
" | >>> x\n",
" | array([[3, 1, 7],\n",
" | [2, 8, 3],\n",
" | [8, 5, 3]])\n",
" | >>> x.itemset(4, 0)\n",
" | >>> x.itemset((2, 2), 9)\n",
" | >>> x\n",
" | array([[3, 1, 7],\n",
" | [2, 0, 3],\n",
" | [8, 5, 9]])\n",
" | \n",
" | max(...)\n",
" | a.max(axis=None, out=None)\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)\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)\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(new_order='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(new_order))\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",
" | new_order : string, optional\n",
" | Byte order to force; a value from the byte order specifications\n",
" | below. `new_order` codes can be any of:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | The default value ('S') results in swapping the current\n",
" | byte order. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_arr : 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)\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)\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",
" | resize(...)\n",
" | a.resize(new_shape, refcheck=True)\n",
" | \n",
" | Change shape and size of array in-place.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_shape : 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",
" | \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) # new_shape 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 has been 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]])\n",
" | >>> x\n",
" | array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323],\n",
" | [ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323],\n",
" | [ 1.48219694e-323, 1.48219694e-323, 1.00000000e+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, and UPDATEIFCOPY, 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 UPDATEIFCOPY flag can never be set to True. The flag WRITEABLE\n",
" | can only be set to True if the array owns its own memory, or the\n",
" | ultimate owner of the memory exposes a writeable buffer interface,\n",
" | or is a string. (The exception for string is made so that unpickling\n",
" | 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 6 Boolean flags\n",
" | in use, only three of which can be changed by the user:\n",
" | 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) this array is a copy of some other array (referenced\n",
" | by .base). When this array is deallocated, the base array will be\n",
" | updated with the contents of this array.\n",
" | \n",
" | All flags can be accessed using their first (upper case) letter as well\n",
" | as the full name.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> y\n",
" | array([[3, 1, 7],\n",
" | [2, 0, 0],\n",
" | [8, 5, 9]])\n",
" | >>> y.flags\n",
" | C_CONTIGUOUS : True\n",
" | F_CONTIGUOUS : False\n",
" | OWNDATA : True\n",
" | WRITEABLE : True\n",
" | ALIGNED : True\n",
" | UPDATEIFCOPY : False\n",
" | >>> y.setflags(write=0, align=0)\n",
" | >>> y.flags\n",
" | C_CONTIGUOUS : True\n",
" | F_CONTIGUOUS : False\n",
" | OWNDATA : True\n",
" | WRITEABLE : False\n",
" | ALIGNED : False\n",
" | UPDATEIFCOPY : False\n",
" | >>> y.setflags(uic=1)\n",
" | Traceback (most recent call last):\n",
" | File \"\", line 1, in \n",
" | ValueError: cannot set UPDATEIFCOPY flag to True\n",
" | \n",
" | sort(...)\n",
" | a.sort(axis=-1, kind='quicksort', order=None)\n",
" | \n",
" | Sort an array, in-place.\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'}, optional\n",
" | Sorting algorithm. Default is 'quicksort'.\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",
" | argsort : Indirect sort.\n",
" | lexsort : Indirect stable sort on multiple keys.\n",
" | searchsorted : Find elements in sorted array.\n",
" | partition: Partial sort.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | See ``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([('c', 1), ('a', 2)],\n",
" | dtype=[('x', '|S1'), ('y', '>> x = np.array([[0, 1], [2, 3]])\n",
" | >>> x.tobytes()\n",
" | b'\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x03\\x00\\x00\\x00'\n",
" | >>> x.tobytes('C') == x.tobytes()\n",
" | True\n",
" | >>> x.tobytes('F')\n",
" | b'\\x00\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x03\\x00\\x00\\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\n",
" | An open file object, or a string containing a filename.\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",
" | tolist(...)\n",
" | a.tolist()\n",
" | \n",
" | Return the array as a (possibly nested) list.\n",
" | \n",
" | Return a copy of the array data as a (nested) Python list.\n",
" | Data items are converted to the nearest compatible Python type.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | none\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : list\n",
" | The possibly nested list of array elements.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | The array may be recreated, ``a = np.array(a.tolist())``.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> a = np.array([1, 2])\n",
" | >>> a.tolist()\n",
" | [1, 2]\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",
" | tostring(...)\n",
" | a.tostring(order='C')\n",
" | \n",
" | Construct Python bytes containing the raw data bytes in the array.\n",
" | \n",
" | Constructs Python bytes showing a copy of the raw contents of\n",
" | data memory. The bytes object can be produced in either 'C' or 'Fortran',\n",
" | or 'Any' order (the default is 'C'-order). 'Any' order means C-order\n",
" | unless the F_CONTIGUOUS flag in the array is set, in which case it\n",
" | means 'Fortran' order.\n",
" | \n",
" | This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | order : {'C', 'F', None}, optional\n",
" | Order of the data for multidimensional arrays:\n",
" | C, Fortran, or the same as for the original array.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | s : bytes\n",
" | Python bytes exhibiting a copy of `a`'s raw data.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> x = np.array([[0, 1], [2, 3]])\n",
" | >>> x.tobytes()\n",
" | b'\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x03\\x00\\x00\\x00'\n",
" | >>> x.tobytes('C') == x.tobytes()\n",
" | True\n",
" | >>> x.tobytes('F')\n",
" | b'\\x00\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x03\\x00\\x00\\x00'\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. (To change between column and\n",
" | row vectors, first cast the 1-D array into a matrix object.)\n",
" | For a 2-D array, this is the usual 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",
" | ndarray.T : Array property returning the array transposed.\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)\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=None, type=None)\n",
" | \n",
" | New view of array with the same data.\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. The\n",
" | default, None, 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, the\n",
" | default None results in type preservation.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | ``a.view()`` is used two different ways:\n",
" | \n",
" | ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` 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(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just\n",
" | returns an instance of `ndarray_subclass` 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(some_dtype)``, if ``some_dtype`` 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",
" | >>> print(x)\n",
" | [(1, 20) (3, 4)]\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], 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",
" | File \"\", line 1, in \n",
" | ValueError: new type not compatible with array.\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",
" | __array_interface__\n",
" | Array protocol: Python side.\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\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",
" | * data: A pointer to the memory area of the array as a Python integer.\n",
" | This memory area may contain data that is not aligned, or not in correct\n",
" | byte-order. The memory area may not even be writeable. The array\n",
" | flags and data-type of this array should be respected when passing this\n",
" | attribute to arbitrary C-code to avoid trouble that can include Python\n",
" | crashing. User Beware! The value of this attribute is exactly the same\n",
" | as self._array_interface_['data'][0].\n",
" | \n",
" | * shape (c_intp*self.ndim): A ctypes array of length self.ndim where\n",
" | the basetype is the C-integer corresponding to dtype('p') on this\n",
" | platform. This base-type could be c_int, c_long, or c_longlong\n",
" | depending on the platform. The c_intp type is defined accordingly in\n",
" | numpy.ctypeslib. The ctypes array contains the shape of the underlying\n",
" | array.\n",
" | \n",
" | * strides (c_intp*self.ndim): A ctypes array of length self.ndim where\n",
" | the basetype is the same as for the shape attribute. This ctypes array\n",
" | contains the strides information from the underlying array. This strides\n",
" | information is important for showing how many bytes must be jumped to\n",
" | get to the next element in the array.\n",
" | \n",
" | * data_as(obj): Return the data pointer cast to a particular c-types object.\n",
" | For example, calling self._as_parameter_ is equivalent to\n",
" | self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a\n",
" | pointer to a ctypes array of floating-point data:\n",
" | self.data_as(ctypes.POINTER(ctypes.c_double)).\n",
" | \n",
" | * shape_as(obj): Return the shape tuple as an array of some other c-types\n",
" | type. For example: self.shape_as(ctypes.c_short).\n",
" | \n",
" | * strides_as(obj): Return the strides tuple as an array of some other\n",
" | c-types type. For example: self.strides_as(ctypes.c_longlong).\n",
" | \n",
" | Be careful using the ctypes attribute - especially on temporary\n",
" | arrays or arrays constructed on the fly. For example, calling\n",
" | ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory\n",
" | that is invalid because the array created as (a+b) is deallocated\n",
" | before the next Python statement. You can avoid this problem using\n",
" | either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will\n",
" | hold a reference to the array until ct is deleted or re-assigned.\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 as parameter attribute which will\n",
" | return an integer equal to the data attribute.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> import ctypes\n",
" | >>> x\n",
" | array([[0, 1],\n",
" | [2, 3]])\n",
" | >>> x.ctypes.data\n",
" | 30439712\n",
" | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))\n",
" | \n",
" | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents\n",
" | c_long(0)\n",
" | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents\n",
" | c_longlong(4294967296L)\n",
" | >>> x.ctypes.shape\n",
" | \n",
" | >>> x.ctypes.shape_as(ctypes.c_long)\n",
" | \n",
" | >>> x.ctypes.strides\n",
" | \n",
" | >>> x.ctypes.strides_as(ctypes.c_longlong)\n",
" | \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",
" | C_CONTIGUOUS (C)\n",
" | The data is in a single, C-style contiguous segment.\n",
" | F_CONTIGUOUS (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",
" | UPDATEIFCOPY (U)\n",
" | This array is a copy of some other array. When this array is\n",
" | deallocated, the base array will be updated with the contents of\n",
" | this array.\n",
" | FNC\n",
" | F_CONTIGUOUS and not C_CONTIGUOUS.\n",
" | FORC\n",
" | F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).\n",
" | BEHAVED (B)\n",
" | ALIGNED and WRITEABLE.\n",
" | CARRAY (CA)\n",
" | BEHAVED and C_CONTIGUOUS.\n",
" | FARRAY (FA)\n",
" | BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.\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 UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by\n",
" | the user, via direct assignment to the attribute or dictionary entry,\n",
" | or by calling `ndarray.setflags`.\n",
" | \n",
" | The array flags cannot be set arbitrarily:\n",
" | \n",
" | - UPDATEIFCOPY 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",
" | Notes\n",
" | -----\n",
" | May be used to \"reshape\" the array, as long as this would not\n",
" | require a change in the total number of elements\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",
" | \n",
" | size\n",
" | Number of elements in the array.\n",
" | \n",
" | Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's\n",
" | dimensions.\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.stride_tricks.as_strided\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",
" clongdouble = class complex128(complexfloating)\n",
" | Composed of two 64 bit floats\n",
" | \n",
" | Method resolution order:\n",
" | complex128\n",
" | complexfloating\n",
" | inexact\n",
" | number\n",
" | generic\n",
" | builtins.object\n",
" | \n",
" | Methods defined here:\n",
" | \n",
" | __complex__(...)\n",
" | \n",
" | __eq__(self, value, /)\n",
" | Return self==value.\n",
" | \n",
" | __float__(self, /)\n",
" | float(self)\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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" clongfloat = class complex128(complexfloating)\n",
" | Composed of two 64 bit floats\n",
" | \n",
" | Method resolution order:\n",
" | complex128\n",
" | complexfloating\n",
" | inexact\n",
" | number\n",
" | generic\n",
" | builtins.object\n",
" | \n",
" | Methods defined here:\n",
" | \n",
" | __complex__(...)\n",
" | \n",
" | __eq__(self, value, /)\n",
" | Return self==value.\n",
" | \n",
" | __float__(self, /)\n",
" | float(self)\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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" class complex128(complexfloating, builtins.complex)\n",
" | Composed of two 64 bit floats\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",
" | __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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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__(...)\n",
" \n",
" class complex64(complexfloating)\n",
" | Composed of two 32 bit floats\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",
" | __complex__(...)\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" complex_ = class complex128(complexfloating, builtins.complex)\n",
" | Composed of two 64 bit floats\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",
" | __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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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__(...)\n",
" \n",
" class complexfloating(inexact)\n",
" | Base class for numpy scalar types.\n",
" | \n",
" | Class from which most (all?) numpy scalar types are derived. For\n",
" | consistency, exposes the same API as `ndarray`, despite many\n",
" | consequent attributes being either \"get-only,\" or completely irrelevant.\n",
" | This is the class from which it is strongly suggested users should derive\n",
" | custom scalar types.\n",
" | \n",
" | Method resolution order:\n",
" | complexfloating\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__(|type) return 0-dim array\n",
" | \n",
" | __array_wrap__(...)\n",
" | sc.__array_wrap__(obj) return scalar from array\n",
" | \n",
" | __bool__(self, /)\n",
" | self != 0\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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",
" \n",
" csingle = class complex64(complexfloating)\n",
" | Composed of two 32 bit floats\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",
" | __complex__(...)\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" class datetime64(generic)\n",
" | Base class for numpy scalar types.\n",
" | \n",
" | Class from which most (all?) numpy scalar types are derived. For\n",
" | consistency, exposes the same API as `ndarray`, despite many\n",
" | consequent attributes being either \"get-only,\" or completely irrelevant.\n",
" | This is the class from which it is strongly suggested users should derive\n",
" | custom scalar types.\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" double = class float64(floating, builtins.float)\n",
" | 64-bit floating-point number. Character code 'd'. Python float compatible.\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",
" | __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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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",
" | __getattribute__(self, name, /)\n",
" | Return getattr(self, name).\n",
" | \n",
" | __getformat__(...) from builtins.type\n",
" | float.__getformat__(typestr) -> string\n",
" | \n",
" | You probably don't want to use this function. It exists mainly to be\n",
" | used in Python's test suite.\n",
" | \n",
" | typestr must be 'double' or 'float'. This function returns whichever of\n",
" | 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the\n",
" | format of floating point numbers used by the C type named by typestr.\n",
" | \n",
" | __getnewargs__(...)\n",
" | \n",
" | __setformat__(...) from builtins.type\n",
" | float.__setformat__(typestr, fmt) -> None\n",
" | \n",
" | You probably don't want to use this function. It exists mainly to be\n",
" | used in Python's test suite.\n",
" | \n",
" | typestr must be 'double' or 'float'. fmt must be one of 'unknown',\n",
" | 'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be\n",
" | one of the latter two if it appears to match the underlying C reality.\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",
" | __trunc__(...)\n",
" | Return the Integral closest to x between 0 and x.\n",
" | \n",
" | as_integer_ratio(...)\n",
" | float.as_integer_ratio() -> (int, int)\n",
" | \n",
" | Return a pair of integers, whose ratio is exactly equal to the original\n",
" | float and with a positive denominator.\n",
" | Raise OverflowError on infinities and a ValueError on NaNs.\n",
" | \n",
" | >>> (10.0).as_integer_ratio()\n",
" | (10, 1)\n",
" | >>> (0.0).as_integer_ratio()\n",
" | (0, 1)\n",
" | >>> (-.25).as_integer_ratio()\n",
" | (-1, 4)\n",
" | \n",
" | fromhex(...) from builtins.type\n",
" | float.fromhex(string) -> float\n",
" | \n",
" | Create a floating-point number from a hexadecimal string.\n",
" | >>> float.fromhex('0x1.ffffp10')\n",
" | 2047.984375\n",
" | >>> float.fromhex('-0x1p-1074')\n",
" | -5e-324\n",
" | \n",
" | hex(...)\n",
" | float.hex() -> string\n",
" | \n",
" | Return a hexadecimal representation of a floating-point number.\n",
" | >>> (-0.1).hex()\n",
" | '-0x1.999999999999ap-4'\n",
" | >>> 3.14159.hex()\n",
" | '0x1.921f9f01b866ep+1'\n",
" | \n",
" | is_integer(...)\n",
" | Return True if the float is an integer.\n",
" \n",
" class dtype(builtins.object)\n",
" | dtype(obj, 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",
" | obj\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",
" | result_type\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.uint), ('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.int,3)),('world',np.void,10)])\n",
" | dtype([('hello', '>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))\n",
" | dtype(('>> 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",
" | __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', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | The code does a case-insensitive check on the first letter of\n",
" | `new_order` for these alternatives. For example, any of '>'\n",
" | or 'B' or 'b' or 'brian' are valid to specify big-endian.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : 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",
" | >>> sys_is_le = sys.byteorder == 'little'\n",
" | >>> native_code = sys_is_le and '<' or '>'\n",
" | >>> swapped_code = sys_is_le and '>' or '<'\n",
" | >>> native_dt = np.dtype(native_code+'i2')\n",
" | >>> swapped_dt = np.dtype(swapped_code+'i2')\n",
" | >>> native_dt.newbyteorder('S') == swapped_dt\n",
" | True\n",
" | >>> native_dt.newbyteorder() == swapped_dt\n",
" | True\n",
" | >>> native_dt == swapped_dt.newbyteorder('S')\n",
" | True\n",
" | >>> native_dt == swapped_dt.newbyteorder('=')\n",
" | True\n",
" | >>> native_dt == swapped_dt.newbyteorder('N')\n",
" | True\n",
" | >>> native_dt == native_dt.newbyteorder('|')\n",
" | True\n",
" | >>> np.dtype('>> np.dtype('>> np.dtype('>i2') == native_dt.newbyteorder('>')\n",
" | True\n",
" | >>> np.dtype('>i2') == native_dt.newbyteorder('B')\n",
" | True\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",
" | base\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",
" | >>> sys_is_le = sys.byteorder == 'little'\n",
" | >>> native_code = sys_is_le and '<' or '>'\n",
" | >>> swapped_code = sys_is_le and '>' or '<'\n",
" | >>> dt = np.dtype(native_code + 'i2')\n",
" | >>> dt.byteorder\n",
" | '='\n",
" | >>> # Swapped code shows up as itself\n",
" | >>> dt = np.dtype(swapped_code + 'i2')\n",
" | >>> dt.byteorder == swapped_code\n",
" | True\n",
" | \n",
" | char\n",
" | A unique character code for each of the 21 different built-in types.\n",
" | \n",
" | descr\n",
" | Array-interface compliant full description of the data-type.\n",
" | \n",
" | The format is that required by the 'descr' key in the\n",
" | `__array_interface__` attribute.\n",
" | \n",
" | fields\n",
" | Dictionary of named fields defined for this data type, or ``None``.\n",
" | \n",
" | The dictionary is indexed by keys that are the names of the fields.\n",
" | Each entry in the dictionary is a tuple fully describing the field::\n",
" | \n",
" | (dtype, offset[, title])\n",
" | \n",
" | If present, the optional title can be any object (if it is a string\n",
" | or unicode then it will also be a key in the fields dictionary,\n",
" | otherwise it's meta-data). Notice also that the first two elements\n",
" | of the tuple can be passed directly as arguments to the ``ndarray.getfield``\n",
" | and ``ndarray.setfield`` methods.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | ndarray.getfield, ndarray.setfield\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> 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",
" | `ITEM_HASOBJECT`, `LIST_PICKLE`, `ITEM_IS_POINTER`, `NEEDS_INIT`,\n",
" | `NEEDS_PYAPI`, `USE_GETITEM`, `USE_SETITEM`. A full explanation\n",
" | of these flags is in C-API documentation; they are largely useful\n",
" | for user-defined data-types.\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",
" | 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",
" | metadata\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",
" | 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",
" | 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",
" | shape\n",
" | Shape tuple of the sub-array if this data type describes a sub-array,\n",
" | and ``()`` otherwise.\n",
" | \n",
" | str\n",
" | The array-protocol typestring of this data-type object.\n",
" | \n",
" | subdtype\n",
" | Tuple ``(item_dtype, 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 *item_dtype* 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",
" | type\n",
" | The type object used to instantiate a scalar of this data-type.\n",
" \n",
" class errstate(builtins.object)\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",
" | 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",
" | The ``with`` statement was introduced in Python 2.5, and can only be used\n",
" | there by importing it: ``from __future__ import with_statement``. In\n",
" | earlier Python versions the ``with`` statement is not available.\n",
" | \n",
" | For complete documentation of the types of floating-point exceptions and\n",
" | treatment options, see `seterr`.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> from __future__ import with_statement # use 'with' in Python 2.5\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",
" | ...\n",
" | __main__:2: RuntimeWarning: divide by zero encountered in divide\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",
" | {'over': 'warn', 'divide': 'warn', 'invalid': 'warn',\n",
" | 'under': 'ignore'}\n",
" | \n",
" | Methods defined here:\n",
" | \n",
" | __enter__(self)\n",
" | \n",
" | __exit__(self, *exc_info)\n",
" | \n",
" | __init__(self, **kwargs)\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",
" \n",
" class finfo(builtins.object)\n",
" | finfo(dtype)\n",
" | \n",
" | Machine limits for floating point types.\n",
" | \n",
" | Attributes\n",
" | ----------\n",
" | eps : float\n",
" | The smallest representable positive number such that\n",
" | ``1.0 + eps != 1.0``. Type of `eps` is an appropriate floating\n",
" | point type.\n",
" | epsneg : floating point number of the appropriate type\n",
" | The smallest representable positive number such that\n",
" | ``1.0 - epsneg != 1.0``.\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 usable number. Type of `tiny` is an\n",
" | appropriate floating point type.\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",
" | \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",
" | 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",
" \n",
" class flatiter(builtins.object)\n",
" | 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",
" | >>> fl.next()\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",
" | >>> fl.next()\n",
" | 0\n",
" | >>> fl.index\n",
" | 1\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data and other attributes defined here:\n",
" | \n",
" | __hash__ = None\n",
" \n",
" class flexible(generic)\n",
" | Base class for numpy scalar types.\n",
" | \n",
" | Class from which most (all?) numpy scalar types are derived. For\n",
" | consistency, exposes the same API as `ndarray`, despite many\n",
" | consequent attributes being either \"get-only,\" or completely irrelevant.\n",
" | This is the class from which it is strongly suggested users should derive\n",
" | custom scalar types.\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__(|type) return 0-dim array\n",
" | \n",
" | __array_wrap__(...)\n",
" | sc.__array_wrap__(obj) return scalar from array\n",
" | \n",
" | __bool__(self, /)\n",
" | self != 0\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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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",
" \n",
" class float16(floating)\n",
" | Base class for numpy scalar types.\n",
" | \n",
" | Class from which most (all?) numpy scalar types are derived. For\n",
" | consistency, exposes the same API as `ndarray`, despite many\n",
" | consequent attributes being either \"get-only,\" or completely irrelevant.\n",
" | This is the class from which it is strongly suggested users should derive\n",
" | custom scalar types.\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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" class float32(floating)\n",
" | 32-bit floating-point number. Character code 'f'. C float compatible.\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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the gentype\n",
" | \n",
" | strides\n",
" | tuple of bytes steps in each dimension\n",
" \n",
" class float64(floating, builtins.float)\n",
" | 64-bit floating-point number. Character code 'd'. Python float compatible.\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",
" | __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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | item(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | itemset(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | max(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | mean(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | min(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | newbyteorder(...)\n",
" | newbyteorder(new_order='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 `new_order` code can be any from the following:\n",
" | \n",
" | * 'S' - swap dtype from current to opposite endian\n",
" | * {'<', 'L'} - little endian\n",
" | * {'>', 'B'} - big endian\n",
" | * {'=', 'N'} - native order\n",
" | * {'|', 'I'} - ignore (no change to byte order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | new_order : 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. The code does a case-insensitive check on the first\n",
" | letter of `new_order` for the alternatives above. For example,\n",
" | any of 'B' or 'b' or 'biggish' are valid to specify big-endian.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | new_dtype : dtype\n",
" | New `dtype` object with the given change to the byte order.\n",
" | \n",
" | nonzero(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | prod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ptp(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | put(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ravel(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | repeat(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | reshape(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | resize(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | round(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | searchsorted(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | setflags(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | squeeze(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | std(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | sum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | swapaxes(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | take(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tobytes(...)\n",
" | \n",
" | tofile(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tolist(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | tostring(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | trace(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | transpose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | var(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | view(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from generic:\n",
" | \n",
" | T\n",
" | transpose\n",
" | \n",
" | __array_interface__\n",
" | Array protocol: Python side\n",
" | \n",
" | __array_priority__\n",
" | Array priority.\n",
" | \n",
" | __array_struct__\n",
" | Array protocol: struct\n",
" | \n",
" | base\n",
" | base object\n",
" | \n",
" | data\n",
" | pointer to start of data\n",
" | \n",
" | dtype\n",
" | get array data-descriptor\n",
" | \n",
" | flags\n",
" | integer value of flags\n",
" | \n",
" | flat\n",
" | a 1-d view of scalar\n",
" | \n",
" | imag\n",
" | imaginary part of scalar\n",
" | \n",
" | itemsize\n",
" | length of one element in bytes\n",
" | \n",
" | nbytes\n",
" | length of item in bytes\n",
" | \n",
" | ndim\n",
" | number of array dimensions\n",
" | \n",
" | real\n",
" | real part of scalar\n",
" | \n",
" | shape\n",
" | tuple of array dimensions\n",
" | \n",
" | size\n",
" | 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",
" | __getattribute__(self, name, /)\n",
" | Return getattr(self, name).\n",
" | \n",
" | __getformat__(...) from builtins.type\n",
" | float.__getformat__(typestr) -> string\n",
" | \n",
" | You probably don't want to use this function. It exists mainly to be\n",
" | used in Python's test suite.\n",
" | \n",
" | typestr must be 'double' or 'float'. This function returns whichever of\n",
" | 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the\n",
" | format of floating point numbers used by the C type named by typestr.\n",
" | \n",
" | __getnewargs__(...)\n",
" | \n",
" | __setformat__(...) from builtins.type\n",
" | float.__setformat__(typestr, fmt) -> None\n",
" | \n",
" | You probably don't want to use this function. It exists mainly to be\n",
" | used in Python's test suite.\n",
" | \n",
" | typestr must be 'double' or 'float'. fmt must be one of 'unknown',\n",
" | 'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be\n",
" | one of the latter two if it appears to match the underlying C reality.\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",
" | __trunc__(...)\n",
" | Return the Integral closest to x between 0 and x.\n",
" | \n",
" | as_integer_ratio(...)\n",
" | float.as_integer_ratio() -> (int, int)\n",
" | \n",
" | Return a pair of integers, whose ratio is exactly equal to the original\n",
" | float and with a positive denominator.\n",
" | Raise OverflowError on infinities and a ValueError on NaNs.\n",
" | \n",
" | >>> (10.0).as_integer_ratio()\n",
" | (10, 1)\n",
" | >>> (0.0).as_integer_ratio()\n",
" | (0, 1)\n",
" | >>> (-.25).as_integer_ratio()\n",
" | (-1, 4)\n",
" | \n",
" | fromhex(...) from builtins.type\n",
" | float.fromhex(string) -> float\n",
" | \n",
" | Create a floating-point number from a hexadecimal string.\n",
" | >>> float.fromhex('0x1.ffffp10')\n",
" | 2047.984375\n",
" | >>> float.fromhex('-0x1p-1074')\n",
" | -5e-324\n",
" | \n",
" | hex(...)\n",
" | float.hex() -> string\n",
" | \n",
" | Return a hexadecimal representation of a floating-point number.\n",
" | >>> (-0.1).hex()\n",
" | '-0x1.999999999999ap-4'\n",
" | >>> 3.14159.hex()\n",
" | '0x1.921f9f01b866ep+1'\n",
" | \n",
" | is_integer(...)\n",
" | Return True if the float is an integer.\n",
" \n",
" float_ = class float64(floating, builtins.float)\n",
" | 64-bit floating-point number. Character code 'd'. Python float compatible.\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",
" | __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",
" | __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",
" | __sizeof__() -> int\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",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | any(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmax(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argmin(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | argsort(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | astype(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | byteswap(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class so as to\n",
" | provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | choose(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | clip(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | compress(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | conj(...)\n",
" | \n",
" | conjugate(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | copy(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumprod(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | cumsum(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | diagonal(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dump(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | dumps(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | fill(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | flatten(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses,\n",
" | albeit unimplemented, all the attributes of the ndarray class\n",
" | so as to provide a uniform API.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | The corresponding attribute of the derived class of interest.\n",
" | \n",
" | getfield(...)\n",
" | Not implemented (virtual attribute)\n",
" | \n",
" | Class generic exists solely to derive numpy scalars from, and possesses