[Numpy-discussion] Inconsistent behavior for ufuncs in numpy v1.10.X

[Charles R Harris]

On Tue, Jan 26, 2016 at 10:11 AM, Charles R Harris <
charlesr.harris at gmail.com> wrote:

>
>
> On Mon, Jan 25, 2016 at 10:43 PM, Solbrig,Jeremy <
> Jeremy.Solbrig at colostate.edu> wrote:
>
>> Hello,
>>
>> Much of what is below was copied from this stack overflow question.
>>
>> <http://stackoverflow.com/questions/35005569/behavior-of-ufuncs-and-mathematical-operators-differ-for-subclassed-maskedarray>
>>
>> I am attempting to subclass numpy.ma.MaskedArray.  I am currently using
>> Python v2.7.10.  The problem discussed below does not occur in Numpy
>> v1.9.2, but does occur in all versions of Numpy v1.10.x.
>>
>> In all versions of Numpy v1.10.x, using mathematical operators on my
>> subclass behaves differently than using the analogous ufunc. When using the
>> ufunc directly (e.g. np.subtract(arr1, arr2)), __array_prepare__,
>> __array_finalize__, and __array_wrap__ are all called as expected, however,
>> when using the symbolic operator (e.g. arr1-arr2) only
>> __array_finalize__ is called. As a consequence, I lose any information
>> stored in arr._optinfo when a mathematical operator is used.
>>
>> Here is a code snippet that illustrates the issue.
>>
>> #!/bin/env python
>> import numpy as npfrom numpy.ma import MaskedArray, nomask
>> class InfoArray(MaskedArray):
>>     def __new__(cls, info=None, data=None, mask=nomask, dtype=None,
>>                 copy=False, subok=True, ndmin=0, fill_value=None,
>>                 keep_mask=True, hard_mask=None, shrink=True, **kwargs):
>>         obj = super(InfoArray, cls).__new__(cls, data=data, mask=mask,
>>                       dtype=dtype, copy=copy, subok=subok, ndmin=ndmin,
>>                       fill_value=fill_value, hard_mask=hard_mask,
>>                       shrink=shrink, **kwargs)
>>         obj._optinfo['info'] = info
>>         return obj
>>
>>     def __array_prepare__(self, out, context=None):
>>         print '__array_prepare__'
>>         return super(InfoArray, self).__array_prepare__(out, context)
>>
>>     def __array_wrap__(self, out, context=None):
>>         print '__array_wrap__'
>>         return super(InfoArray, self).__array_wrap__(out, context)
>>
>>     def __array_finalize__(self, obj):
>>         print '__array_finalize__'
>>         return super(InfoArray, self).__array_finalize__(obj)
>> if __name__ == "__main__":
>>     arr1 = InfoArray('test', data=[1,2,3,4,5,6])
>>     arr2 = InfoArray(data=[0,1,2,3,4,5])
>>
>>     diff1 = np.subtract(arr1, arr2)
>>     print diff1._optinfo
>>
>>     diff2 = arr1-arr2
>>     print diff2._optinfo
>>
>> If run, the output looks like this:
>>
>> $ python test_ma_sub.py #Call to np.subtract(arr1, arr2) here
>> __array_finalize__
>> __array_finalize__
>> __array_prepare__
>> __array_finalize__
>> __array_wrap__
>> __array_finalize__{'info': 'test'}#Executing arr1-arr2 here
>> __array_finalize__{}
>>
>> Currently I have simply downgraded to 1.9.2 to solve the problem for
>> myself, but have been having difficulty figuring out where the difference
>> lies between 1.9.2 and 1.10.0.
>>
>
> I don't see a difference between 1.9.2 and 1.10.0 in this test, so I
> suspect it is something else. Could you try 1.10.4 to see if the something
> else has been fixed?
>

Which is to say, it isn't in the calls to prepare, wrap, and finalize. Now
to look in _optinfo.

Chuck
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/numpy-discussion/attachments/20160126/4cd492ee/attachment.html>