rank-1r )r )ndimcopyshapeas K/opt/cloudlinux/venv/lib64/python3.11/site-packages/numpy/core/getlimits.py_fr0r s& v{{
FFHH H c R | j dk r| } d| _ | S )zfix rank > 0 --> rank-0r )sizer r r s r _fr1r s& v{{
FFHH Hr c \ e Zd ZdZdddZed Zed Zd Zd Z d Z
dS )
MachArLikez$ Object to simulate MachAr instance N)smallest_subnormalc t | | _ || _ | j d | _ |sCt | d | d | j | _ n|| _ | | x| _ | _ | | | _ | | x| _
| _ | | | _ | | x| _
| _ | j d | | _ | j | t% t' | j | _ | | d | j z | _ | | j | _ | | j | _ | | j | _ | | j
| _ | | j | _ | | j | _ d S )Ntitler r dtypeitype
) _MACHAR_PARAMSparamsftyper# r _smallest_subnormal_float_to_floatepsilonepsepsnegxmaxhugexminsmallest_normaltinyibeta__dict__updateintr precision _float_conv
resolution
_float_to_str_str_eps _str_epsneg _str_xmin _str_xmax_str_resolution_str_smallest_normal) selfr* r. r/ r1 r4 r5 r! kwargss r __init__zMachArLike.__init__" s $U+
[)
! :'0
1
tzz!}}DJ(@ (@ (@D $ $ (:D $"&"6"6s";";; tx**622 $ 4 4T : :: DI((.. +/+?+?+E+EE ty)T[)%00
V$$$ eDHoo -.. .. R dn_ 57 7 **4844
--dk:: ++DI66 ++DI66 # 1 1$/ B B $($6$6ty$A$A!!!r c | j }| d |k r4t j d | j t
d | | S )a Return the value for the smallest subnormal.
Returns
-------
smallest_subnormal : float
value for the smallest subnormal.
Warns
-----
UserWarning
If the calculated value for the smallest subnormal is zero.
r z8The value of the smallest subnormal for {} type is zero.r
stacklevel)r+ r* warningswarnformat UserWarningr, rC values r r! z MachArLike.smallest_subnormal> sl ( ::a==E ! ! M!6$*--{q
J
J
J
J ##E***r c 6 | | j S )z;Return the string representation of the smallest subnormal.)r< r! rC s r _str_smallest_subnormalz"MachArLike._str_smallest_subnormalV s !!$"9:::r c F t | | S )zConverts float to float.
Parameters
----------
value : float
value to be converted.
)r r: rM s r r, zMachArLike._float_to_float[ s D$$U++,,,r c . t |g| j S )zConverts float to conv.
Parameters
----------
value : float
value to be converted.
)r r* rM s r r: zMachArLike._float_conve s eWdj)))r c n | j d t t | d | j z S )zConverts float to str.
Parameters
----------
value : float
value to be converted.
fmtr )r) r r r* rM s r r< zMachArLike._float_to_stro s, {5!E$u++a.$*$E$EEEr ) __name__
__module__ __qualname____doc__rE propertyr! rQ r, r: r< r r r r r s ..+/B B B B B8 + + X+. ; ; X;- - -* * *F F F F Fr r z(numpy {} precision floating point numberz%24.16edouble)r& rU r# z%15.7esinglez%sz long doublez%12.5ehalfc | t |< d S N) _KNOWN_TYPES)macharbytepats r _register_typerc s "Lr c t j } t | dddddddddt | d t | d | d | d
}t |d |t
d< t j }t |d
ddddddddt |d
t |d |dddz z t |d }t |d |t
d< t j }d}d}t |ddddd d dddd |d |z
|z |d z | }t |d! |t
d"< t j }t |d# } t |d$ }
t j
d%& 5 |d' | z
|
z |d z } d d d n # 1 swxY w Y t |d(d#d$d)d*d+dddt |d( | | |
} t | d, | t
d< t |d- }
t |d$ }t j
d%& 5 |d' |
z
|z |d z }d d d n # 1 swxY w Y t |d.d-d$d)d/d+dddt |d. |
|| }t |d0 |t
d1< t |t |d |2 }t } |t d3d }t |d4d5ddd6d dddt |d4 t |d5 |||7 }t |d8 t |d9 |t
d:< d S );Niii r' r r i g ?)
machepnegepminexpmaxexpitiexpr5 irndngrdr. r/ r1 r4 s fiii g ?s ̽ g >!$U!$X
0
0
0J :x((( IbM .CC#&"%#'#& !!""#!"!" $SSXX#'C>>!$laf%Q!G!)
+
+
+J : BCCC IbM
Brr$xx..KRRZZ I h ' ' ' > >RUU[(I51= > > > > > > > > > > > > > > > R$(#'$*$) #"$#$"#"#!%bbhh $/"+"+
-
-
-K ;KM M M IcN bbgg JBBvJJ H h ' ' ' ; ;BqEEJ&(2RRUU:; ; ; ; ; ; ; ; ; ; ; ; ; ; ;B#&"%#)#( !!#"#!"!" $RRWW
#-!)!)
+
+
+J : JKKK IbM 3Ab111G ByR 0 0 1 1 R$(#'$)$( #"$#$"#"#!%bbhh $(DNN")"40E G G GK ;EG G G ;EG G G!IdOOOs$ G**G.1G. J11J58J5c t | }| t t | | d | d z d }d}| t j k r"t |dd }|t | }|St | dk r@d t
D }| |dd }||S t j d| d | d
t d t | S )
a Get MachAr instance or MachAr-like instance
Get parameters for floating point type, by first trying signatures of
various known floating point types, then, if none match, attempting to
identify parameters by analysis.
Parameters
----------
ftype : class
Numpy floating point type class (e.g. ``np.float64``)
Returns
-------
ma_like : instance of :class:`MachAr` or :class:`MachArLike`
Object giving floating point parameters for `ftype`.
Warns
-----
UserWarning
If the binary signature of the float type is not in the dictionary of
known float types.
Ng g $@z _get_machar.._ s1 JJJTQSVVr\\q"vq\\\r z
Signature z for zz does not match any known type: falling back to type probe function.
This warnings indicates broken support for the dtype!r rG )r( get
ValueErrorrepr newbyteordertobytesr r r` r itemsrI rJ rL _discovered_machar)r* r) keyma_like_kts r _get_macharr 3 s_ .
&
&F
~e%%% 5;;s #
1
1#
6
6
>
>
@
@CG !!!
""3ss8,, ""3''3s88r>> KJ\%7%7%9%9JJJ''#crc(## M @S @ @u @ @ @ # # # #
e $ $$r c l t t fdfd fd fdd S )z Create MachAr instance with found information on float types
TODO: MachAr should be retired completely ideally. We currently only
ever use it system with broken longdouble (valgrind, WSL).
c & t | g S r_ )r r r* s r z$_discovered_machar..s s E1#u - - r c ` t | d d S )Nr& r )r astype)r r) s r r z$_discovered_machar..t s$ 4 9 9::1= r c J t t | d S )Nr r r r s r r z$_discovered_machar..u s 5aU33 r c \ d t t | d z S )NrU r r )r r* r) s r r z$_discovered_machar..v s$ F5ME$q''!*e,D,D D r r# )r( r )r* r) s `@r r r l s\ E
"F ----====3333DDDDD/ # # #r numpyc Z e Zd ZdZi Zd Zd Zd Zd Ze d Z
e d Z dS ) r a
finfo(dtype)
Machine limits for floating point types.
Attributes
----------
bits : int
The number of bits occupied by the type.
dtype : dtype
Returns the dtype for which `finfo` returns information. For complex
input, the returned dtype is the associated ``float*`` dtype for its
real and complex components.
eps : float
The difference between 1.0 and the next smallest representable float
larger than 1.0. For example, for 64-bit binary floats in the IEEE-754
standard, ``eps = 2**-52``, approximately 2.22e-16.
epsneg : float
The difference between 1.0 and the next smallest representable float
less than 1.0. For example, for 64-bit binary floats in the IEEE-754
standard, ``epsneg = 2**-53``, approximately 1.11e-16.
iexp : int
The number of bits in the exponent portion of the floating point
representation.
machep : int
The exponent that yields `eps`.
max : floating point number of the appropriate type
The largest representable number.
maxexp : int
The smallest positive power of the base (2) that causes overflow.
min : floating point number of the appropriate type
The smallest representable number, typically ``-max``.
minexp : int
The most negative power of the base (2) consistent with there
being no leading 0's in the mantissa.
negep : int
The exponent that yields `epsneg`.
nexp : int
The number of bits in the exponent including its sign and bias.
nmant : int
The number of bits in the mantissa.
precision : int
The approximate number of decimal digits to which this kind of
float is precise.
resolution : floating point number of the appropriate type
The approximate decimal resolution of this type, i.e.,
``10**-precision``.
tiny : float
An alias for `smallest_normal`, kept for backwards compatibility.
smallest_normal : float
The smallest positive floating point number with 1 as leading bit in
the mantissa following IEEE-754 (see Notes).
smallest_subnormal : float
The smallest positive floating point number with 0 as leading bit in
the mantissa following IEEE-754.
Parameters
----------
dtype : float, dtype, or instance
Kind of floating point or complex floating point
data-type about which to get information.
See Also
--------
iinfo : The equivalent for integer data types.
spacing : The distance between a value and the nearest adjacent number
nextafter : The next floating point value after x1 towards x2
Notes
-----
For developers of NumPy: do not instantiate this at the module level.
The initial calculation of these parameters is expensive and negatively
impacts import times. These objects are cached, so calling ``finfo()``
repeatedly inside your functions is not a problem.
Note that ``smallest_normal`` is not actually the smallest positive
representable value in a NumPy floating point type. As in the IEEE-754
standard [1]_, NumPy floating point types make use of subnormal numbers to
fill the gap between 0 and ``smallest_normal``. However, subnormal numbers
may have significantly reduced precision [2]_.
This function can also be used for complex data types as well. If used,
the output will be the same as the corresponding real float type
(e.g. numpy.finfo(numpy.csingle) is the same as numpy.finfo(numpy.single)).
However, the output is true for the real and imaginary components.
References
----------
.. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008,
pp.1-70, 2008, http://www.doi.org/10.1109/IEEESTD.2008.4610935
.. [2] Wikipedia, "Denormal Numbers",
https://en.wikipedia.org/wiki/Denormal_number
Examples
--------
>>> np.finfo(np.float64).dtype
dtype('float64')
>>> np.finfo(np.complex64).dtype
dtype('float32')
c | j | }||S n# t $ r Y nw xY w| t j dt
d t
j | }n1# t $ r$ t
j t | }Y nw xY w| j | }||S |g}t
j | }||ur|
| |}t |t j st d|z | j | }||S t |t j sVt | }||urE|
| |}| j |d }||D ] }|| j |<
|S t | | }|D ] }|| j |<
|S )Nzifinfo() dtype cannot be None. This behavior will raise an error in the future. (Deprecated in NumPy 1.25)r rG zdata type %r not inexact) _finfo_cacher TypeErrorrI rJ DeprecationWarningr r% type
obj2sctypeappend
issubclassinexactr floating_convert_to_floatobject__new___init)clsr% objdtypesnewdtypedts r r z
finfo.__new__ s- "&&u--C
D = MK"
/M%((EE / / /M$u++..EEE / ""5)) ?J%e,, 5 MM( # # # E% 11 C 75 ABB B ""5)) ?J%!122 (/Hu$$
h''' &**5$77? % 3 3/2(,, JnnS!!''.. ' 'B#&C R
s !
..A% %+BBc | t j | | _ t | }dD ]!}t | |t || "dD ],}t | |t || j d -| j j dz | _ |j j d | _ | j | _
|j j d | _ |j | _
|j | _ || _ |j | _ |j | _ |j | _ |j | _ |j | _ |j | _ |j | _ | S )N)r9 rl rj ri rh rg )r; r/ r! r rq )r r% r setattrgetattrflatitemsizebitsr1 maxminr. rl nexprk nmant_macharr? strip _str_tinyr@ _str_maxr> r= rA rB rQ )rC r% ra words r r z finfo._init s ]5))
U## 7 7D
D$ 5 5 6 6 6 6B ? ?D D$ 5 5 :1 = > > > >J'!+ ;#A&H9:?1%K Y
)//11 (..00
!-3355 --//
% 5 ; ; = = $*$?$E$E$G$G!'-'E'K'K'M'M$ r c d}|| j z S )Na+ Machine parameters for %(dtype)s
---------------------------------------------------------------
precision = %(precision)3s resolution = %(_str_resolution)s
machep = %(machep)6s eps = %(_str_eps)s
negep = %(negep)6s epsneg = %(_str_epsneg)s
minexp = %(minexp)6s tiny = %(_str_tiny)s
maxexp = %(maxexp)6s max = %(_str_max)s
nexp = %(nexp)6s min = -max
smallest_normal = %(_str_smallest_normal)s smallest_subnormal = %(_str_smallest_subnormal)s
---------------------------------------------------------------
)r6 rC rU s r __str__z
finfo.__str__6 s
P T]""r c ` | j j }| j }||d< d|z S )NklasszZ%(klass)s(resolution=%(resolution)s, min=-%(_str_max)s, max=%(_str_max)s, dtype=%(dtype)s)) __class__rV r6 r )rC cds r __repr__zfinfo.__repr__F s: N # M '
7:;< =r c t | j j j d r t j dt d | j j j d S )a7 Return the value for the smallest normal.
Returns
-------
smallest_normal : float
Value for the smallest normal.
Warns
-----
UserWarning
If the calculated value for the smallest normal is requested for
double-double.
r z;The value of smallest normal is undefined for double doubler rG )r r r3 r rI rJ rL rP s r r3 zfinfo.smallest_normalM sW " -215 6 6 + MM
+
+
+
+ |+033r c | j S )aQ Return the value for tiny, alias of smallest_normal.
Returns
-------
tiny : float
Value for the smallest normal, alias of smallest_normal.
Warns
-----
UserWarning
If the calculated value for the smallest normal is requested for
double-double.
)r3 rP s r r4 z
finfo.tinyd s
##r N) rV rW rX rY r r r r r rZ r3 r4 r r r r r z s d dL L6 6 6p 4# # # = = = 4 4 X4, $ $ X$ $ $r c X e Zd ZdZi Zi Zd Zed Zed Z d Z
d Z dS )r a
iinfo(type)
Machine limits for integer types.
Attributes
----------
bits : int
The number of bits occupied by the type.
dtype : dtype
Returns the dtype for which `iinfo` returns information.
min : int
The smallest integer expressible by the type.
max : int
The largest integer expressible by the type.
Parameters
----------
int_type : integer type, dtype, or instance
The kind of integer data type to get information about.
See Also
--------
finfo : The equivalent for floating point data types.
Examples
--------
With types:
>>> ii16 = np.iinfo(np.int16)
>>> ii16.min
-32768
>>> ii16.max
32767
>>> ii32 = np.iinfo(np.int32)
>>> ii32.min
-2147483648
>>> ii32.max
2147483647
With instances:
>>> ii32 = np.iinfo(np.int32(10))
>>> ii32.min
-2147483648
>>> ii32.max
2147483647
c ` t j | | _ n6# t $ r) t j t | | _ Y nw xY w| j j | _ | j j dz | _ d| j | j fz | _ | j dvrt d| j d d S )Nrq z%s%diuzInvalid integer data type .) r r% r r kindr r r r )rC int_types r rE ziinfo.__init__ s 7 x00DJJ 7 7 7 tH~~66DJJJ 7JO J'!+ TY 22 9D * KLL L ! s 0AAc | j dk rdS t j | j }n?# t $ r2 t d| j dz
z }|t j | j < Y nw xY w|S )z Minimum value of given dtype.ur r )r r _min_valsr KeyErrorr8 r rC vals r r z iinfo.min s| 9 1
0odh/
0
0
0A$)A+ ./00,/)))
0 Js ' 9A#"A#c t j | j }ng# t $ rZ | j dk rt d| j z dz
}n t d| j dz
z dz
}|t j | j < Y nw xY w|S )z Maximum value of given dtype.r r )r _max_valsr r r r8 r r s r r z iinfo.max s ,/$(+CC , , ,yC 1 >Q.//11-233(+EODH % % % ,
s A!A>=A>c 6 d}|| j | j | j dz S )zString representation.zMachine parameters for %(dtype)s
---------------------------------------------------------------
min = %(min)s
max = %(max)s
---------------------------------------------------------------
r% r r r r s r r z
iinfo.__str__ s*
P tz$(48LLLLr c P | j j d| j d| j d| j dS )Nz(min=z, max=z, dtype=))r rV r r r% rP s r r ziinfo.__repr__ s5 15 1H1H1H$(HHHdhhh
D Dr N) rV rW rX rY r r rE rZ r r r r r r r r r v s 0 0d II M M M
X
X
M M MD D D D Dr )0rY __all__rI _utilsr r r r r
r r r r
umathr r r r r r r csingler\ complex_float_
clongfloat longfloatr
_title_fmtr[ dictint64rK int32r longlongr] int16r( r` rc r r r r r r r r r r s G
$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ 0 0 0 0 0 0 0 0 0 0 0 0
WF WF WF WF WF WF WF WFv NFM
OV]
v' 8
M44 !!(++- - - M44 !!(++- - - tt!!-002 2 2 K !!&))+ + +,4 # # # N" N" N"b6% 6% 6%r # # # Gx$ x$ x$ x$ x$ x$ x$ x$v GhD hD hD hD hD hD hD hD hD hDr