Changes between Version 7 and Version 8 of MaskedArray

Timestamp:

01/13/06 21:26:14 (7 years ago)

Author:

sasha

Comment:

Added Ufuncs and Masked Arrays section

MaskedArray

@@ -10 +10 @@
 
 describe migration from Numeric.MA to numpy.ma here
+----
+= Ufuncs and Masked Arrays =
+
+In changeset:1835, Travis added {{{__array_wrap__}}} hook to the {{{MaskedArray}}} class. This was done in an attempt
+to fix mixed arithmetics. Unfortunately, there is not enought information within the   {{{__array_wrap__}}} hook to correctly 
+generate the mask:
+{{{
+>>> from numpy import *
+>>> print ma.array([1])/ma.array([0])
+[--]
+>>> print array([1])/ma.array([0])
+[0]
+}}}
+In order to fix this situation, more information has to be passed to the  {{{__array_wrap__}}} hook by the ufunc. Sasha proposes
+to change the  {{{__array_wrap__}}} signature form 
+{{{
+def __array_wrap__(self, arr)
+}}}
+to
+{{{
+def __array_wrap__(self, arr, context)
+}}}
+and make ufuncs pass a tuple context=(func, args, i), where func is the ufunc itself, args is the tuple of ufunc arguments and
+i is the index of self in the args tuple.  Strictly speaking, i is not necessary, but it is available in ufunc and may prove to be helpful
+in the future.
+
+Once ufuncs can handle the case of mixed arguments to binary operations, it is tempting to get rid of ma wrapers to ufuncs alltogether
+and implement ma logic entirely in  {{{__array_wrap__}}} and  {{{__array__}}} hooks.  Unfortunately,  {{{__array__}}} hook suffers from the
+same problem: before passing data to ufunc ma array heeds to replace masked values with something safe for the given operation. In
+order to do this more information in needed than passed to {{{__array__}}} hook.  Sasha proposes to make a similar change to  {{{__array__}}}
+hook as for  {{{__array_wrap__}}} hook above.
+
+The new signature will be
+{{{
+def __array__(self, dtype=None, context=None)
+}}}
+The ufuncs will pass to {{{__array__}}} a tuple context=(func, args, i), where func is the ufunc itself, args is the tuple of ufunc arguments and
+i is the index of self in the args tuple.  For backward compatibility ufuncs will allow a two-argument {{{__array__}}} and classes that will take
+advantage of context will define {{{__array__}}} with a default value for context so that it can be called with one or two arguments as well. 
+
 
 ----