fix #234 : implemented support for np.__array_ufunc__

- renamed npufuncs.py as npfuncs.py

Author: alixdamman

doc/source/changes/version_0_30.rst.inc

@@ -223,6 +223,8 @@ Miscellaneous improvements
 
 * implemented :py:obj:`LArray.reverse()` method to reverse one or several axes of an array (closes :issue:`631`).
 
+* made it possible to pass LArray objects to Numpy ufuncs directly (e.g. np.sqrt(ndtest(3)), closes :issue:`234`).
+
 
 Fixes
 -----

larray/__init__.py

@@ -12,15 +12,14 @@
 from larray.core.session import Session, local_arrays, global_arrays, arrays
 from larray.core.constants import nan, inf, pi, e, euler_gamma
 from larray.core.metadata import Metadata
-from larray.core.ufuncs import maximum, minimum, where
-from larray.core.npufuncs import (sin, cos, tan, arcsin, arccos, arctan, hypot, arctan2, degrees,
-                                  radians, unwrap, sinh, cosh, tanh, arcsinh, arccosh, arctanh,
-                                  angle, real, imag, conj,
-                                  round, around, round_, rint, fix, floor, ceil, trunc,
-                                  exp, expm1, exp2, log, log10, log2, log1p, logaddexp, logaddexp2,
-                                  i0, sinc, signbit, copysign, frexp, ldexp,
-                                  convolve, clip, sqrt, absolute, fabs, sign, fmax, fmin, nan_to_num,
-                                  real_if_close, interp, isnan, isinf, inverse)
+from larray.core.npfuncs import (where, clip, degrees, radians, unwrap, angle, real, imag,
+                                 round, around, round_, fix, i0, sinc, convolve, nan_to_num,
+                                 real_if_close, inverse, interp, )
+from larray.core.ufuncs import (sin, cos, tan, arcsin, arccos, arctan, hypot, arctan2, sinh, cosh,
+                                tanh, arcsinh, arccosh, arctanh, conj, rint, floor, ceil, trunc,
+                                exp, expm1, exp2, log, log10, log2, log1p, logaddexp, logaddexp2,
+                                signbit, copysign, frexp, ldexp, sqrt, absolute, fabs, sign,
+                                fmax, fmin, isnan, isinf, maximum, minimum)
 
 from larray.inout.misc import from_lists, from_string
 from larray.inout.pandas import from_frame, from_series
@@ -56,15 +55,17 @@
     # metadata
     'Metadata',
     # ufuncs
-    'maximum', 'minimum', 'where',
+    'maximum', 'minimum',
     'sin', 'cos', 'tan', 'arcsin', 'arccos', 'arctan', 'hypot', 'arctan2', 'degrees', 'radians',
     'unwrap', 'sinh', 'cosh', 'tanh', 'arcsinh', 'arccosh', 'arctanh',
     'angle', 'real', 'imag', 'conj',
     'round', 'around', 'round_', 'rint', 'fix', 'floor', 'ceil', 'trunc',
     'exp', 'expm1', 'exp2', 'log', 'log10', 'log2', 'log1p', 'logaddexp', 'logaddexp2',
     'i0', 'sinc', 'signbit', 'copysign', 'frexp', 'ldexp',
-    'convolve', 'clip', 'sqrt', 'absolute', 'fabs', 'sign', 'fmax', 'fmin', 'nan_to_num',
+    'convolve', 'sqrt', 'absolute', 'fabs', 'sign', 'fmax', 'fmin', 'nan_to_num',
     'real_if_close', 'interp', 'isnan', 'isinf', 'inverse',
+    # npfuncs
+    'where', 'clip',
     # inout
     'from_lists', 'from_string', 'from_frame', 'from_series', 'read_csv', 'read_tsv',
     'read_eurostat', 'read_excel', 'read_hdf', 'read_sas', 'open_excel', 'Workbook',

larray/core/array.py

@@ -59,6 +59,7 @@
 from larray.core.constants import nan
 from larray.core.metadata import Metadata
 from larray.core.expr import ExprNode
+from larray.core.ufuncs import SupportsNumpyUfuncs
 from larray.core.group import (Group, IGroup, LGroup, remove_nested_groups, _to_key, _to_keys,
                                _translate_sheet_name, _translate_group_key_hdf)
 from larray.core.axis import Axis, AxisReference, AxisCollection, X, _make_axis
@@ -560,7 +561,7 @@ def _handle_deprecated_argument_title(meta, title):
     return meta
 
 
-class LArray(ABCLArray):
+class LArray(ABCLArray, SupportsNumpyUfuncs):
     """
     A LArray object represents a multidimensional, homogeneous array of fixed-size items with labeled axes.
 
@@ -5326,7 +5327,7 @@ def eq(self, other, rtol=0, atol=0, nans_equal=False):
             if not nans_equal:
                 return self == other
             else:
-                from larray.core.npufuncs import isnan
+                from larray.core.ufuncs import isnan
 
                 def general_isnan(a):
                     if np.issubclass_(a.dtype.type, np.inexact):
@@ -6076,7 +6077,7 @@ def clip(self, minval=None, maxval=None, out=None):
          a1   0   1   2
          a2   2   2   2
         """
-        from larray.core.npufuncs import clip
+        from larray.core.npfuncs import clip
         return clip(self, minval, maxval, out)
 
     @deprecate_kwarg('transpose', 'wide')

larray/core/npfuncs.py

@@ -0,0 +1,130 @@
+# numpy ufuncs -- this module is excluded from pytest
+# http://docs.scipy.org/doc/numpy/reference/routines.math.html
+
+import numpy as np
+
+from larray.core.ufuncs import _broadcastify, _copy_npfunc_doc
+
+
+def broadcastify(npfunc, copy_doc=True):
+    # intentionally not using functools.wraps, because it does not work for wrapping a function from another module
+    def wrapper(*args, **kwargs):
+       return _broadcastify(npfunc, *args, **kwargs)
+    if copy_doc:
+        _copy_npfunc_doc(wrapper, npfunc)
+    return wrapper
+
+# Trigonometric functions
+
+degrees = broadcastify(np.degrees)
+radians = broadcastify(np.radians)
+unwrap = broadcastify(np.unwrap)
+
+# Handling complex numbers
+
+angle = broadcastify(np.angle)
+real = broadcastify(np.real)
+imag = broadcastify(np.imag)
+
+# Rounding
+
+# all 3 are equivalent, I am unsure I should support around and round_
+round = broadcastify(np.round)
+around = broadcastify(np.around)
+round_ = broadcastify(np.round_)
+fix = broadcastify(np.fix)
+
+# Sums, products, differences
+
+# prod = broadcastify(np.prod)
+# sum = broadcastify(np.sum)
+# nansum = broadcastify(np.nansum)
+# cumprod = broadcastify(np.cumprod)
+# cumsum = broadcastify(np.cumsum)
+
+# cannot use a simple wrapped ufunc because those ufuncs do not preserve
+# shape or dimensions so labels are wrong
+# diff = broadcastify(np.diff)
+# ediff1d = broadcastify(np.ediff1d)
+# gradient = broadcastify(np.gradient)
+# cross = broadcastify(np.cross)
+# trapz = broadcastify(np.trapz)
+
+
+# Other special functions
+
+i0 = broadcastify(np.i0)
+sinc = broadcastify(np.sinc)
+
+# Miscellaneous
+
+where = broadcastify(np.where, copy_doc=False)
+where.__doc__ = r"""
+    Return elements, either from `x` or `y`, depending on `condition`.
+
+    If only `condition` is given, return ``condition.nonzero()``.
+
+    Parameters
+    ----------
+    condition : boolean LArray
+        When True, yield `x`, otherwise yield `y`.
+    x, y : LArray
+        Values from which to choose.
+
+    Returns
+    -------
+    out : LArray
+        If both `x` and `y` are specified, the output array contains
+        elements of `x` where `condition` is True, and elements from
+        `y` elsewhere.
+
+    Examples
+    --------
+    >>> from larray import LArray
+    >>> arr = LArray([[10, 7, 5, 9],
+    ...               [5, 8, 3, 7],
+    ...               [6, 2, 0, 9],
+    ...               [9, 10, 5, 6]], "a=a0..a3;b=b0..b3")
+    >>> arr
+    a\b  b0  b1  b2  b3
+     a0  10   7   5   9
+     a1   5   8   3   7
+     a2   6   2   0   9
+     a3   9  10   5   6
+
+    Simple use
+
+    >>> where_(arr <= 5, 0, arr)
+    a\b  b0  b1  b2  b3
+     a0  10   7   0   9
+     a1   0   8   0   7
+     a2   6   0   0   9
+     a3   9  10   0   6
+
+    With broadcasting
+
+    >>> mean_by_col = arr.mean('a')
+    >>> mean_by_col
+    b   b0    b1    b2    b3
+       7.5  6.75  3.25  7.75
+    >>> # for each column, set values below the mean value to the mean value
+    >>> where_(arr < mean_by_col, mean_by_col, arr)
+    a\b    b0    b1    b2    b3
+     a0  10.0   7.0   5.0   9.0
+     a1   7.5   8.0  3.25  7.75
+     a2   7.5  6.75  3.25   9.0
+     a3   9.0  10.0   5.0  7.75
+"""
+
+clip = broadcastify(np.clip)
+convolve = broadcastify(np.convolve)
+nan_to_num = broadcastify(np.nan_to_num)
+real_if_close = broadcastify(np.real_if_close)
+inverse = broadcastify(np.linalg.inv)
+
+# XXX: create a new LArray method instead ?
+# TODO: should appear in the API doc if it actually works with LArrays,
+#       which I have never tested (and I doubt is the case).
+#       Might be worth having specific documentation if it works well.
+#       My guess is that we should rather make a new LArray method for that one.
+interp = broadcastify(np.interp)