numpy.core._ufunc

module documentation

(source)

Functions for changing global ufunc configuration

This provides helpers which wrap umath.geterrobj and umath.seterrobj

Class	`errstate`	errstate(**kwargs)
Function	`getbufsize`	Return the size of the buffer used in ufuncs.
Function	`geterr`	Get the current way of handling floating-point errors.
Function	`geterrcall`	Return the current callback function used on floating-point errors.
Function	`setbufsize`	Set the size of the buffer used in ufuncs.
Function	`seterr`	Set how floating-point errors are handled.
Function	`seterrcall`	Set the floating-point error callback function or log object.
Constant	`NO_NEP50_WARNING`	Undocumented
Class	`_unspecified`	Undocumented
Function	`_no_nep50_warning`	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).
Function	`_setdef`	Undocumented
Variable	`_errdict`	Undocumented
Variable	`_errdict_rev`	Undocumented
Variable	`_Unspecified`	Undocumented

@set_module('numpy')
def getbufsize(): (source) ¶

Return the size of the buffer used in ufuncs.

Returns
`int`	getbufsize - Size of ufunc buffer in bytes.

@set_module('numpy')
def geterr(): (source) ¶

Get the current way of handling floating-point errors.

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.])

Returns
`dict`	res - 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.

@set_module('numpy')
def geterrcall(): (source) ¶

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.

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

Returns
`callable`, log instance or `None`	errobj - The current error handler. If no handler was set through `seterrcall`, `None` is returned.

@set_module('numpy')
def setbufsize(size): (source) ¶

Set the size of the buffer used in ufuncs.

Parameters
size:`int`	Size of buffer.

@set_module('numpy')
def seterr(all=None, divide=None, over=None, under=None, invalid=None): (source) ¶

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.

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

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
`dict`	old_settings - Dictionary containing the old settings.

@set_module('numpy')
def seterrcall(func): (source) ¶

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.

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'}

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 + 2over + 4under + 8*invalid`. If an object is provided, its write method should take one argument, a string.
Returns
`callable`, log instance or `None`	h - The old error handler.

NO_NEP50_WARNING = (source) ¶

Undocumented

Value

contextvars.ContextVar('_no_nep50_warning',
                       default=False)

@set_module('numpy')
@contextlib.contextmanager
def _no_nep50_warning(): (source) ¶

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.

def _setdef(): (source) ¶

Undocumented

_errdict = (source) ¶

Undocumented

_errdict_rev = (source) ¶

Undocumented

_Unspecified = (source) ¶

Undocumented

numpy.core._ufunc_config

`numpy.core._ufunc_config`