Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

gh-122681: merge m_atan2() and c_atan2() helper functions (#122682)

This commit is contained in:
Sergey B Kirpichev 2024-08-06 15:43:13 +03:00 committed by GitHub
parent 6ff82fdb56
commit 0b433aa9df
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 41 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
Modules/_math.h
View File

@ -23,3 +23,42 @@ _Py_log1p(double x)
}
#define m_log1p _Py_log1p
/*
wrapper for atan2 that deals directly with special cases before
delegating to the platform libm for the remaining cases. This
is necessary to get consistent behaviour across platforms.
Windows, FreeBSD and alpha Tru64 are amongst platforms that don't
always follow C99. Windows screws up atan2 for inf and nan, and
alpha Tru64 5.1 doesn't follow C99 for atan2(0., 0.).
*/
static double
_Py_atan2(double y, double x)
{
if (isnan(x) || isnan(y))
return Py_NAN;
if (isinf(y)) {
if (isinf(x)) {
if (copysign(1., x) == 1.)
/* atan2(+-inf, +inf) == +-pi/4 */
return copysign(0.25*Py_MATH_PI, y);
else
/* atan2(+-inf, -inf) == +-pi*3/4 */
return copysign(0.75*Py_MATH_PI, y);
}
/* atan2(+-inf, x) == +-pi/2 for finite x */
return copysign(0.5*Py_MATH_PI, y);
}
if (isinf(x) || y == 0.) {
if (copysign(1., x) == 1.)
/* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
return copysign(0., y);
else
/* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
return copysign(Py_MATH_PI, y);
}
return atan2(y, x);
}
#define m_atan2 _Py_atan2

34
Modules/cmathmodule.c
View File

@ -324,36 +324,6 @@ cmath_atan_impl(PyObject *module, Py_complex z)
return r;
}
/* Windows screws up atan2 for inf and nan, and alpha Tru64 5.1 doesn't follow
C99 for atan2(0., 0.). */
static double
c_atan2(Py_complex z)
{
if (isnan(z.real) || isnan(z.imag))
return Py_NAN;
if (isinf(z.imag)) {
if (isinf(z.real)) {
if (copysign(1., z.real) == 1.)
/* atan2(+-inf, +inf) == +-pi/4 */
return copysign(0.25*Py_MATH_PI, z.imag);
else
/* atan2(+-inf, -inf) == +-pi*3/4 */
return copysign(0.75*Py_MATH_PI, z.imag);
}
/* atan2(+-inf, x) == +-pi/2 for finite x */
return copysign(0.5*Py_MATH_PI, z.imag);
}
if (isinf(z.real) || z.imag == 0.) {
if (copysign(1., z.real) == 1.)
/* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
return copysign(0., z.imag);
else
/* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
return copysign(Py_MATH_PI, z.imag);
}
return atan2(z.imag, z.real);
}
static Py_complex atanh_special_values[7][7];
@ -966,7 +936,7 @@ cmath_phase_impl(PyObject *module, Py_complex z)
double phi;
errno = 0;
phi = c_atan2(z); /* should not cause any exception */
phi = m_atan2(z.imag, z.real); /* should not cause any exception */
if (errno != 0)
return math_error();
else
@ -991,7 +961,7 @@ cmath_polar_impl(PyObject *module, Py_complex z)
double r, phi;
errno = 0;
phi = c_atan2(z); /* should not cause any exception */
phi = m_atan2(z.imag, z.real); /* should not cause any exception */
r = _Py_c_abs(z); /* sets errno to ERANGE on overflow */
if (errno != 0)
return math_error();

37
Modules/mathmodule.c
View File

@ -535,43 +535,6 @@ m_lgamma(double x)
return r;
}
/*
wrapper for atan2 that deals directly with special cases before
delegating to the platform libm for the remaining cases. This
is necessary to get consistent behaviour across platforms.
Windows, FreeBSD and alpha Tru64 are amongst platforms that don't
always follow C99.
*/
static double
m_atan2(double y, double x)
{
if (isnan(x) || isnan(y))
return Py_NAN;
if (isinf(y)) {
if (isinf(x)) {
if (copysign(1., x) == 1.)
/* atan2(+-inf, +inf) == +-pi/4 */
return copysign(0.25*Py_MATH_PI, y);
else
/* atan2(+-inf, -inf) == +-pi*3/4 */
return copysign(0.75*Py_MATH_PI, y);
}
/* atan2(+-inf, x) == +-pi/2 for finite x */
return copysign(0.5*Py_MATH_PI, y);
}
if (isinf(x) || y == 0.) {
if (copysign(1., x) == 1.)
/* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
return copysign(0., y);
else
/* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
return copysign(Py_MATH_PI, y);
}
return atan2(y, x);
}
/* IEEE 754-style remainder operation: x - n*y where n*y is the nearest
multiple of y to x, taking n even in the case of a tie. Assuming an IEEE 754
binary floating-point format, the result is always exact. */