Issue #2487. math.ldexp(x, n) raised OverflowError when n was large and

negative; fix to return an (appropriately signed) zero instead.

diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index c9eade3a9035072d437d8cdd71c01546f619c16a..a5c6f626deef0a3178aafc5e536ffc3e98757b3c 100644 (file)
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -374,6 +374,24 @@ class MathTests(unittest.TestCase):
         self.assertEquals(math.ldexp(NINF, -213), NINF)
         self.assert_(math.isnan(math.ldexp(NAN, 0)))
 
+        # large second argument
+        for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]:
+            self.assertEquals(math.ldexp(INF, -n), INF)
+            self.assertEquals(math.ldexp(NINF, -n), NINF)
+            self.assertEquals(math.ldexp(1., -n), 0.)
+            self.assertEquals(math.ldexp(-1., -n), -0.)
+            self.assertEquals(math.ldexp(0., -n), 0.)
+            self.assertEquals(math.ldexp(-0., -n), -0.)
+            self.assert_(math.isnan(math.ldexp(NAN, -n)))
+
+            self.assertRaises(OverflowError, math.ldexp, 1., n)
+            self.assertRaises(OverflowError, math.ldexp, -1., n)
+            self.assertEquals(math.ldexp(0., n), 0.)
+            self.assertEquals(math.ldexp(-0., n), -0.)
+            self.assertEquals(math.ldexp(INF, n), INF)
+            self.assertEquals(math.ldexp(NINF, n), NINF)
+            self.assert_(math.isnan(math.ldexp(NAN, n)))
+
     def testLog(self):
         self.assertRaises(TypeError, math.log)
         self.ftest('log(1/e)', math.log(1/math.e), -1)

diff --git a/Misc/NEWS b/Misc/NEWS
index 12522dbfe680358ccfde00fd917418e4b0b88316..2b7b52fa62e36cc66435949d7d6c8768e01abef5 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -23,6 +23,11 @@ Extension Modules
 Library
 -------
 
+- Issue #2487: change the semantics of math.ldexp(x, n) when n is too
+  large to fit in a C long.  ldexp(x, n) now returns a zero (with
+  suitable sign) if n is large and negative; previously, it raised
+  OverflowError.
+
 - The toaiff module has been deprecated for removal in Python 3.0.
 
 - The test.testall module has been deprecated for removal in Python 3.0.

diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index 201ffc449c22ca57dca95af9264ddf34f3b2acc9..c4ac69adad16cdef3236a6b62133dff44ef2929b 100644 (file)
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -349,23 +349,65 @@ static PyObject *
 math_ldexp(PyObject *self, PyObject *args)
 {
        double x, r;
-       int exp;
-       if (! PyArg_ParseTuple(args, "di:ldexp", &x, &exp))
+       PyObject *oexp;
+       long exp;
+       if (! PyArg_ParseTuple(args, "dO:ldexp", &x, &oexp))
                return NULL;
-       errno = 0;
-       PyFPE_START_PROTECT("in math_ldexp", return 0)
-       r = ldexp(x, exp);
-       PyFPE_END_PROTECT(r)
-       if (Py_IS_FINITE(x) && Py_IS_INFINITY(r))
+
+       if (PyLong_Check(oexp)) {
+               /* on overflow, replace exponent with either LONG_MAX
+                  or LONG_MIN, depending on the sign. */
+               exp = PyLong_AsLong(oexp);
+               if (exp == -1 && PyErr_Occurred()) {
+                       if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+                               if (Py_SIZE(oexp) < 0) {
+                                       exp = LONG_MIN;
+                               }
+                               else {
+                                       exp = LONG_MAX;
+                               }
+                               PyErr_Clear();
+                       }
+                       else {
+                               /* propagate any unexpected exception */
+                               return NULL;
+                       }
+               }
+       }
+       else if (PyInt_Check(oexp)) {
+               exp = PyInt_AS_LONG(oexp);
+       }
+       else {
+               PyErr_SetString(PyExc_TypeError,
+                               "Expected an int or long as second argument "
+                               "to ldexp.");
+               return NULL;
+       }
+
+       if (x == 0. || !Py_IS_FINITE(x)) {
+               /* NaNs, zeros and infinities are returned unchanged */
+               r = x;
+               errno = 0;
+       } else if (exp > INT_MAX) {
+               /* overflow */
+               r = copysign(Py_HUGE_VAL, x);
                errno = ERANGE;
-       /* Windows MSVC8 sets errno = EDOM on ldexp(NaN, i);
-          we unset it to avoid raising a ValueError here. */
-       if (errno == EDOM)
+       } else if (exp < INT_MIN) {
+               /* underflow to +-0 */
+               r = copysign(0., x);
                errno = 0;
+       } else {
+               errno = 0;
+               PyFPE_START_PROTECT("in math_ldexp", return 0);
+               r = ldexp(x, (int)exp);
+               PyFPE_END_PROTECT(r);
+               if (Py_IS_INFINITY(r))
+                       errno = ERANGE;
+       }
+
        if (errno && is_error(r))
                return NULL;
-       else
-               return PyFloat_FromDouble(r);
+       return PyFloat_FromDouble(r);
 }
 
 PyDoc_STRVAR(math_ldexp_doc,