cpython/Modules/mathmodule.c

349 lines
9.7 KiB
C
Raw Normal View History

1990-10-14 09:07:46 -03:00
/* Math module -- standard C math library functions, pi and e */
1996-12-09 18:32:36 -04:00
#include "Python.h"
#include "longintrepr.h"
1990-10-14 09:07:46 -03:00
1996-05-23 19:56:19 -03:00
#ifndef _MSC_VER
#ifndef __STDC__
extern double fmod (double, double);
extern double frexp (double, int *);
extern double ldexp (double, int);
extern double modf (double, double *);
1996-05-23 19:56:19 -03:00
#endif /* __STDC__ */
#endif /* _MSC_VER */
1995-01-12 07:28:16 -04:00
#ifdef i860
/* Cray APP has bogus definition of HUGE_VAL in <math.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.
*/
1991-12-16 11:44:24 -04:00
#ifdef HUGE_VAL
#define CHECK(x) if (errno != 0) ; \
else if (-HUGE_VAL <= (x) && (x) <= HUGE_VAL) ; \
else errno = ERANGE
#else
#define CHECK(x) /* Don't know how to check */
#endif
/* 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)
1991-12-16 11:44:24 -04:00
{
int result = 1; /* presumption of guilt */
assert(errno); /* non-zero errno is a precondition for calling */
1991-12-16 11:44:24 -04:00
if (errno == EDOM)
1996-12-09 18:32:36 -04:00
PyErr_SetString(PyExc_ValueError, "math domain 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;
}
1991-12-16 11:44:24 -04:00
else
1996-12-09 18:32:36 -04:00
/* Unexpected math error */
PyErr_SetFromErrno(PyExc_ValueError);
return result;
1991-12-16 11:44:24 -04:00
}
1996-12-09 18:32:36 -04:00
static PyObject *
math_1(PyObject *args, double (*func) (double), char *argsfmt)
1990-10-14 09:07:46 -03:00
{
double x;
if (! PyArg_ParseTuple(args, argsfmt, &x))
1990-10-14 09:07:46 -03:00
return NULL;
errno = 0;
PyFPE_START_PROTECT("in math_1", return 0)
1990-10-14 09:07:46 -03:00
x = (*func)(x);
1997-03-14 00:32:50 -04:00
PyFPE_END_PROTECT(x)
1991-12-16 11:44:24 -04:00
CHECK(x);
if (errno && is_error(x))
return NULL;
1990-10-14 09:07:46 -03:00
else
1996-12-09 18:32:36 -04:00
return PyFloat_FromDouble(x);
1990-10-14 09:07:46 -03:00
}
1996-12-09 18:32:36 -04:00
static PyObject *
math_2(PyObject *args, double (*func) (double, double), char *argsfmt)
1990-10-14 09:07:46 -03:00
{
double x, y;
if (! PyArg_ParseTuple(args, argsfmt, &x, &y))
1990-10-14 09:07:46 -03:00
return NULL;
errno = 0;
PyFPE_START_PROTECT("in math_2", return 0)
1990-10-14 09:07:46 -03:00
x = (*func)(x, y);
1997-03-14 00:32:50 -04:00
PyFPE_END_PROTECT(x)
1991-12-16 11:44:24 -04:00
CHECK(x);
if (errno && is_error(x))
return NULL;
1990-10-14 09:07:46 -03:00
else
1996-12-09 18:32:36 -04:00
return PyFloat_FromDouble(x);
1990-10-14 09:07:46 -03:00
}
#define FUNC1(funcname, func, docstring) \
static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
return math_1(args, func, "d:" #funcname); \
}\
static char math_##funcname##_doc [] = docstring;
1990-10-14 09:07:46 -03:00
#define FUNC2(funcname, func, docstring) \
static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
return math_2(args, func, "dd:" #funcname); \
}\
static char math_##funcname##_doc [] = docstring;
FUNC1(acos, acos,
"acos(x)\n\nReturn the arc cosine (measured in radians) of x.")
FUNC1(asin, asin,
"asin(x)\n\nReturn the arc sine (measured in radians) of x.")
FUNC1(atan, atan,
"atan(x)\n\nReturn the arc tangent (measured in radians) of x.")
FUNC2(atan2, atan2,
"atan2(y, x)\n\nReturn the arc tangent (measured in radians) of y/x.\n"
"Unlike atan(y/x), the signs of both x and y are considered.")
FUNC1(ceil, ceil,
"ceil(x)\n\nReturn the ceiling of x as a float.\n"
"This is the smallest integral value >= x.")
FUNC1(cos, cos,
"cos(x)\n\nReturn the cosine of x (measured in radians).")
FUNC1(cosh, cosh,
"cosh(x)\n\nReturn the hyperbolic cosine of x.")
FUNC1(exp, exp,
"exp(x)\n\nReturn e raised to the power of x.")
FUNC1(fabs, fabs,
"fabs(x)\n\nReturn the absolute value of the float x.")
FUNC1(floor, floor,
"floor(x)\n\nReturn the floor of x as a float.\n"
"This is the largest integral value <= x.")
2001-06-10 13:45:08 -03:00
FUNC2(fmod, fmod,
"fmod(x,y)\n\nReturn fmod(x, y), according to platform C."
" x % y may differ.")
FUNC2(hypot, hypot,
"hypot(x,y)\n\nReturn the Euclidean distance, sqrt(x*x + y*y).")
#ifdef MPW_3_1 /* This hack is needed for MPW 3.1 but not for 3.2 ... */
FUNC2(pow, power,
"pow(x,y)\n\nReturn x**y (x to the power of y).")
#else
FUNC2(pow, pow,
"pow(x,y)\n\nReturn x**y (x to the power of y).")
#endif
FUNC1(sin, sin,
"sin(x)\n\nReturn the sine of x (measured in radians).")
FUNC1(sinh, sinh,
"sinh(x)\n\nReturn the hyperbolic sine of x.")
FUNC1(sqrt, sqrt,
"sqrt(x)\n\nReturn the square root of x.")
FUNC1(tan, tan,
"tan(x)\n\nReturn the tangent of x (measured in radians).")
FUNC1(tanh, tanh,
"tanh(x)\n\nReturn the hyperbolic tangent of x.")
1990-10-14 09:07:46 -03:00
1996-12-09 18:32:36 -04:00
static PyObject *
math_frexp(PyObject *self, PyObject *args)
1991-10-24 11:57:21 -03:00
{
double x;
int i;
if (! PyArg_ParseTuple(args, "d:frexp", &x))
1991-10-24 11:57:21 -03:00
return NULL;
errno = 0;
x = frexp(x, &i);
1991-12-16 11:44:24 -04:00
CHECK(x);
if (errno && is_error(x))
return NULL;
else
return Py_BuildValue("(di)", x, i);
1991-10-24 11:57:21 -03:00
}
static char math_frexp_doc [] =
"frexp(x)\n"
"\n"
"Return the mantissa and exponent of x, as pair (m, e).\n"
"m is a float and e is an int, such that x = m * 2.**e.\n"
"If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.";
1996-12-09 18:32:36 -04:00
static PyObject *
math_ldexp(PyObject *self, PyObject *args)
1991-10-24 11:57:21 -03:00
{
double x;
int exp;
if (! PyArg_ParseTuple(args, "di:ldexp", &x, &exp))
1991-10-24 11:57:21 -03:00
return NULL;
errno = 0;
PyFPE_START_PROTECT("ldexp", return 0)
x = ldexp(x, exp);
1997-03-14 00:32:50 -04:00
PyFPE_END_PROTECT(x)
1991-12-16 11:44:24 -04:00
CHECK(x);
if (errno && is_error(x))
return NULL;
1991-10-24 11:57:21 -03:00
else
1996-12-09 18:32:36 -04:00
return PyFloat_FromDouble(x);
1991-10-24 11:57:21 -03:00
}
static char math_ldexp_doc [] =
"ldexp(x, i) -> x * (2**i)";
1996-12-09 18:32:36 -04:00
static PyObject *
math_modf(PyObject *self, PyObject *args)
1991-10-24 11:57:21 -03:00
{
double x, y;
if (! PyArg_ParseTuple(args, "d:modf", &x))
1991-10-24 11:57:21 -03:00
return NULL;
errno = 0;
#ifdef MPW /* MPW C modf expects pointer to extended as second argument */
{
extended e;
x = modf(x, &e);
y = e;
}
#else
1991-10-24 11:57:21 -03:00
x = modf(x, &y);
#endif
1991-12-16 11:44:24 -04:00
CHECK(x);
if (errno && is_error(x))
return NULL;
else
return Py_BuildValue("(dd)", x, y);
1991-10-24 11:57:21 -03:00
}
1990-10-14 09:07:46 -03:00
static char math_modf_doc [] =
"modf(x)\n"
"\n"
"Return the fractional and integer parts of x. Both results carry the sign\n"
"of x. The integer part is returned as a real.";
/* A decent logarithm is easy to compute even for huge longs, but libm can't
do that by itself -- loghelper can. func is log or log10, and name is
"log" or "log10". Note that overflow isn't possible: a long can contain
no more than INT_MAX * SHIFT bits, so has value certainly less than
2**(2**64 * 2**16) == 2**2**80, and log2 of that is 2**80, which is
small enough to fit in an IEEE single. log and log10 are even smaller.
*/
static PyObject*
loghelper(PyObject* args, double (*func)(double), char *name)
{
PyObject *arg;
char format[16];
/* See whether this is a long. */
format[0] = 'O';
format[1] = ':';
strcpy(format + 2, name);
if (! PyArg_ParseTuple(args, format, &arg))
return NULL;
/* If it is long, do it ourselves. */
if (PyLong_Check(arg)) {
double x;
int e;
x = _PyLong_AsScaledDouble(arg, &e);
if (x <= 0.0) {
PyErr_SetString(PyExc_ValueError,
"math domain error");
return NULL;
}
/* Value is ~= x * 2**(e*SHIFT), so the log ~=
log(x) + log(2) * e * SHIFT.
CAUTION: e*SHIFT may overflow using int arithmetic,
so force use of double. */
x = func(x) + func(2.0) * (double)e * (double)SHIFT;
return PyFloat_FromDouble(x);
}
/* Else let libm handle it by itself. */
format[0] = 'd';
return math_1(args, func, format);
}
static PyObject *
math_log(PyObject *self, PyObject *args)
{
return loghelper(args, log, "log");
}
static char math_log_doc[] =
"log(x) -> the natural logarithm (base e) of x.";
static PyObject *
math_log10(PyObject *self, PyObject *args)
{
return loghelper(args, log10, "log10");
}
static char math_log10_doc[] =
"log10(x) -> the base 10 logarithm of x.";
1996-12-09 18:32:36 -04:00
static PyMethodDef math_methods[] = {
{"acos", math_acos, METH_VARARGS, math_acos_doc},
{"asin", math_asin, METH_VARARGS, math_asin_doc},
{"atan", math_atan, METH_VARARGS, math_atan_doc},
{"atan2", math_atan2, METH_VARARGS, math_atan2_doc},
{"ceil", math_ceil, METH_VARARGS, math_ceil_doc},
{"cos", math_cos, METH_VARARGS, math_cos_doc},
{"cosh", math_cosh, METH_VARARGS, math_cosh_doc},
{"exp", math_exp, METH_VARARGS, math_exp_doc},
{"fabs", math_fabs, METH_VARARGS, math_fabs_doc},
{"floor", math_floor, METH_VARARGS, math_floor_doc},
{"fmod", math_fmod, METH_VARARGS, math_fmod_doc},
{"frexp", math_frexp, METH_VARARGS, math_frexp_doc},
{"hypot", math_hypot, METH_VARARGS, math_hypot_doc},
{"ldexp", math_ldexp, METH_VARARGS, math_ldexp_doc},
{"log", math_log, METH_VARARGS, math_log_doc},
{"log10", math_log10, METH_VARARGS, math_log10_doc},
{"modf", math_modf, METH_VARARGS, math_modf_doc},
{"pow", math_pow, METH_VARARGS, math_pow_doc},
{"sin", math_sin, METH_VARARGS, math_sin_doc},
{"sinh", math_sinh, METH_VARARGS, math_sinh_doc},
{"sqrt", math_sqrt, METH_VARARGS, math_sqrt_doc},
{"tan", math_tan, METH_VARARGS, math_tan_doc},
{"tanh", math_tanh, METH_VARARGS, math_tanh_doc},
1990-10-14 09:07:46 -03:00
{NULL, NULL} /* sentinel */
};
static char module_doc [] =
"This module is always available. It provides access to the\n"
"mathematical functions defined by the C standard.";
DL_EXPORT(void)
initmath(void)
1990-10-14 09:07:46 -03:00
{
1996-12-09 18:32:36 -04:00
PyObject *m, *d, *v;
m = Py_InitModule3("math", math_methods, module_doc);
1996-12-09 18:32:36 -04:00
d = PyModule_GetDict(m);
1996-12-16 20:47:03 -04:00
if (!(v = PyFloat_FromDouble(atan(1.0) * 4.0)))
goto finally;
if (PyDict_SetItemString(d, "pi", v) < 0)
goto finally;
1996-12-09 18:32:36 -04:00
Py_DECREF(v);
1996-12-16 20:47:03 -04:00
if (!(v = PyFloat_FromDouble(exp(1.0))))
goto finally;
1996-12-18 10:12:22 -04:00
if (PyDict_SetItemString(d, "e", v) < 0)
1996-12-16 20:47:03 -04:00
goto finally;
1996-12-09 18:32:36 -04:00
Py_DECREF(v);
1996-12-16 20:47:03 -04:00
finally:
return;
1990-10-14 09:07:46 -03:00
}