print 'tanh'
testit('tanh(0)', math.tanh(0), 0)
testit('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
+
+print 'exceptions' # oooooh, *this* is a x-platform gamble! good luck
+
+try:
+ x = math.exp(-1000000000)
+except:
+ # mathmodule.c is failing to weed out underflows from libm, or
+ # we've got an fp format with huge dynamic range
+ raise TestFailed("underflowing exp() should not have rasied an exception")
+if x != 0:
+ raise TestFailed("underflowing exp() should have returned 0")
+
+# If this fails, probably using a strict IEEE-754 conforming libm, and x
+# is +Inf afterwards. But Python wants overflows detected by default.
+try:
+ x = math.exp(1000000000)
+except OverflowError:
+ pass
+else:
+ raise TestFailed("overflowing exp() didn't trigger OverflowError")
+
+# If this fails, it could be a puzzle. One odd possibility is that
+# mathmodule.c's CHECK() macro is getting confused while comparing
+# Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE
+# as a result (and so raising OverflowError instead).
+try:
+ x = math.sqrt(-1.0)
+except ValueError:
+ pass
-
/* Math module -- standard C math library functions, pi and e */
#include "Python.h"
#undef HUGE_VAL
#endif
+/* RED_FLAG 12-Oct-2000 Tim
+ * What CHECK does if errno != 0 and x is a NaN is a platform-dependent crap
+ * shoot. Most (but not all!) platforms will end up setting errno to ERANGE
+ * then, but EDOM is probably better.
+ */
#ifdef HUGE_VAL
#define CHECK(x) if (errno != 0) ; \
else if (-HUGE_VAL <= (x) && (x) <= HUGE_VAL) ; \
#define CHECK(x) /* Don't know how to check */
#endif
-static PyObject *
-math_error(void)
+/* Call is_error when errno != 0, and where x is the result libm
+ * returned. is_error will usually set up an exception and return
+ * true (1), but may return false (0) without setting up an exception.
+ */
+static int
+is_error(double x)
{
+ int result = 1; /* presumption of guilt */
if (errno == EDOM)
PyErr_SetString(PyExc_ValueError, "math domain error");
- else if (errno == ERANGE)
- PyErr_SetString(PyExc_OverflowError, "math range error");
+ else if (errno == ERANGE) {
+ /* ANSI C generally requires libm functions to set ERANGE
+ * on overflow, but also generally *allows* them to set
+ * ERANGE on underflow too. There's no consistency about
+ * the latter across platforms. Here we suppress the
+ * underflow errors (libm functions should return a zero
+ * on underflow, and +- HUGE_VAL on overflow, so testing
+ * the result for zero suffices to distinguish the cases).
+ */
+ if (x)
+ PyErr_SetString(PyExc_OverflowError,
+ "math range error");
+ else
+ result = 0;
+ }
else
/* Unexpected math error */
PyErr_SetFromErrno(PyExc_ValueError);
- return NULL;
+ return result;
}
static PyObject *
x = (*func)(x);
PyFPE_END_PROTECT(x)
CHECK(x);
- if (errno != 0)
- return math_error();
+ if (errno && is_error(x))
+ return NULL;
else
return PyFloat_FromDouble(x);
}
x = (*func)(x, y);
PyFPE_END_PROTECT(x)
CHECK(x);
- if (errno != 0)
- return math_error();
+ if (errno && is_error(x))
+ return NULL;
else
return PyFloat_FromDouble(x);
}
errno = 0;
x = frexp(x, &i);
CHECK(x);
- if (errno != 0)
- return math_error();
- return Py_BuildValue("(di)", x, i);
+ if (errno && is_error(x))
+ return NULL;
+ else
+ return Py_BuildValue("(di)", x, i);
}
static char math_frexp_doc [] =
x = ldexp(x, exp);
PyFPE_END_PROTECT(x)
CHECK(x);
- if (errno != 0)
- return math_error();
+ if (errno && is_error(x))
+ return NULL;
else
return PyFloat_FromDouble(x);
}
x = modf(x, &y);
#endif
CHECK(x);
- if (errno != 0)
- return math_error();
- return Py_BuildValue("(dd)", x, y);
+ if (errno && is_error(x))
+ return NULL;
+ else
+ return Py_BuildValue("(dd)", x, y);
}
static char math_modf_doc [] =