BUG: overflow encountered in multiply when multiplying masked arrays of float32

[mashatarasevich]

Describe the issue:

When doing _MaskedBinaryOperation on two masked arrays the actual operation is done on underlying data arrays ignoring mask. The relevant code is https://github.com/numpy/numpy/blob/main/numpy/ma/core.py#L1008-L1013

        # Get the data, as ndarray
        (da, db) = (getdata(a), getdata(b))
        # Get the result
        with np.errstate():
            np.seterr(divide='ignore', invalid='ignore')
            result = self.f(da, db, *args, **kwargs)

Division by zero and invalid operations are ignored for this operation, but not over- or underflow. Also this code silently swallows errors occurred for nonmasked elements.

Reproduce the code example:

import numpy as np

np.seterr(all='raise')

x = np.array([[1, 1e20], [1e20, 2]], dtype=np.float32)
y = np.array([[3, 1e20], [1e20, 4]], dtype=np.float32)

undef = np.float32(1e20)

z = np.ma.masked_equal(x, undef)
w = np.ma.masked_equal(y, undef)

z*w

Error message:

Traceback (most recent call last):
  File "test.py", line 13, in <module>
    z*w
  File "<snip>/miniconda3/lib/python3.7/site-packages/numpy/ma/core.py", line 4169, in __mul__
    return multiply(self, other)
  File "<snip>/miniconda3/lib/python3.7/site-packages/numpy/ma/core.py", line 1021, in __call__
    result = self.f(da, db, *args, **kwargs)
FloatingPointError: overflow encountered in multiply

NumPy/Python version information:

1.19.2 3.7.5 (default, Oct 25 2019, 15:51:11)
[GCC 7.3.0]

[Hayashi-Yudai]

It is because MaskedArray has its original value even if some of element is hidden. You can see it in the console, for example,

>>> import numpy as np
>>> a = np.ma.core.MaskedArray([1,2], mask=True)
>>> a
masked_array(data=[--, --],  # Value is masked
             mask=[ True,  True],
       fill_value=999999,
            dtype=int64)
>>> a.mask = False  # Change not to mask values
>>> a
masked_array(data=[1, 2],  # Original values are restored
             mask=[False, False],
       fill_value=999999)

Therefore, in your case, z*w has its original value [[3, 1e+40], [1e+40, 8]] (in _data attribute), but dtype is float32, so it causes overflow.

I understood the cause, but I am interested in whether such the behavior is intended one or not.

---

refs.

called in multiplication

numpy/numpy/ma/core.py

Lines 1011 to 1021 in bdec321

	def __call__(self, a, b, *args, **kwargs):
	"""
	Execute the call behavior.
	"""
	# Get the data, as ndarray
	(da, db) = (getdata(a), getdata(b))
	# Get the result
	with np.errstate():
	np.seterr(divide='ignore', invalid='ignore')
	result = self.f(da, db, *args, **kwargs)

getdata restore its original value

numpy/numpy/ma/core.py

Lines 666 to 714 in bdec321

	def getdata(a, subok=True):
	"""
	Return the data of a masked array as an ndarray.
	Return the data of `a` (if any) as an ndarray if `a` is a ``MaskedArray``,
	else return `a` as a ndarray or subclass (depending on `subok`) if not.
	Parameters
	----------
	a : array_like
	Input ``MaskedArray``, alternatively a ndarray or a subclass thereof.
	subok : bool
	Whether to force the output to be a `pure` ndarray (False) or to
	return a subclass of ndarray if appropriate (True, default).
	See Also
	--------
	getmask : Return the mask of a masked array, or nomask.
	getmaskarray : Return the mask of a masked array, or full array of False.
	Examples
	--------
	>>> import numpy.ma as ma
	>>> a = ma.masked_equal([[1,2],[3,4]], 2)
	>>> a
	masked_array(
	data=[[1, --],
	[3, 4]],
	mask=[[False, True],
	[False, False]],
	fill_value=2)
	>>> ma.getdata(a)
	array([[1, 2],
	[3, 4]])
	Equivalently use the ``MaskedArray`` `data` attribute.
	>>> a.data
	array([[1, 2],
	[3, 4]])
	"""
	try:
	data = a._data
	except AttributeError:
	data = np.array(a, copy=False, subok=subok)
	if not subok:
	return data.view(ndarray)
	return data