MAINT: umath: generate the ldexp and frexp ufuncs like all the others.

numpy · ewmoore · Feb 22, 2013 · Mar 1, 2013 · Mar 6, 2013 · Mar 8, 2013
commit e6b99c946c411b3ae4e8b1dbdab2149ed341fa19
diff --git a/numpy/core/code_generators/generate_umath.py b/numpy/core/code_generators/generate_umath.py
@@ -20,14 +20,20 @@
 class FullTypeDescr(object):
     pass
 
+class FuncNameSuffix(object):
+    """Stores the suffix to append when generating function names.
+    """
+    def __init__(self, suffix):
+        self.suffix = suffix
+
 class TypeDescription(object):
     """Type signature for a ufunc.
 
     Attributes
     ----------
     type : str
         Character representing the nominal type.
-    func_data : str or None or FullTypeDescr, optional
+    func_data : str or None or FullTypeDescr or FuncNameSuffix, optional
         The string representing the expression to insert into the data array, if
         any.
     in_ : str or None, optional
@@ -795,6 +801,30 @@ def english_upper(s):
           None,
           TD(flts),
           ),
+'ldexp' :
+    Ufunc(2, 1, None,
+          docstrings.get('numpy.core.umath.ldexp'),
+          None,
+          [TypeDescription('e', None, 'ei', 'e'),
+          TypeDescription('f', None, 'fi', 'f'),
+          TypeDescription('e', FuncNameSuffix('long'), 'el', 'e'),
+          TypeDescription('f', FuncNameSuffix('long'), 'fl', 'f'),
+          TypeDescription('d', None, 'di', 'd'),
+          TypeDescription('d', FuncNameSuffix('long'), 'dl', 'd'),
+          TypeDescription('g', None, 'gi', 'g'),
+          TypeDescription('g', FuncNameSuffix('long'), 'gl', 'g'),
+          ],
+          ),
+'frexp' :
+    Ufunc(1, 2, None,
+          docstrings.get('numpy.core.umath.frexp'),
+          None,
+          [TypeDescription('e', None, 'e', 'ei'),
+          TypeDescription('f', None, 'f', 'fi'),
+          TypeDescription('d', None, 'd', 'di'),
+          TypeDescription('g', None, 'g', 'gi'),
+          ],
+          )
 }
 
 if sys.version_info[0] >= 3:
@@ -854,7 +884,7 @@ def make_arrays(funcdict):
             thedict = chartotype1  # one input and one output
 
         for t in uf.type_descriptions:
-            if t.func_data not in (None, FullTypeDescr):
+            if t.func_data not in (None, FullTypeDescr) and not isinstance(t.func_data, FuncNameSuffix):
                 funclist.append('NULL')
                 astype = ''
                 if not t.astype is None:
@@ -880,6 +910,10 @@ def make_arrays(funcdict):
                 tname = english_upper(chartoname[t.type])
                 datalist.append('(void *)NULL')
                 funclist.append('%s_%s_%s_%s' % (tname, t.in_, t.out, name))
+            elif isinstance(t.func_data,  FuncNameSuffix):
+                datalist.append('(void *)NULL')
+                tname = english_upper(chartoname[t.type])
+                funclist.append('%s_%s_%s' % (tname, name, t.func_data.suffix))
             else:
                 datalist.append('(void *)NULL')
                 tname = english_upper(chartoname[t.type])

diff --git a/numpy/core/code_generators/ufunc_docstrings.py b/numpy/core/code_generators/ufunc_docstrings.py
@@ -3312,3 +3312,65 @@ def add_newdoc(place, name, doc):
     array([0, 0, 0, 0, 1])
 
     """)
+
+add_newdoc('numpy.core.umath', 'ldexp',
+    """
+    Scale floating point value by a power of 2, element-wise.
+
+    Equivalent to ``x1 * 2**x2``.
+
+    Parameters
+    ----------
+    x1 : array_like
+        Input array to be scaled.
+    x2 : array_like
+        Input array of exponents.
+
+    Returns
+    -------
+    y: ndarray
+        The corresponding scaled values.
+
+    See Also
+    --------
+    frexp : Extract significand and exponent from floating point number
+
+    Examples
+    --------
+    >>> np.ldexp(0.5, np.arange(-1,4))
+    array([ 0.25,  0.5 ,  1.  ,  2.  ,  4.  ])
+
+    """)
+
+add_newdoc('numpy.core.umath', 'frexp',
+    """
+    Extract significand and exponent from a floating point number.
+
+    All floating point numbers are of the form: ``y1 * 2**y2`` where `y1`,
+    the significand, is a number between 0.5 and 1, or 0 and `y2`, the
+    exponent, is an integer.
+
+    Parameters
+    ----------
+    x: array_like
+        Input array.
+
+    Returns
+    -------
+    y1 : ndarray
+        The normalized significands from `x`.
+    y2 : ndarray
+        The exponents from `x`.
+
+    See Also
+    --------
+    ldexp : Scale floating point number by power of 2
+
+    Examples
+    --------
+    >>> np.frexp([0.25, 0.5, 1, 2, 4])
+    (array([ 0.5,  0.5,  0.5,  0.5,  0.5]),
+     array([-1,  0,  1,  2,  3], dtype=int32))
+
+    """)
+
diff --git a/numpy/core/src/umath/umathmodule.c b/numpy/core/src/umath/umathmodule.c
@@ -201,99 +201,6 @@ ufunc_frompyfunc(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *NPY_UNUS
  **                            SETUP UFUNCS                                 **
  *****************************************************************************
  */
-
-/* Less automated additions to the ufuncs */
-
-static PyUFuncGenericFunction frexp_functions[] = {
-#ifdef HAVE_FREXPF
-    HALF_frexp,
-    FLOAT_frexp,
-#endif
-    DOUBLE_frexp
-#ifdef HAVE_FREXPL
-    ,LONGDOUBLE_frexp
-#endif
-};
-
-static void * blank3_data[] = { (void *)NULL, (void *)NULL, (void *)NULL};
-static void * blank6_data[] = { (void *)NULL, (void *)NULL, (void *)NULL,
-                                (void *)NULL, (void *)NULL, (void *)NULL};
-static char frexp_signatures[] = {
-#ifdef HAVE_FREXPF
-    NPY_HALF, NPY_HALF, NPY_INT,
-    NPY_FLOAT, NPY_FLOAT, NPY_INT,
-#endif
-    NPY_DOUBLE, NPY_DOUBLE, NPY_INT
-#ifdef HAVE_FREXPL
-    ,NPY_LONGDOUBLE, NPY_LONGDOUBLE, NPY_INT
-#endif
-};
-
-#if NPY_SIZEOF_LONG == NPY_SIZEOF_INT
-#define LDEXP_LONG(typ) typ##_ldexp
-#else
-#define LDEXP_LONG(typ) typ##_ldexp_long
-#endif
-
-static PyUFuncGenericFunction ldexp_functions[] = {
-#ifdef HAVE_LDEXPF
-    HALF_ldexp,
-    FLOAT_ldexp,
-    LDEXP_LONG(HALF),
-    LDEXP_LONG(FLOAT),
-#endif
-    DOUBLE_ldexp,
-    LDEXP_LONG(DOUBLE)
-#ifdef HAVE_LDEXPL
-    ,
-    LONGDOUBLE_ldexp,
-    LDEXP_LONG(LONGDOUBLE)
-#endif
-};
-
-static char ldexp_signatures[] = {
-#ifdef HAVE_LDEXPF
-    NPY_HALF, NPY_INT, NPY_HALF,
-    NPY_FLOAT, NPY_INT, NPY_FLOAT,
-    NPY_HALF, NPY_LONG, NPY_HALF,
-    NPY_FLOAT, NPY_LONG, NPY_FLOAT,
-#endif
-    NPY_DOUBLE, NPY_INT, NPY_DOUBLE,
-    NPY_DOUBLE, NPY_LONG, NPY_DOUBLE
-#ifdef HAVE_LDEXPL
-    ,NPY_LONGDOUBLE, NPY_INT, NPY_LONGDOUBLE
-    ,NPY_LONGDOUBLE, NPY_LONG, NPY_LONGDOUBLE
-#endif
-};
-
-static void
-InitOtherOperators(PyObject *dictionary) {
-    PyObject *f;
-    int num;
-
-    num = sizeof(frexp_functions) / sizeof(frexp_functions[0]);
-    f = PyUFunc_FromFuncAndData(frexp_functions, blank3_data,
-                                frexp_signatures, num,
-                                1, 2, PyUFunc_None, "frexp",
-                                "Split the number, x, into a normalized"\
-                                " fraction (y1) and exponent (y2)",0);
-    PyDict_SetItemString(dictionary, "frexp", f);
-    Py_DECREF(f);
-
-    num = sizeof(ldexp_functions) / sizeof(ldexp_functions[0]);
-    f = PyUFunc_FromFuncAndData(ldexp_functions, blank6_data, ldexp_signatures, num,
-                                2, 1, PyUFunc_None, "ldexp",
-                                "Compute y = x1 * 2**x2.",0);
-    PyDict_SetItemString(dictionary, "ldexp", f);
-    Py_DECREF(f);
-
-#if defined(NPY_PY3K)
-    f = PyDict_GetItemString(dictionary, "true_divide");
-    PyDict_SetItemString(dictionary, "divide", f);
-#endif
-    return;
-}
-
 NPY_VISIBILITY_HIDDEN PyObject * npy_um_str_out = NULL;
 NPY_VISIBILITY_HIDDEN PyObject * npy_um_str_subok = NULL;
 NPY_VISIBILITY_HIDDEN PyObject * npy_um_str_array_prepare = NULL;
@@ -409,15 +316,18 @@ PyMODINIT_FUNC initumath(void)
     /* Load the ufunc operators into the array module's namespace */
     InitOperators(d);
 
-    InitOtherOperators(d);
-
     PyDict_SetItemString(d, "pi", s = PyFloat_FromDouble(NPY_PI));
     Py_DECREF(s);
     PyDict_SetItemString(d, "e", s = PyFloat_FromDouble(NPY_E));
     Py_DECREF(s);
     PyDict_SetItemString(d, "euler_gamma", s = PyFloat_FromDouble(NPY_EULER));
     Py_DECREF(s);
 
+#if defined(NPY_PY3K)
+    s = PyDict_GetItemString(d, "true_divide");
+    PyDict_SetItemString(d, "divide", s);
+#endif
+
 #define ADDCONST(str) PyModule_AddIntConstant(m, #str, UFUNC_##str)
 #define ADDSCONST(str) PyModule_AddStringConstant(m, "UFUNC_" #str, UFUNC_##str)