numpy · ewmoore · Feb 22, 2013 · Mar 1, 2013 · Mar 6, 2013 · Mar 8, 2013
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/include/numpy/npy_math.h b/numpy/core/include/numpy/npy_math.h
@@ -118,10 +118,6 @@ double npy_tanh(double x);
 double npy_asin(double x);
 double npy_acos(double x);
 double npy_atan(double x);
-double npy_aexp(double x);
-double npy_alog(double x);
-double npy_asqrt(double x);
-double npy_afabs(double x);
 
 double npy_log(double x);
 double npy_log10(double x);
@@ -152,6 +148,9 @@ double npy_copysign(double x, double y);
 double npy_nextafter(double x, double y);
 double npy_spacing(double x);
 
+double npy_ldexp(double x, int exp);
+double npy_frexp(double x, int* exp);
+
 /*
  * IEEE 754 fpu handling. Those are guaranteed to be macros
  */
@@ -256,8 +255,11 @@ float npy_copysignf(float x, float y);
 float npy_nextafterf(float x, float y);
 float npy_spacingf(float x);
 
+float npy_ldexpf(float x, int exp);
+float npy_frexpf(float x, int* exp);
+
 /*
- * float C99 math functions
+ * long double C99 math functions
  */
 
 npy_longdouble npy_sinl(npy_longdouble x);
@@ -297,6 +299,9 @@ npy_longdouble npy_copysignl(npy_longdouble x, npy_longdouble y);
 npy_longdouble npy_nextafterl(npy_longdouble x, npy_longdouble y);
 npy_longdouble npy_spacingl(npy_longdouble x);
 
+npy_longdouble npy_ldexpl(npy_longdouble x, int exp);
+npy_longdouble npy_frexpl(npy_longdouble x, int* exp);
+
 /*
  * Non standard functions
  */
@@ -420,6 +425,19 @@ npy_cdouble npy_csqrt(npy_cdouble z);
 
 npy_cdouble npy_ccos(npy_cdouble z);
 npy_cdouble npy_csin(npy_cdouble z);
+npy_cdouble npy_ctan(npy_cdouble z);
+
+npy_cdouble npy_ccosh(npy_cdouble z);
+npy_cdouble npy_csinh(npy_cdouble z);
+npy_cdouble npy_ctanh(npy_cdouble z);
+
+npy_cdouble npy_cacos(npy_cdouble z);
+npy_cdouble npy_casin(npy_cdouble z);
+npy_cdouble npy_catan(npy_cdouble z);
+
+npy_cdouble npy_cacosh(npy_cdouble z);
+npy_cdouble npy_casinh(npy_cdouble z);
+npy_cdouble npy_catanh(npy_cdouble z);
 
 /*
  * Single precision complex functions
@@ -435,6 +453,20 @@ npy_cfloat npy_csqrtf(npy_cfloat z);
 
 npy_cfloat npy_ccosf(npy_cfloat z);
 npy_cfloat npy_csinf(npy_cfloat z);
+npy_cfloat npy_ctanf(npy_cfloat z);
+
+npy_cfloat npy_ccoshf(npy_cfloat z);
+npy_cfloat npy_csinhf(npy_cfloat z);
+npy_cfloat npy_ctanhf(npy_cfloat z);
+
+npy_cfloat npy_cacosf(npy_cfloat z);
+npy_cfloat npy_casinf(npy_cfloat z);
+npy_cfloat npy_catanf(npy_cfloat z);
+
+npy_cfloat npy_cacoshf(npy_cfloat z);
+npy_cfloat npy_casinhf(npy_cfloat z);
+npy_cfloat npy_catanhf(npy_cfloat z);
+
 
 /*
  * Extended precision complex functions
@@ -450,6 +482,20 @@ npy_clongdouble npy_csqrtl(npy_clongdouble z);
 
 npy_clongdouble npy_ccosl(npy_clongdouble z);
 npy_clongdouble npy_csinl(npy_clongdouble z);
+npy_clongdouble npy_ctanl(npy_clongdouble z);
+
+npy_clongdouble npy_ccoshl(npy_clongdouble z);
+npy_clongdouble npy_csinhl(npy_clongdouble z);
+npy_clongdouble npy_ctanhl(npy_clongdouble z);
+
+npy_clongdouble npy_cacosl(npy_clongdouble z);
+npy_clongdouble npy_casinl(npy_clongdouble z);
+npy_clongdouble npy_catanl(npy_clongdouble z);
+
+npy_clongdouble npy_cacoshl(npy_clongdouble z);
+npy_clongdouble npy_casinhl(npy_clongdouble z);
+npy_clongdouble npy_catanhl(npy_clongdouble z);
+
 
 /*
  * Functions that set the floating point error

diff --git a/numpy/core/setup.py b/numpy/core/setup.py
@@ -220,6 +220,32 @@ def check_prec(prec):
             else:
                 priv.extend([(fname2def(f), 1) for f in flist])
 
+            flist = [f + prec for f in C99_COMPLEX_FUNCS_CHECKED]
+            decl = dict([(f, True) for f in flist])
+            exists = []
+            if not config.check_funcs_once(flist, call=decl, decl=decl,
+                                           libraries=mathlibs):
+                for f in C99_COMPLEX_FUNCS_CHECKED:
+                    if config.check_func(f + prec, call=True, decl=True,
+                                         libraries=mathlibs):
+                        exists.append(f)
+            else:
+                exists.extend(C99_COMPLEX_FUNCS_CHECKED)
+
+            if len(exists) > 0:
+                fp = open(join('.', 'numpy', 'core', 'src', 'npymath',
+                              'test_c99complex.c'), 'r')
+                obody = fp.read()
+                fp.close()
+                precname = {'f':'FLOAT', '':'DOUBLE', 'l':'LONGDOUBLE'}[prec]
+            for f in exists:
+                body = obody.replace('PYTESTPRECISION', precname) \
+                            .replace('PYTESTFUNC', f.upper())
+                inc_dir = join('.', 'numpy', 'core', 'src', 'npymath')
+                if config.try_run(body, libraries=mathlibs,
+                                  include_dirs=[inc_dir]):
+                    priv.append((fname2def(f + prec), 1))
+
         check_prec('')
         check_prec('f')
         check_prec('l')
@@ -690,7 +716,8 @@ def get_mathlib_info(*args):
     npymath_sources = [join('src', 'npymath', 'npy_math.c.src'),
                        join('src', 'npymath', 'ieee754.c.src'),
                        join('src', 'npymath', 'npy_math_complex.c.src'),
-                       join('src', 'npymath', 'halffloat.c')]
+                       join('src', 'npymath', 'halffloat.c'),
+                       join('src', 'npymath', 'fpstatus.c')]
     config.add_installed_library('npymath',
             sources=npymath_sources + [get_mathlib_info],
             install_dir='lib')
@@ -996,6 +1023,16 @@ def get_dotblas_sources(ext, build_dir):
     config.add_extension('operand_flag_tests',
                     sources = [join('src', 'umath', 'operand_flag_tests.c.src')])
 
+    #######################################################################
+    #                        npymath_tests module                         #
+    #######################################################################
+
+    config.add_extension('npymath_tests',
+                    sources = [join('src', 'npymath', 'npymath_tests.c')],
+                    depends = ['test_c99complex.c'],
+                    libraries = ['npymath']
+                    )
+
     config.add_data_dir('tests')
     config.add_data_dir('tests/data')
 

diff --git a/numpy/core/setup_common.py b/numpy/core/setup_common.py
@@ -143,8 +143,10 @@ def check_api_version(apiversion, codegen_dir):
 
 C99_COMPLEX_TYPES = ['complex double', 'complex float', 'complex long double']
 
-C99_COMPLEX_FUNCS = ['creal', 'cimag', 'cabs', 'carg', 'cexp', 'csqrt', 'clog',
-                  'ccos', 'csin', 'cpow']
+C99_COMPLEX_FUNCS = ['creal', 'cimag', 'cabs', 'carg']
+C99_COMPLEX_FUNCS_CHECKED = ['cacos', 'casin', 'catan', 'cacosh', 'casinh',
+                             'catanh', 'ccos', 'csin', 'ctan', 'ccosh', 'csinh',
+                             'ctanh', 'cexp', 'clog', 'cpow', 'csqrt']
 
 def fname2def(name):
     return "HAVE_%s" % name.upper()