U
|
P ±dºP ã @ s2 d Z ddlZddlZddddddd d
|
d d d dg Zddlm mZ ddlmZm Z m
|
Z
|
m Z ddl m Z ddlmZ ddlmZmZ ejejddZdZe ddQdd ZdRddZeeejfd d Zd d Zeed d Zd d! Z ee d"d Z d#d$ Z ee d%d Z ee d&d Z ee d'd Z!ee d(d Z"d)d* Z#dSd+d,Z$ee$dTd/dZ%dUd0d1Z&ee&dVd3d
|
Z'd4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJZ(e ddKd Z)ej*ej+ej,ej-gdej.ej/ej0ggZ1ej*dej+dej,dLej-dMej.dej/dLej0dMiZ2dNdO Z3ee3dPd Z4dS )Wz@Automatically adapted for numpy Sep 19, 2005 by convertcode.py
|
|
é NÚ iscomplexobjÚ isrealobjÚimagÚ iscomplexÚisrealÚ
|
nan_to_numÚrealÚ real_if_closeÚtypenameÚasfarrayÚ mintypecodeÚ common_type)ÚasarrayÚ
|
asanyarrayÚisnanÚzeros)Ú
|
set_module)Ú overridesé )ÚisneginfÚisposinfÚnumpy)ÚmodulezGDFgdfQqLlIiHhBb?ÚGDFgdfÚdc sN dd | D }t fdd|D }|s,|S d|kr@d|kr@dS t|tjdS )aé
|
Return the character for the minimum-size type to which given types can
|
be safely cast.
|
|
The returned type character must represent the smallest size dtype such
|
that an array of the returned type can handle the data from an array of
|
all types in `typechars` (or if `typechars` is an array, then its
|
dtype.char).
|
|
Parameters
|
----------
|
typechars : list of str or array_like
|
If a list of strings, each string should represent a dtype.
|
If array_like, the character representation of the array dtype is used.
|
typeset : str or list of str, optional
|
The set of characters that the returned character is chosen from.
|
The default set is 'GDFgdf'.
|
default : str, optional
|
The default character, this is returned if none of the characters in
|
`typechars` matches a character in `typeset`.
|
|
Returns
|
-------
|
typechar : str
|
The character representing the minimum-size type that was found.
|
|
See Also
|
--------
|
dtype, sctype2char, maximum_sctype
|
|
Examples
|
--------
|
>>> np.mintypecode(['d', 'f', 'S'])
|
'd'
|
>>> x = np.array([1.1, 2-3.j])
|
>>> np.mintypecode(x)
|
'D'
|
|
>>> np.mintypecode('abceh', default='G')
|
'G'
|
|
c s s( | ] }t |tr|p t|jjV qd S ©N)Ú
|
isinstanceÚstrr ÚdtypeÚchar©Ú.0Út© r# úKd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/lib/type_check.pyÚ <genexpr>F s ÿz mintypecode.<locals>.<genexpr>c 3 s | ]}| kr|V qd S r r# r ©Útypesetr# r$ r% H s ÚFr ÚD)Úkey)ÚsetÚminÚ_typecodes_by_elsizeÚindex)Z typecharsr' ÚdefaultZ typecodesÚ intersectionr# r& r$ r s ,ÿc C s | fS r r# ©Úar r# r# r$ Ú_asfarray_dispatcherP s r3 c C s t |t j¡st j}t| |dS )aJ
|
Return an array converted to a float type.
|
|
Parameters
|
----------
|
a : array_like
|
The input array.
|
dtype : str or dtype object, optional
|
Float type code to coerce input array `a`. If `dtype` is one of the
|
'int' dtypes, it is replaced with float64.
|
|
Returns
|
-------
|
out : ndarray
|
The input `a` as a float ndarray.
|
|
Examples
|
--------
|
>>> np.asfarray([2, 3])
|
array([2., 3.])
|
>>> np.asfarray([2, 3], dtype='float')
|
array([2., 3.])
|
>>> np.asfarray([2, 3], dtype='int8')
|
array([2., 3.])
|
|
)r )Ú_nxZ
|
issubdtypeÚinexactÚfloat_r r1 r# r# r$ r T s c C s | fS r r# ©Úvalr# r# r$ Ú_real_dispatcheru s r9 c C s, z| j W S tk
|
r& t| j Y S X dS )aÑ
|
Return the real part of the complex argument.
|
|
Parameters
|
----------
|
val : array_like
|
Input array.
|
|
Returns
|
-------
|
out : ndarray or scalar
|
The real component of the complex argument. If `val` is real, the type
|
of `val` is used for the output. If `val` has complex elements, the
|
returned type is float.
|
|
See Also
|
--------
|
real_if_close, imag, angle
|
|
Examples
|
--------
|
>>> a = np.array([1+2j, 3+4j, 5+6j])
|
>>> a.real
|
array([1., 3., 5.])
|
>>> a.real = 9
|
>>> a
|
array([9.+2.j, 9.+4.j, 9.+6.j])
|
>>> a.real = np.array([9, 8, 7])
|
>>> a
|
array([9.+2.j, 8.+4.j, 7.+6.j])
|
>>> np.real(1 + 1j)
|
1.0
|
|
N)r ÚAttributeErrorr r7 r# r# r$ r y s $c C s | fS r r# r7 r# r# r$ Ú_imag_dispatcher£ s r; c C s, z| j W S tk
|
r& t| j Y S X dS )a
|
Return the imaginary part of the complex argument.
|
|
Parameters
|
----------
|
val : array_like
|
Input array.
|
|
Returns
|
-------
|
out : ndarray or scalar
|
The imaginary component of the complex argument. If `val` is real,
|
the type of `val` is used for the output. If `val` has complex
|
elements, the returned type is float.
|
|
See Also
|
--------
|
real, angle, real_if_close
|
|
Examples
|
--------
|
>>> a = np.array([1+2j, 3+4j, 5+6j])
|
>>> a.imag
|
array([2., 4., 6.])
|
>>> a.imag = np.array([8, 10, 12])
|
>>> a
|
array([1. +8.j, 3.+10.j, 5.+12.j])
|
>>> np.imag(1 + 1j)
|
1.0
|
|
N)r r: r r7 r# r# r$ r § s !c C s | fS r r# ©Úxr# r# r$ Ú_is_type_dispatcherÎ s r> c C s6 t | }t|jjtjr"|jdkS t|jt }|d S )aY
|
Returns a bool array, where True if input element is complex.
|
|
What is tested is whether the input has a non-zero imaginary part, not if
|
the input type is complex.
|
|
Parameters
|
----------
|
x : array_like
|
Input array.
|
|
Returns
|
-------
|
out : ndarray of bools
|
Output array.
|
|
See Also
|
--------
|
isreal
|
iscomplexobj : Return True if x is a complex type or an array of complex
|
numbers.
|
|
Examples
|
--------
|
>>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
|
array([ True, False, False, False, False, True])
|
|
r r# )
|
r Ú
|
issubclassr Útyper4 Úcomplexfloatingr r ÚshapeÚbool)r= ZaxÚresr# r# r$ r Ò s
|
|
c C s t | dkS )aÔ
|
Returns a bool array, where True if input element is real.
|
|
If element has complex type with zero complex part, the return value
|
for that element is True.
|
|
Parameters
|
----------
|
x : array_like
|
Input array.
|
|
Returns
|
-------
|
out : ndarray, bool
|
Boolean array of same shape as `x`.
|
|
Notes
|
-----
|
`isreal` may behave unexpectedly for string or object arrays (see examples)
|
|
See Also
|
--------
|
iscomplex
|
isrealobj : Return True if x is not a complex type.
|
|
Examples
|
--------
|
>>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)
|
>>> np.isreal(a)
|
array([False, True, True, True, True, False])
|
|
The function does not work on string arrays.
|
|
>>> a = np.array([2j, "a"], dtype="U")
|
>>> np.isreal(a) # Warns about non-elementwise comparison
|
False
|
|
Returns True for all elements in input array of ``dtype=object`` even if
|
any of the elements is complex.
|
|
>>> a = np.array([1, "2", 3+4j], dtype=object)
|
>>> np.isreal(a)
|
array([ True, True, True])
|
|
isreal should not be used with object arrays
|
|
>>> a = np.array([1+2j, 2+1j], dtype=object)
|
>>> np.isreal(a)
|
array([ True, True])
|
|
r )r r< r# r# r$ r ÷ s 5c C s> z| j }|j}W n tk
|
r0 t| j j}Y nX t|tjS )a
|
Check for a complex type or an array of complex numbers.
|
|
The type of the input is checked, not the value. Even if the input
|
has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
|
|
Parameters
|
----------
|
x : any
|
The input can be of any type and shape.
|
|
Returns
|
-------
|
iscomplexobj : bool
|
The return value, True if `x` is of a complex type or has at least
|
one complex element.
|
|
See Also
|
--------
|
isrealobj, iscomplex
|
|
Examples
|
--------
|
>>> np.iscomplexobj(1)
|
False
|
>>> np.iscomplexobj(1+0j)
|
True
|
>>> np.iscomplexobj([3, 1+0j, True])
|
True
|
|
)r r@ r: r r? r4 rA )r= r Útype_r# r# r$ r / s !
|
c C s
|
t | S )aÈ
|
Return True if x is a not complex type or an array of complex numbers.
|
|
The type of the input is checked, not the value. So even if the input
|
has an imaginary part equal to zero, `isrealobj` evaluates to False
|
if the data type is complex.
|
|
Parameters
|
----------
|
x : any
|
The input can be of any type and shape.
|
|
Returns
|
-------
|
y : bool
|
The return value, False if `x` is of a complex type.
|
|
See Also
|
--------
|
iscomplexobj, isreal
|
|
Notes
|
-----
|
The function is only meant for arrays with numerical values but it
|
accepts all other objects. Since it assumes array input, the return
|
value of other objects may be True.
|
|
>>> np.isrealobj('A string')
|
True
|
>>> np.isrealobj(False)
|
True
|
>>> np.isrealobj(None)
|
True
|
|
Examples
|
--------
|
>>> np.isrealobj(1)
|
True
|
>>> np.isrealobj(1+0j)
|
False
|
>>> np.isrealobj([3, 1+0j, True])
|
False
|
|
)r r< r# r# r$ r X s .c C s" ddl m} | | ¡}|j|jfS )Nr ©Ú getlimits)Ú
|
numpy.corerG ÚfinfoÚmaxr, )r" rG Úfr# r# r$ Ú
|
_getmaxmin s
|
rL c C s | fS r r# )r= ÚcopyÚnanÚposinfÚneginfr# r# r$ Ú_nan_to_num_dispatcher s rQ Tç c C sê t j| d|d} | jj}| jdk}t|t js>|r:| d S | S t|t j}|rZ| j| j fn| f}t
|
| jj\} }
|
|dk r||} |dk r|}
|
|D ]L} t | } t | } t | }t j| || d t j| | | d t j| |
|
|d q|ræ| d S | S )aÀ
|
Replace NaN with zero and infinity with large finite numbers (default
|
behaviour) or with the numbers defined by the user using the `nan`,
|
`posinf` and/or `neginf` keywords.
|
|
If `x` is inexact, NaN is replaced by zero or by the user defined value in
|
`nan` keyword, infinity is replaced by the largest finite floating point
|
values representable by ``x.dtype`` or by the user defined value in
|
`posinf` keyword and -infinity is replaced by the most negative finite
|
floating point values representable by ``x.dtype`` or by the user defined
|
value in `neginf` keyword.
|
|
For complex dtypes, the above is applied to each of the real and
|
imaginary components of `x` separately.
|
|
If `x` is not inexact, then no replacements are made.
|
|
Parameters
|
----------
|
x : scalar or array_like
|
Input data.
|
copy : bool, optional
|
Whether to create a copy of `x` (True) or to replace values
|
in-place (False). The in-place operation only occurs if
|
casting to an array does not require a copy.
|
Default is True.
|
|
.. versionadded:: 1.13
|
nan : int, float, optional
|
Value to be used to fill NaN values. If no value is passed
|
then NaN values will be replaced with 0.0.
|
|
.. versionadded:: 1.17
|
posinf : int, float, optional
|
Value to be used to fill positive infinity values. If no value is
|
passed then positive infinity values will be replaced with a very
|
large number.
|
|
.. versionadded:: 1.17
|
neginf : int, float, optional
|
Value to be used to fill negative infinity values. If no value is
|
passed then negative infinity values will be replaced with a very
|
small (or negative) number.
|
|
.. versionadded:: 1.17
|
|
|
|
Returns
|
-------
|
out : ndarray
|
`x`, with the non-finite values replaced. If `copy` is False, this may
|
be `x` itself.
|
|
See Also
|
--------
|
isinf : Shows which elements are positive or negative infinity.
|
isneginf : Shows which elements are negative infinity.
|
isposinf : Shows which elements are positive infinity.
|
isnan : Shows which elements are Not a Number (NaN).
|
isfinite : Shows which elements are finite (not NaN, not infinity)
|
|
Notes
|
-----
|
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
|
(IEEE 754). This means that Not a Number is not equivalent to infinity.
|
|
Examples
|
--------
|
>>> np.nan_to_num(np.inf)
|
1.7976931348623157e+308
|
>>> np.nan_to_num(-np.inf)
|
-1.7976931348623157e+308
|
>>> np.nan_to_num(np.nan)
|
0.0
|
>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
|
>>> np.nan_to_num(x)
|
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
|
-1.28000000e+002, 1.28000000e+002])
|
>>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
|
array([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,
|
-1.2800000e+02, 1.2800000e+02])
|
>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
|
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
|
-1.28000000e+002, 1.28000000e+002])
|
>>> np.nan_to_num(y)
|
array([ 1.79769313e+308 +0.00000000e+000j, # may vary
|
0.00000000e+000 +0.00000000e+000j,
|
0.00000000e+000 +1.79769313e+308j])
|
>>> np.nan_to_num(y, nan=111111, posinf=222222)
|
array([222222.+111111.j, 111111. +0.j, 111111.+222222.j])
|
T)ZsubokrM r r# N)Úwhere)r4 Úarrayr r@ Úndimr? r5 rA r r rL r r r Zcopyto)r= rM rN rO rP ZxtypeZisscalarr ÚdestZmaxfZminfr Zidx_nanZ
|
idx_posinfZ
|
idx_neginfr# r# r$ r s( ^
|
c C s | fS r r# )r2 Útolr# r# r$ Ú_real_if_close_dispatcher s rX éd c C sh t | } t| jjtjs | S |dkrHddlm} | | jj¡}|j | }t
|
t | j ¡|k ¡rd| j } | S )a}
|
If input is complex with all imaginary parts close to zero, return
|
real parts.
|
|
"Close to zero" is defined as `tol` * (machine epsilon of the type for
|
`a`).
|
|
Parameters
|
----------
|
a : array_like
|
Input array.
|
tol : float
|
Tolerance in machine epsilons for the complex part of the elements
|
in the array.
|
|
Returns
|
-------
|
out : ndarray
|
If `a` is real, the type of `a` is used for the output. If `a`
|
has complex elements, the returned type is float.
|
|
See Also
|
--------
|
real, imag, angle
|
|
Notes
|
-----
|
Machine epsilon varies from machine to machine and between data types
|
but Python floats on most platforms have a machine epsilon equal to
|
2.2204460492503131e-16. You can use 'np.finfo(float).eps' to print
|
out the machine epsilon for floats.
|
|
Examples
|
--------
|
>>> np.finfo(float).eps
|
2.2204460492503131e-16 # may vary
|
|
>>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)
|
array([2.1, 5.2])
|
>>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)
|
array([2.1+4.e-13j, 5.2 + 3e-15j])
|
|
r r rF )r r? r r@ r4 rA rH rG rI ZepsÚallÚabsoluter r )r2 rW rG rK r# r# r$ r s -
|
Ú characterrC z signed charz unsigned charÚshortzunsigned shortÚintegerzunsigned integerz long integerzunsigned long integerzlong long integerzunsigned long long integerzsingle precisionzdouble precisionzlong precisionzcomplex single precisionzcomplex double precisionz complex long double precisionÚstringÚunicodeZvoidÚobject)ZS1ú?ÚbÚBÚhÚHÚiÚIÚlÚLÚqÚQrK r Úgr( r) ÚGÚSÚUÚVÚOc C s t | S )aD
|
Return a description for the given data type code.
|
|
Parameters
|
----------
|
char : str
|
Data type code.
|
|
Returns
|
-------
|
out : str
|
Description of the input data type code.
|
|
See Also
|
--------
|
dtype, typecodes
|
|
Examples
|
--------
|
>>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
|
... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
|
>>> for typechar in typechars:
|
... print(typechar, ' : ', np.typename(typechar))
|
...
|
S1 : character
|
? : bool
|
B : unsigned char
|
D : complex double precision
|
G : complex long double precision
|
F : complex single precision
|
I : unsigned integer
|
H : unsigned short
|
L : unsigned long integer
|
O : object
|
Q : unsigned long long integer
|
S : string
|
U : unicode
|
V : void
|
b : signed char
|
d : double precision
|
g : long precision
|
f : single precision
|
i : integer
|
h : short
|
l : long integer
|
q : long long integer
|
|
)Ú _namefromtype)r r# r# r$ r
|
d s 2é é c G s | S r r# )Úarraysr# r# r$ Ú_common_type_dispatcher¦ s rw c G s~ d}d}| D ]P}|j j}t|r$d}t|tjr6d}n t |d¡}|dkrRtdt ||}q |rnt
|
d | S t
|
d | S dS )aË
|
Return a scalar type which is common to the input arrays.
|
|
The return type will always be an inexact (i.e. floating point) scalar
|
type, even if all the arrays are integer arrays. If one of the inputs is
|
an integer array, the minimum precision type that is returned is a
|
64-bit floating point dtype.
|
|
All input arrays except int64 and uint64 can be safely cast to the
|
returned dtype without loss of information.
|
|
Parameters
|
----------
|
array1, array2, ... : ndarrays
|
Input arrays.
|
|
Returns
|
-------
|
out : data type code
|
Data type code.
|
|
See Also
|
--------
|
dtype, mintypecode
|
|
Examples
|
--------
|
>>> np.common_type(np.arange(2, dtype=np.float32))
|
<class 'numpy.float32'>
|
>>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
|
<class 'numpy.float64'>
|
>>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
|
<class 'numpy.complex128'>
|
|
Fr Trt Nz+can't get common type for non-numeric arrayr ) r r@ r r? r4 r^ Úarray_precisionÚgetÚ TypeErrorrJ Ú
|
array_type)rv Z
|
is_complexZ precisionr2 r" Úpr# r# r$ r ª s % )r r )N)NNNN)TrR NN)N)rY )5Ú__doc__Ú functoolsÚwarningsÚ__all__Znumpy.core.numericÚcoreÚnumericr4 r r r r Znumpy.core.overridesr rH r Z ufuncliker r ÚpartialZarray_function_dispatchr- r r3 r6 r r9 r r; r r> r r r r rL rQ r rX r rs r
|
ZhalfZsingleÚdoubleZ
|
longdoubleZcsingleZcdoubleZ clongdoubler{ rx rw r r# r# r# r$ Ú<module> s¼ ý ÿ 5
|
|
)
|
&
|
$
|
7
|
(
|
1
|
x
|
:ë
|
6ÿ ú
|
