U
|
O ±dL8 ã @ sj d Z ddlZddlZddlZddlmZ ddlmZm Z m
|
Z
|
m Z m Z m Z mZmZmZmZmZmZ ddlmZ ddd d
|
d d d dgZe e
|
e e e edZdd e ¡ D Zedd!ddZeddd Zeddd Zeddd
|
Z eddd Z eddd Z G dd dZ e Z edG dd d ej!Z"d d Z#e# ej$dd d Z%edej&d d Z'dS )"z}
|
Functions for changing global ufunc configuration
|
|
This provides helpers which wrap `umath.geterrobj` and `umath.seterrobj`
|
é Né )Ú
|
set_module) ÚUFUNC_BUFSIZE_DEFAULTÚ
|
ERR_IGNOREÚERR_WARNÚ ERR_RAISEÚERR_CALLÚ ERR_PRINTÚERR_LOGÚ ERR_DEFAULTÚSHIFT_DIVIDEBYZEROÚSHIFT_OVERFLOWÚSHIFT_UNDERFLOWÚ SHIFT_INVALID)ÚumathÚseterrÚgeterrÚ
|
setbufsizeÚ
|
getbufsizeÚ
|
seterrcallÚ
|
geterrcallÚerrstateÚ_no_nep50_warning)ÚignoreÚwarnÚraiseÚcallÚprintÚlogc C s i | ]\}}||qS © r )Ú.0ÚkeyÚvaluer r úOd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/core/_ufunc_config.pyÚ
|
<dictcomp> s r$ Únumpyc C s¤ t ¡ }t }|dkr"| p |d }|dkr6| p4|d }|dkrJ| pH|d }|dkr^| p\|d }t| t> t| t> t| t> t| t> }||d< t |¡ |S )a
|
Set how floating-point errors are handled.
|
|
Note that operations on integer scalar types (such as `int16`) are
|
handled like floating point, and are affected by these settings.
|
|
Parameters
|
----------
|
all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
Set treatment for all types of floating-point errors at once:
|
|
- ignore: Take no action when the exception occurs.
|
- warn: Print a `RuntimeWarning` (via the Python `warnings` module).
|
- raise: Raise a `FloatingPointError`.
|
- call: Call a function specified using the `seterrcall` function.
|
- print: Print a warning directly to ``stdout``.
|
- log: Record error in a Log object specified by `seterrcall`.
|
|
The default is not to change the current behavior.
|
divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
Treatment for division by zero.
|
over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
Treatment for floating-point overflow.
|
under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
Treatment for floating-point underflow.
|
invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
|
Treatment for invalid floating-point operation.
|
|
Returns
|
-------
|
old_settings : dict
|
Dictionary containing the old settings.
|
|
See also
|
--------
|
seterrcall : Set a callback function for the 'call' mode.
|
geterr, geterrcall, errstate
|
|
Notes
|
-----
|
The floating-point exceptions are defined in the IEEE 754 standard [1]_:
|
|
- Division by zero: infinite result obtained from finite numbers.
|
- Overflow: result too large to be expressed.
|
- Underflow: result so close to zero that some precision
|
was lost.
|
- Invalid operation: result is not an expressible number, typically
|
indicates that a NaN was produced.
|
|
.. [1] https://en.wikipedia.org/wiki/IEEE_754
|
|
Examples
|
--------
|
>>> old_settings = np.seterr(all='ignore') #seterr to known value
|
>>> np.seterr(over='raise')
|
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
|
>>> np.seterr(**old_settings) # reset to default
|
{'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}
|
|
>>> np.int16(32000) * np.int16(3)
|
30464
|
>>> old_settings = np.seterr(all='warn', over='raise')
|
>>> np.int16(32000) * np.int16(3)
|
Traceback (most recent call last):
|
File "<stdin>", line 1, in <module>
|
FloatingPointError: overflow encountered in scalar multiply
|
|
>>> old_settings = np.seterr(all='print')
|
>>> np.geterr()
|
{'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}
|
>>> np.int16(32000) * np.int16(3)
|
30464
|
|
NÚdivideÚoverÚunderÚinvalidr ) r Ú geterrobjr Ú_errdictr r r r Ú seterrobj)Úallr& r' r( r) ÚpyvalsÚoldÚ maskvaluer r r# r ! s( M
|
|
ÿ
|
þ
|
ý
|
c C sx t ¡ d } d}i }| t? |@ }t| |d< | t? |@ }t| |d< | t? |@ }t| |d< | t? |@ }t| |d< |S )að
|
Get the current way of handling floating-point errors.
|
|
Returns
|
-------
|
res : dict
|
A dictionary with keys "divide", "over", "under", and "invalid",
|
whose values are from the strings "ignore", "print", "log", "warn",
|
"raise", and "call". The keys represent possible floating-point
|
exceptions, and the values define how these exceptions are handled.
|
|
See Also
|
--------
|
geterrcall, seterr, seterrcall
|
|
Notes
|
-----
|
For complete documentation of the types of floating-point exceptions and
|
treatment options, see `seterr`.
|
|
Examples
|
--------
|
>>> np.geterr()
|
{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}
|
>>> np.arange(3.) / np.arange(3.)
|
array([nan, 1., 1.])
|
|
>>> oldsettings = np.seterr(all='warn', over='raise')
|
>>> np.geterr()
|
{'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'}
|
>>> np.arange(3.) / np.arange(3.)
|
array([nan, 1., 1.])
|
|
r é r& r' r( r) )r r* r Ú _errdict_revr r r )r0 ÚmaskÚresÚvalr r r# r s $ c C sd | dkrt d| | dk r(t d| | d dkr@t d| t ¡ }t }| |d< t |¡ |S )z{
|
Set the size of the buffer used in ufuncs.
|
|
Parameters
|
----------
|
size : int
|
Size of buffer.
|
|
g ÐcAz Buffer size, %s, is too big.é z Buffer size, %s, is too small.é r z)Buffer size, %s, is not a multiple of 16.)Ú
|
ValueErrorr r* r r, )Úsizer. r/ r r r# r ¶ s
|
c C s t ¡ d S )z
|
Return the size of the buffer used in ufuncs.
|
|
Returns
|
-------
|
getbufsize : int
|
Size of ufunc buffer in bytes.
|
|
r ©r r* r r r r# r Ï s c C s\ | dk r8t | tjjs8t| dr0t | jtjjs8tdt ¡ }t }| |d< t
|
|¡ |S )aÇ
|
Set the floating-point error callback function or log object.
|
|
There are two ways to capture floating-point error messages. The first
|
is to set the error-handler to 'call', using `seterr`. Then, set
|
the function to call using this function.
|
|
The second is to set the error-handler to 'log', using `seterr`.
|
Floating-point errors then trigger a call to the 'write' method of
|
the provided object.
|
|
Parameters
|
----------
|
func : callable f(err, flag) or object with write method
|
Function to call upon floating-point errors ('call'-mode) or
|
object whose 'write' method is used to log such message ('log'-mode).
|
|
The call function takes two arguments. The first is a string describing
|
the type of error (such as "divide by zero", "overflow", "underflow",
|
or "invalid value"), and the second is the status flag. The flag is a
|
byte, whose four least-significant bits indicate the type of error, one
|
of "divide", "over", "under", "invalid"::
|
|
[0 0 0 0 divide over under invalid]
|
|
In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
|
|
If an object is provided, its write method should take one argument,
|
a string.
|
|
Returns
|
-------
|
h : callable, log instance or None
|
The old error handler.
|
|
See Also
|
--------
|
seterr, geterr, geterrcall
|
|
Examples
|
--------
|
Callback upon error:
|
|
>>> def err_handler(type, flag):
|
... print("Floating point error (%s), with flag %s" % (type, flag))
|
...
|
|
>>> saved_handler = np.seterrcall(err_handler)
|
>>> save_err = np.seterr(all='call')
|
|
>>> np.array([1, 2, 3]) / 0.0
|
Floating point error (divide by zero), with flag 1
|
array([inf, inf, inf])
|
|
>>> np.seterrcall(saved_handler)
|
<function err_handler at 0x...>
|
>>> np.seterr(**save_err)
|
{'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'}
|
|
Log error message:
|
|
>>> class Log:
|
... def write(self, msg):
|
... print("LOG: %s" % msg)
|
...
|
|
>>> log = Log()
|
>>> saved_handler = np.seterrcall(log)
|
>>> save_err = np.seterr(all='log')
|
|
>>> np.array([1, 2, 3]) / 0.0
|
LOG: Warning: divide by zero encountered in divide
|
array([inf, inf, inf])
|
|
>>> np.seterrcall(saved_handler)
|
<numpy.core.numeric.Log object at 0x...>
|
>>> np.seterr(**save_err)
|
{'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'}
|
|
NÚwritez%Only callable can be used as callbacké ) Ú
|
isinstanceÚ collectionsÚabcÚCallableÚhasattrr; r8 r r* r r, )Úfuncr. r/ r r r# r Ý s R
|
ÿ
|
c C s t ¡ d S )aé
|
Return the current callback function used on floating-point errors.
|
|
When the error handling for a floating-point error (one of "divide",
|
"over", "under", or "invalid") is set to 'call' or 'log', the function
|
that is called or the log instance that is written to is returned by
|
`geterrcall`. This function or log instance has been set with
|
`seterrcall`.
|
|
Returns
|
-------
|
errobj : callable, log instance or None
|
The current error handler. If no handler was set through `seterrcall`,
|
``None`` is returned.
|
|
See Also
|
--------
|
seterrcall, seterr, geterr
|
|
Notes
|
-----
|
For complete documentation of the types of floating-point exceptions and
|
treatment options, see `seterr`.
|
|
Examples
|
--------
|
>>> np.geterrcall() # we did not yet set a handler, returns None
|
|
>>> oldsettings = np.seterr(all='call')
|
>>> def err_handler(type, flag):
|
... print("Floating point error (%s), with flag %s" % (type, flag))
|
>>> oldhandler = np.seterrcall(err_handler)
|
>>> np.array([1, 2, 3]) / 0.0
|
Floating point error (divide by zero), with flag 1
|
array([inf, inf, inf])
|
|
>>> cur_handler = np.geterrcall()
|
>>> cur_handler is err_handler
|
True
|
|
r< r: r r r r# r : s +c @ s e Zd ZdS )Ú _unspecifiedN)Ú__name__Ú
|
__module__Ú __qualname__r r r r# rC h s rC c @ s. e Zd ZdZedddZdd Zdd Zd S )
|
r a/
|
errstate(**kwargs)
|
|
Context manager for floating-point error handling.
|
|
Using an instance of `errstate` as a context manager allows statements in
|
that context to execute with a known error handling behavior. Upon entering
|
the context the error handling is set with `seterr` and `seterrcall`, and
|
upon exiting it is reset to what it was before.
|
|
.. versionchanged:: 1.17.0
|
`errstate` is also usable as a function decorator, saving
|
a level of indentation if an entire function is wrapped.
|
See :py:class:`contextlib.ContextDecorator` for more information.
|
|
Parameters
|
----------
|
kwargs : {divide, over, under, invalid}
|
Keyword arguments. The valid keywords are the possible floating-point
|
exceptions. Each keyword should have a string value that defines the
|
treatment for the particular error. Possible values are
|
{'ignore', 'warn', 'raise', 'call', 'print', 'log'}.
|
|
See Also
|
--------
|
seterr, geterr, seterrcall, geterrcall
|
|
Notes
|
-----
|
For complete documentation of the types of floating-point exceptions and
|
treatment options, see `seterr`.
|
|
Examples
|
--------
|
>>> olderr = np.seterr(all='ignore') # Set error handling to known state.
|
|
>>> np.arange(3) / 0.
|
array([nan, inf, inf])
|
>>> with np.errstate(divide='warn'):
|
... np.arange(3) / 0.
|
array([nan, inf, inf])
|
|
>>> np.sqrt(-1)
|
nan
|
>>> with np.errstate(invalid='raise'):
|
... np.sqrt(-1)
|
Traceback (most recent call last):
|
File "<stdin>", line 2, in <module>
|
FloatingPointError: invalid value encountered in sqrt
|
|
Outside the context the error handling behavior has not changed:
|
|
>>> np.geterr()
|
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
|
|
)r c K s || _ || _d S ©N)r Úkwargs)Úselfr rH r r r# Ú__init__ª s zerrstate.__init__c C s( t f | j| _| jtk r$t| j| _d S rG )r rH Úoldstater Ú _Unspecifiedr Úoldcall)rI r r r# Ú __enter__® s
|
zerrstate.__enter__c G s$ t f | j | jtk r t| j d S rG )r rK r rL r rM )rI Úexc_infor r r# Ú__exit__³ s
|
zerrstate.__exit__N)rD rE rF Ú__doc__rL rJ rN rP r r r r# r o s 9c C s t td g} t | ¡ d S rG )r r r r, )Zdefvalr r r# Ú_setdef¹ s
|
rR F)Údefaultc c s& t d¡} z
|
dV W 5 t | ¡ X dS )zõ
|
Context manager to disable NEP 50 warnings. This context manager is
|
only relevant if the NEP 50 warnings are enabled globally (which is not
|
thread/context safe).
|
|
This warning context manager itself is fully safe, however.
|
TN)ÚNO_NEP50_WARNINGÚsetÚreset)Útokenr r r# r Ä s
|
|
|
)NNNNN)(rQ Úcollections.abcr> Ú
|
contextlibZ contextvarsZ overridesr r r r r r r r r
|
r r r r r Ú Ú__all__r+ Úitemsr2 r r r r r r rC rL ÚContextDecoratorr rR Z
|
ContextVarrT Úcontextmanagerr r r r r# Ú<module> sZ 8 þû b
|
1
|
|
|
\
|
-I
|
