Inconsistency when multiplying NumPy masked arrays

[dopplershift]

There's a weird inconsistency when working with numpy masked arrays:

>>> import numpy as np
>>> import pint
>>> ureg = pint.UnitRegistry()
>>> a = np.arange(5)
>>> type(a * ureg.meter)
pint.quantity.build_quantity_class.<locals>.Quantity

>>>type(a * ureg('meter'))
pint.quantity.build_quantity_class.<locals>.Quantity

>>> ma = np.ma.arange(5)
>>> type(ma * ureg.meter)
pint.quantity.build_quantity_class.<locals>.Quantity

>>> type(ma * ureg('meter'))
numpy.ma.core.MaskedArray

That last one is creating quite a bit of heartache for me.

So I see that unit.meter is a Unit instance, whereas unit('meter') is a Quantity. Also, Unit.__rmul__ delegates to Unit.__mul__:

pint/pint/unit.py

Lines 141 to 147 in 19d0547

	def __mul__(self, other):
	if self._check(other):
	if isinstance(other, self.__class__):
	return self.__class__(self._units*other._units)
	else:
	qself = self._REGISTRY.Quantity(1.0, self._units)
	return qself * other

So this changes a Unit into a Quantity, and delegates to Quantity.__mul__ by multiply the Quantity on the left--that explains why it works.

Based on some tracing with numpy 1.15, it looks like we end up in numpy.ma.core:

    def __mul__(self, other):
        "Multiply self by other, and return a new masked array."
        if self._delegate_binop(other):
            return NotImplemented
        return multiply(self, other)

and inside self._delegate_binop():

    def _delegate_binop(self, other):
        # This emulates the logic in
        #     private/binop_override.h:forward_binop_should_defer
        if isinstance(other, type(self)):
            return False
        array_ufunc = getattr(other, "__array_ufunc__", False)
        if array_ufunc is False:
            other_priority = getattr(other, "__array_priority__", -1000000)
            return self.__array_priority__ < other_priority
        else:
            # If array_ufunc is not None, it will be called inside the ufunc;
            # None explicitly tells us to not call the ufunc, i.e., defer.
            return array_ufunc is None

Unfortunately, this ends up returning False, which results in using the multiply function from numpy.ma.core. This is because Quantity delegates the __array_ufunc__ attribute to numpy.ndarray.

I wonder if it would be enough to set __array_ufunc__ to None in Quantity...

[hgrecco]

Maybe the right way will be to implement __array_ufunc__ properly. This can be useful for many other things.

[dopplershift]

I think so too, but I haven't had a chance to dig into those docs and see what that should look like...yet. I can confirm that just setting it to None results in the desired behavior, at least in this case.

[jthielen]

After spending probably too much time on debugging this for #845, I'm pretty sure the issue is upstream in NumPy, so I've created an issue there: numpy/numpy#15200.

With that in mind, my PR for downcast types (incoming soon) will mark the relevant tests as xfail.