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 c9eade3..a5c6f62 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -374,6 +374,24 @@
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 12522db..2b7b52f 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -23,6 +23,11 @@
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 201ffc4..c4ac69a 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -349,23 +349,65 @@
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))
- errno = ERANGE;
- /* Windows MSVC8 sets errno = EDOM on ldexp(NaN, i);
- we unset it to avoid raising a ValueError here. */
- if (errno == EDOM)
+
+ 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;
+ } 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,