cf.Data.seterr

static Data.seterr(all=None, divide=None, over=None, under=None, invalid=None)

Set how floating-point errors in the results of arithmetic operations are handled.

The options for handling floating-point errors are:

Treatment	Action
'ignore'	Take no action. Allows invalid values to occur in the result data array.
'warn'	Print a RuntimeWarning (via the Python warnings module). Allows invalid values to occur in the result data array.
'raise'	Raise a FloatingPointError exception.

The different types of floating-point errors are:

Error	Description	Default treatment
Division by zero	Infinite result obtained from finite numbers.	'warn'
Overflow	Result too large to be expressed.	'warn'
Invalid operation	Result is not an expressible number, typically indicates that a NaN was produced.	'warn'
Underflow	Result so close to zero that some precision was lost.	'ignore'

Note that operations on integer scalar types (such as int16) are handled like floating point, and are affected by these settings.

If called without any arguments then the current behaviour is returned.

See also

cf.Data.mask_fpe, mask_invalid

Parameters:

all : str, optional

Set the treatment for all types of floating-point errors at once. The default is not to change the current behaviour.

divide : str, optional

Set the treatment for division by zero. The default is not to change the current behaviour.

over : str, optional

Set the treatment for floating-point overflow. The default is not to change the current behaviour.

under : str, optional

Set the treatment for floating-point underflow. The default is not to change the current behaviour.

invalid : str, optional

Set the treatment for invalid floating-point operation. The default is not to change the current behaviour.

Returns:

out: dict

The behaviour prior to the change, or the current behaviour if no new values are specified.

Examples:

Set treatment for all types of floating-point errors to 'raise' and then reset to the previous behaviours:

>>> cf.Data.seterr()
{'divide': 'warn', 'invalid': 'warn', 'over': 'warn', 'under': 'ignore'}
>>> old = cf.Data.seterr('raise')
>>> cf.Data.seterr(**old)
{'divide': 'raise', 'invalid': 'raise', 'over': 'raise', 'under': 'raise'}
>>> cf.Data.seterr()
{'divide': 'warn', 'invalid': 'warn', 'over': 'warn', 'under': 'ignore'}

Set the treatment of division by zero to 'ignore' and overflow to 'warn' without changing the treatment of underflow and invalid operation:

>>> cf.Data.seterr(divide='ignore', over='warn')
{'divide': 'warn', 'invalid': 'warn', 'over': 'warn', 'under': 'ignore'}
>>> cf.Data.seterr()
{'divide': 'ignore', 'invalid': 'warn', 'over': 'ignore', 'under': 'ignore'}

Some examples with data arrays:

>>> d = cf.Data([0., 1])
>>> e = cf.Data([1., 2])

>>> old = cf.Data.seterr('ignore')
>>> e/d
<CF Data: [inf, 2.0] >
>>> e**12345
<CF Data: [1.0, inf] >

>>> cf.Data.seterr(divide='warn')
{'divide': 'ignore', 'invalid': 'ignore', 'over': 'ignore', 'under': 'ignore'}
>>> e/d
RuntimeWarning: divide by zero encountered in divide
<CF Data: [inf, 2.0] >
>>> e**12345
<CF Data: [1.0, inf] >

>>> old = cf.Data.mask_fpe(False)
>>> cf.Data.seterr(over='raise')
{'divide': 'warn', 'invalid': 'ignore', 'over': 'ignore', 'under': 'ignore'}
>>> e/d
RuntimeWarning: divide by zero encountered in divide
<CF Data: [inf, 2.0] >
>>> e**12345
FloatingPointError: overflow encountered in power

>>> cf.Data.mask_fpe(True)
False
>>> cf.Data.seterr(divide='ignore')
{'divide': 'warn', 'invalid': 'ignore', 'over': 'raise', 'under': 'ignore'}
>>> e/d
<CF Data: [inf, 2.0] >
>>> e**12345
<CF Data: [1.0, --] >