U
|
O ±d¡0 ã @ sp d Z ddlZddlZddlmZ ddlmZ ddlmZ dd Z e dd d
|
d d d dddddddddddddgZ
|
dd Z e \Z Z d e d e d Zd d! Zed"d#gd$ ed%g d& ed'g d( ed)g d* ed+g d, ed-g d. ed/g d0 ed1g d2 ed3g d4 ed5g d6 ed7g d8 ed9g d: ed;g d< ed=d>gd? ed@dAgdB edCdDgdE edFdGdHgdI edJdKdLgdM edNg dO edPdQgdR edSdTgdU edVg dW edXg dY edZg d[ ed\d]d^ d_D ]BZed\ed`dajedbf ed\edcdde dee dfe dgf qÞdhD ]DZed\edidde dje dkeej ¡ r^dle dmndn f q&dS )oz¹
|
This file is separate from ``_add_newdocs.py`` so that it can be mocked out by
|
our sphinx ``conf.py`` during doc builds, where we want to avoid showing
|
platform-dependent information.
|
é N)Údtype)Ú numerictypes)Ú
|
add_newdocc s fdd}t | S )Nc 3 sB D ]8\} }zt t| }W n tk
|
r. Y qX || |fV qd S )N)ÚgetattrÚ _numerictypesÚAttributeError)ÚaliasÚdocÚ
|
alias_type©Úaliases© úVd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/core/_add_newdocs_scalars.pyÚtype_aliases_gen s z.numeric_type_aliases.<locals>.type_aliases_gen)Úlist)r r r r r Únumeric_type_aliases s r )Úint8z*8-bit signed integer (``-128`` to ``127``))Úint16z116-bit signed integer (``-32_768`` to ``32_767``))Úint32z?32-bit signed integer (``-2_147_483_648`` to ``2_147_483_647``))Úint64zW64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``))ZintpzJSigned integer large enough to fit pointer, compatible with C ``intptr_t``)Úuint8z)8-bit unsigned integer (``0`` to ``255``))Úuint16z-16-bit unsigned integer (``0`` to ``65_535``))Úuint32z432-bit unsigned integer (``0`` to ``4_294_967_295``))Úuint64zA64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``))ZuintpzMUnsigned integer large enough to fit pointer, compatible with C ``uintptr_t``)Úfloat16zX16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa)Úfloat32zX32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa)Úfloat64zY64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa)Zfloat96z496-bit extended-precision floating-point number type)Zfloat128z5128-bit extended-precision floating-point number type)Z complex64zIComplex number type composed of 2 32-bit-precision floating-point numbers)Z
|
complex128zIComplex number type composed of 2 64-bit-precision floating-point numbers)Z
|
complex192zRComplex number type composed of 2 96-bit extended-precision floating-point numbers)Z
|
complex256zSComplex number type composed of 2 128-bit extended-precision floating-point numbersc C sd zt ¡ \} }}}}W nD tk
|
rZ tj} | dkrRt j dd¡pNt j dd¡}nd}Y nX | |fS )NÚwin32ÚPROCESSOR_ARCHITEW6432Ú ÚPROCESSOR_ARCHITECTUREÚunknown)ÚosÚunamer ÚsysÚplatformÚenvironÚget)ÚsystemÚ_Úmachiner r r Ú_get_platform_and_machine6 s ÿ
|
r+ z:Alias on this platform (ú z):c s t t| t j}| jkr"dn
|
d| d}|rHd dd |D ¡}nd}|d fddtD ¡7 }d| ¡ d| d | | d}td
|
| | d S ) Nr z:Canonical name: `numpy.ú`
|
c s s | ]}d | dV qdS )z:Alias: `numpy.r- Nr )Ú.0r r r r Ú <genexpr>O s ÿz-add_newdoc_for_scalar_type.<locals>.<genexpr>c 3 s2 | ]*\}}}| krt d | d| dV qdS )z `numpy.z`: z.
|
N)Ú_doc_alias_string)r. r
|
r r ©Úor r r/ S s ÿz
|
z
|
|
:Character code: ``'z'``
|
únumpy.core.numerictypes) r r r ÚcharÚ__name__ÚjoinÚpossible_aliasesÚstripr )ÚobjZ fixed_aliasesr Zcharacter_codeZcanonical_name_docZ alias_docZ docstringr r1 r Úadd_newdoc_for_scalar_typeG s.
|
|
|
ÿ
|
ÿ
|
ÿ
|
ÿýüür: Zbool_Zbool8aD
|
Boolean type (True or False), stored as a byte.
|
|
.. warning::
|
|
The :class:`bool_` type is not a subclass of the :class:`int_` type
|
(the :class:`bool_` is not even a number type). This is different
|
than Python's default implementation of :class:`bool` as a
|
sub-class of :class:`int`.
|
Úbytez:
|
Signed integer type, compatible with C ``char``.
|
Úshortz;
|
Signed integer type, compatible with C ``short``.
|
Zintcz9
|
Signed integer type, compatible with C ``int``.
|
Úint_zK
|
Signed integer type, compatible with Python `int` and C ``long``.
|
Zlonglongz?
|
Signed integer type, compatible with C ``long long``.
|
ZubytezE
|
Unsigned integer type, compatible with C ``unsigned char``.
|
ZushortzF
|
Unsigned integer type, compatible with C ``unsigned short``.
|
ZuintczD
|
Unsigned integer type, compatible with C ``unsigned int``.
|
ZuintzE
|
Unsigned integer type, compatible with C ``unsigned long``.
|
Z ulonglongzH
|
Signed integer type, compatible with C ``unsigned long long``.
|
Úhalfz4
|
Half-precision floating-point number type.
|
ÚsinglezS
|
Single-precision floating-point number type, compatible with C ``float``.
|
ÚdoubleZfloat_zk
|
Double-precision floating-point number type, compatible with Python `float`
|
and C ``double``.
|
Ú
|
longdoubleZ longfloatz
|
Extended-precision floating-point number type, compatible with C
|
``long double`` but not necessarily with IEEE 754 quadruple-precision.
|
ZcsingleZ singlecomplexzZ
|
Complex number type composed of two single-precision floating-point
|
numbers.
|
ZcdoubleZcfloatZcomplex_z|
|
Complex number type composed of two double-precision floating-point
|
numbers, compatible with Python `complex`.
|
Z clongdoubleZ
|
clongfloatZ longcomplexz\
|
Complex number type composed of two extended-precision floating-point
|
numbers.
|
Zobject_z
|
Any Python object.
|
Zstr_Zunicode_aV
|
A unicode string.
|
|
When used in arrays, this type strips trailing null codepoints.
|
|
Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its
|
contents as UCS4:
|
|
>>> m = memoryview(np.str_("abc"))
|
>>> m.format
|
'3w'
|
>>> m.tobytes()
|
b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'
|
Úbytes_Zstring_zX
|
A byte string.
|
|
When used in arrays, this type strips trailing null bytes.
|
Zvoidaô
|
np.void(length_or_data, /, dtype=None)
|
|
Create a new structured or unstructured void scalar.
|
|
Parameters
|
----------
|
length_or_data : int, array-like, bytes-like, object
|
One of multiple meanings (see notes). The length or
|
bytes data of an unstructured void. Or alternatively,
|
the data to be stored in the new scalar when `dtype`
|
is provided.
|
This can be an array-like, in which case an array may
|
be returned.
|
dtype : dtype, optional
|
If provided the dtype of the new scalar. This dtype must
|
be "void" dtype (i.e. a structured or unstructured void,
|
see also :ref:`defining-structured-types`).
|
|
..versionadded:: 1.24
|
|
Notes
|
-----
|
For historical reasons and because void scalars can represent both
|
arbitrary byte data and structured dtypes, the void constructor
|
has three calling conventions:
|
|
1. ``np.void(5)`` creates a ``dtype="V5"`` scalar filled with five
|
``\0`` bytes. The 5 can be a Python or NumPy integer.
|
2. ``np.void(b"bytes-like")`` creates a void scalar from the byte string.
|
The dtype itemsize will match the byte string length, here ``"V10"``.
|
3. When a ``dtype=`` is passed the call is rougly the same as an
|
array creation. However, a void scalar rather than array is returned.
|
|
Please see the examples which show all three different conventions.
|
|
Examples
|
--------
|
>>> np.void(5)
|
void(b'\x00\x00\x00\x00\x00')
|
>>> np.void(b'abcd')
|
void(b'\x61\x62\x63\x64')
|
>>> np.void((5, 3.2, "eggs"), dtype="i,d,S5")
|
(5, 3.2, b'eggs') # looks like a tuple, but is `np.void`
|
>>> np.void(3, dtype=[('x', np.int8), ('y', np.int8)])
|
(3, 3) # looks like a tuple, but is `np.void`
|
|
Z
|
datetime64a±
|
If created from a 64-bit integer, it represents an offset from
|
``1970-01-01T00:00:00``.
|
If created from string, the string can be in ISO 8601 date
|
or datetime format.
|
|
>>> np.datetime64(10, 'Y')
|
numpy.datetime64('1980')
|
>>> np.datetime64('1980', 'Y')
|
numpy.datetime64('1980')
|
>>> np.datetime64(10, 'D')
|
numpy.datetime64('1970-01-11')
|
|
See :ref:`arrays.datetime` for more information.
|
Z timedelta64zg
|
A timedelta stored as a 64-bit integer.
|
|
See :ref:`arrays.datetime` for more information.
|
r3 Úinteger)Ú
|
is_integerzõ
|
integer.is_integer() -> bool
|
|
Return ``True`` if the number is finite with integral value.
|
|
.. versionadded:: 1.22
|
|
Examples
|
--------
|
>>> np.int64(-2).is_integer()
|
True
|
>>> np.uint32(5).is_integer()
|
True
|
)r> r? r@ rA Úas_integer_ratioaÒ
|
{ftype}.as_integer_ratio() -> (int, int)
|
|
Return a pair of integers, whose ratio is exactly equal to the original
|
floating point number, and with a positive denominator.
|
Raise `OverflowError` on infinities and a `ValueError` on NaNs.
|
|
>>> np.{ftype}(10.0).as_integer_ratio()
|
(10, 1)
|
>>> np.{ftype}(0.0).as_integer_ratio()
|
(0, 1)
|
>>> np.{ftype}(-.25).as_integer_ratio()
|
(-1, 4)
|
)ZftyperD z
|
zÞ.is_integer() -> bool
|
|
Return ``True`` if the floating point number is finite with integral
|
value, and ``False`` otherwise.
|
|
.. versionadded:: 1.22
|
|
Examples
|
--------
|
>>> np.z0(-2.0).is_integer()
|
True
|
>>> np.z)(3.2).is_integer()
|
False
|
) r r r r r r r r r r r r Z bit_countzÚ.bit_count() -> int
|
|
Computes the number of 1-bits in the absolute value of the input.
|
Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
|
Examples
|
--------
|
>>> np.z(127).bit_count()
|
7z
|
>>> np.z%(-127).bit_count()
|
7
|
r )Ú__doc__r$ r" Z
|
numpy.corer r r Znumpy.core.function_baser r r7 r+ Z_systemZ_machiner0 r: Z
|
float_nameÚformatZint_namer4 Úislowerr r r r Ú<module> s
|
í
|
ÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
ÿ
|
ÿÿÿÿÿ2ÿÿ óÿÿÿÿÿ
|
ÿÿ ýÿóÿ
|
