Untabify C files. Will watch buildbots.
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index 2dd7a66..77b56a0 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -73,36 +73,36 @@
static double
sinpi(double x)
{
- double y, r;
- int n;
- /* this function should only ever be called for finite arguments */
- assert(Py_IS_FINITE(x));
- y = fmod(fabs(x), 2.0);
- n = (int)round(2.0*y);
- assert(0 <= n && n <= 4);
- switch (n) {
- case 0:
- r = sin(pi*y);
- break;
- case 1:
- r = cos(pi*(y-0.5));
- break;
- case 2:
- /* N.B. -sin(pi*(y-1.0)) is *not* equivalent: it would give
- -0.0 instead of 0.0 when y == 1.0. */
- r = sin(pi*(1.0-y));
- break;
- case 3:
- r = -cos(pi*(y-1.5));
- break;
- case 4:
- r = sin(pi*(y-2.0));
- break;
- default:
- assert(0); /* should never get here */
- r = -1.23e200; /* silence gcc warning */
- }
- return copysign(1.0, x)*r;
+ double y, r;
+ int n;
+ /* this function should only ever be called for finite arguments */
+ assert(Py_IS_FINITE(x));
+ y = fmod(fabs(x), 2.0);
+ n = (int)round(2.0*y);
+ assert(0 <= n && n <= 4);
+ switch (n) {
+ case 0:
+ r = sin(pi*y);
+ break;
+ case 1:
+ r = cos(pi*(y-0.5));
+ break;
+ case 2:
+ /* N.B. -sin(pi*(y-1.0)) is *not* equivalent: it would give
+ -0.0 instead of 0.0 when y == 1.0. */
+ r = sin(pi*(1.0-y));
+ break;
+ case 3:
+ r = -cos(pi*(y-1.5));
+ break;
+ case 4:
+ r = sin(pi*(y-2.0));
+ break;
+ default:
+ assert(0); /* should never get here */
+ r = -1.23e200; /* silence gcc warning */
+ }
+ return copysign(1.0, x)*r;
}
/* Implementation of the real gamma function. In extensive but non-exhaustive
@@ -166,34 +166,34 @@
static const double lanczos_g = 6.024680040776729583740234375;
static const double lanczos_g_minus_half = 5.524680040776729583740234375;
static const double lanczos_num_coeffs[LANCZOS_N] = {
- 23531376880.410759688572007674451636754734846804940,
- 42919803642.649098768957899047001988850926355848959,
- 35711959237.355668049440185451547166705960488635843,
- 17921034426.037209699919755754458931112671403265390,
- 6039542586.3520280050642916443072979210699388420708,
- 1439720407.3117216736632230727949123939715485786772,
- 248874557.86205415651146038641322942321632125127801,
- 31426415.585400194380614231628318205362874684987640,
- 2876370.6289353724412254090516208496135991145378768,
- 186056.26539522349504029498971604569928220784236328,
- 8071.6720023658162106380029022722506138218516325024,
- 210.82427775157934587250973392071336271166969580291,
- 2.5066282746310002701649081771338373386264310793408
+ 23531376880.410759688572007674451636754734846804940,
+ 42919803642.649098768957899047001988850926355848959,
+ 35711959237.355668049440185451547166705960488635843,
+ 17921034426.037209699919755754458931112671403265390,
+ 6039542586.3520280050642916443072979210699388420708,
+ 1439720407.3117216736632230727949123939715485786772,
+ 248874557.86205415651146038641322942321632125127801,
+ 31426415.585400194380614231628318205362874684987640,
+ 2876370.6289353724412254090516208496135991145378768,
+ 186056.26539522349504029498971604569928220784236328,
+ 8071.6720023658162106380029022722506138218516325024,
+ 210.82427775157934587250973392071336271166969580291,
+ 2.5066282746310002701649081771338373386264310793408
};
/* denominator is x*(x+1)*...*(x+LANCZOS_N-2) */
static const double lanczos_den_coeffs[LANCZOS_N] = {
- 0.0, 39916800.0, 120543840.0, 150917976.0, 105258076.0, 45995730.0,
- 13339535.0, 2637558.0, 357423.0, 32670.0, 1925.0, 66.0, 1.0};
+ 0.0, 39916800.0, 120543840.0, 150917976.0, 105258076.0, 45995730.0,
+ 13339535.0, 2637558.0, 357423.0, 32670.0, 1925.0, 66.0, 1.0};
/* gamma values for small positive integers, 1 though NGAMMA_INTEGRAL */
#define NGAMMA_INTEGRAL 23
static const double gamma_integral[NGAMMA_INTEGRAL] = {
- 1.0, 1.0, 2.0, 6.0, 24.0, 120.0, 720.0, 5040.0, 40320.0, 362880.0,
- 3628800.0, 39916800.0, 479001600.0, 6227020800.0, 87178291200.0,
- 1307674368000.0, 20922789888000.0, 355687428096000.0,
- 6402373705728000.0, 121645100408832000.0, 2432902008176640000.0,
- 51090942171709440000.0, 1124000727777607680000.0,
+ 1.0, 1.0, 2.0, 6.0, 24.0, 120.0, 720.0, 5040.0, 40320.0, 362880.0,
+ 3628800.0, 39916800.0, 479001600.0, 6227020800.0, 87178291200.0,
+ 1307674368000.0, 20922789888000.0, 355687428096000.0,
+ 6402373705728000.0, 121645100408832000.0, 2432902008176640000.0,
+ 51090942171709440000.0, 1124000727777607680000.0,
};
/* Lanczos' sum L_g(x), for positive x */
@@ -201,125 +201,125 @@
static double
lanczos_sum(double x)
{
- double num = 0.0, den = 0.0;
- int i;
- assert(x > 0.0);
- /* evaluate the rational function lanczos_sum(x). For large
- x, the obvious algorithm risks overflow, so we instead
- rescale the denominator and numerator of the rational
- function by x**(1-LANCZOS_N) and treat this as a
- rational function in 1/x. This also reduces the error for
- larger x values. The choice of cutoff point (5.0 below) is
- somewhat arbitrary; in tests, smaller cutoff values than
- this resulted in lower accuracy. */
- if (x < 5.0) {
- for (i = LANCZOS_N; --i >= 0; ) {
- num = num * x + lanczos_num_coeffs[i];
- den = den * x + lanczos_den_coeffs[i];
- }
- }
- else {
- for (i = 0; i < LANCZOS_N; i++) {
- num = num / x + lanczos_num_coeffs[i];
- den = den / x + lanczos_den_coeffs[i];
- }
- }
- return num/den;
+ double num = 0.0, den = 0.0;
+ int i;
+ assert(x > 0.0);
+ /* evaluate the rational function lanczos_sum(x). For large
+ x, the obvious algorithm risks overflow, so we instead
+ rescale the denominator and numerator of the rational
+ function by x**(1-LANCZOS_N) and treat this as a
+ rational function in 1/x. This also reduces the error for
+ larger x values. The choice of cutoff point (5.0 below) is
+ somewhat arbitrary; in tests, smaller cutoff values than
+ this resulted in lower accuracy. */
+ if (x < 5.0) {
+ for (i = LANCZOS_N; --i >= 0; ) {
+ num = num * x + lanczos_num_coeffs[i];
+ den = den * x + lanczos_den_coeffs[i];
+ }
+ }
+ else {
+ for (i = 0; i < LANCZOS_N; i++) {
+ num = num / x + lanczos_num_coeffs[i];
+ den = den / x + lanczos_den_coeffs[i];
+ }
+ }
+ return num/den;
}
static double
m_tgamma(double x)
{
- double absx, r, y, z, sqrtpow;
+ double absx, r, y, z, sqrtpow;
- /* special cases */
- if (!Py_IS_FINITE(x)) {
- if (Py_IS_NAN(x) || x > 0.0)
- return x; /* tgamma(nan) = nan, tgamma(inf) = inf */
- else {
- errno = EDOM;
- return Py_NAN; /* tgamma(-inf) = nan, invalid */
- }
- }
- if (x == 0.0) {
- errno = EDOM;
- return 1.0/x; /* tgamma(+-0.0) = +-inf, divide-by-zero */
- }
+ /* special cases */
+ if (!Py_IS_FINITE(x)) {
+ if (Py_IS_NAN(x) || x > 0.0)
+ return x; /* tgamma(nan) = nan, tgamma(inf) = inf */
+ else {
+ errno = EDOM;
+ return Py_NAN; /* tgamma(-inf) = nan, invalid */
+ }
+ }
+ if (x == 0.0) {
+ errno = EDOM;
+ return 1.0/x; /* tgamma(+-0.0) = +-inf, divide-by-zero */
+ }
- /* integer arguments */
- if (x == floor(x)) {
- if (x < 0.0) {
- errno = EDOM; /* tgamma(n) = nan, invalid for */
- return Py_NAN; /* negative integers n */
- }
- if (x <= NGAMMA_INTEGRAL)
- return gamma_integral[(int)x - 1];
- }
- absx = fabs(x);
+ /* integer arguments */
+ if (x == floor(x)) {
+ if (x < 0.0) {
+ errno = EDOM; /* tgamma(n) = nan, invalid for */
+ return Py_NAN; /* negative integers n */
+ }
+ if (x <= NGAMMA_INTEGRAL)
+ return gamma_integral[(int)x - 1];
+ }
+ absx = fabs(x);
- /* tiny arguments: tgamma(x) ~ 1/x for x near 0 */
- if (absx < 1e-20) {
- r = 1.0/x;
- if (Py_IS_INFINITY(r))
- errno = ERANGE;
- return r;
- }
+ /* tiny arguments: tgamma(x) ~ 1/x for x near 0 */
+ if (absx < 1e-20) {
+ r = 1.0/x;
+ if (Py_IS_INFINITY(r))
+ errno = ERANGE;
+ return r;
+ }
- /* large arguments: assuming IEEE 754 doubles, tgamma(x) overflows for
- x > 200, and underflows to +-0.0 for x < -200, not a negative
- integer. */
- if (absx > 200.0) {
- if (x < 0.0) {
- return 0.0/sinpi(x);
- }
- else {
- errno = ERANGE;
- return Py_HUGE_VAL;
- }
- }
+ /* large arguments: assuming IEEE 754 doubles, tgamma(x) overflows for
+ x > 200, and underflows to +-0.0 for x < -200, not a negative
+ integer. */
+ if (absx > 200.0) {
+ if (x < 0.0) {
+ return 0.0/sinpi(x);
+ }
+ else {
+ errno = ERANGE;
+ return Py_HUGE_VAL;
+ }
+ }
- y = absx + lanczos_g_minus_half;
- /* compute error in sum */
- if (absx > lanczos_g_minus_half) {
- /* note: the correction can be foiled by an optimizing
- compiler that (incorrectly) thinks that an expression like
- a + b - a - b can be optimized to 0.0. This shouldn't
- happen in a standards-conforming compiler. */
- double q = y - absx;
- z = q - lanczos_g_minus_half;
- }
- else {
- double q = y - lanczos_g_minus_half;
- z = q - absx;
- }
- z = z * lanczos_g / y;
- if (x < 0.0) {
- r = -pi / sinpi(absx) / absx * exp(y) / lanczos_sum(absx);
- r -= z * r;
- if (absx < 140.0) {
- r /= pow(y, absx - 0.5);
- }
- else {
- sqrtpow = pow(y, absx / 2.0 - 0.25);
- r /= sqrtpow;
- r /= sqrtpow;
- }
- }
- else {
- r = lanczos_sum(absx) / exp(y);
- r += z * r;
- if (absx < 140.0) {
- r *= pow(y, absx - 0.5);
- }
- else {
- sqrtpow = pow(y, absx / 2.0 - 0.25);
- r *= sqrtpow;
- r *= sqrtpow;
- }
- }
- if (Py_IS_INFINITY(r))
- errno = ERANGE;
- return r;
+ y = absx + lanczos_g_minus_half;
+ /* compute error in sum */
+ if (absx > lanczos_g_minus_half) {
+ /* note: the correction can be foiled by an optimizing
+ compiler that (incorrectly) thinks that an expression like
+ a + b - a - b can be optimized to 0.0. This shouldn't
+ happen in a standards-conforming compiler. */
+ double q = y - absx;
+ z = q - lanczos_g_minus_half;
+ }
+ else {
+ double q = y - lanczos_g_minus_half;
+ z = q - absx;
+ }
+ z = z * lanczos_g / y;
+ if (x < 0.0) {
+ r = -pi / sinpi(absx) / absx * exp(y) / lanczos_sum(absx);
+ r -= z * r;
+ if (absx < 140.0) {
+ r /= pow(y, absx - 0.5);
+ }
+ else {
+ sqrtpow = pow(y, absx / 2.0 - 0.25);
+ r /= sqrtpow;
+ r /= sqrtpow;
+ }
+ }
+ else {
+ r = lanczos_sum(absx) / exp(y);
+ r += z * r;
+ if (absx < 140.0) {
+ r *= pow(y, absx - 0.5);
+ }
+ else {
+ sqrtpow = pow(y, absx / 2.0 - 0.25);
+ r *= sqrtpow;
+ r *= sqrtpow;
+ }
+ }
+ if (Py_IS_INFINITY(r))
+ errno = ERANGE;
+ return r;
}
/*
@@ -330,49 +330,49 @@
static double
m_lgamma(double x)
{
- double r, absx;
+ double r, absx;
- /* special cases */
- if (!Py_IS_FINITE(x)) {
- if (Py_IS_NAN(x))
- return x; /* lgamma(nan) = nan */
- else
- return Py_HUGE_VAL; /* lgamma(+-inf) = +inf */
- }
+ /* special cases */
+ if (!Py_IS_FINITE(x)) {
+ if (Py_IS_NAN(x))
+ return x; /* lgamma(nan) = nan */
+ else
+ return Py_HUGE_VAL; /* lgamma(+-inf) = +inf */
+ }
- /* integer arguments */
- if (x == floor(x) && x <= 2.0) {
- if (x <= 0.0) {
- errno = EDOM; /* lgamma(n) = inf, divide-by-zero for */
- return Py_HUGE_VAL; /* integers n <= 0 */
- }
- else {
- return 0.0; /* lgamma(1) = lgamma(2) = 0.0 */
- }
- }
+ /* integer arguments */
+ if (x == floor(x) && x <= 2.0) {
+ if (x <= 0.0) {
+ errno = EDOM; /* lgamma(n) = inf, divide-by-zero for */
+ return Py_HUGE_VAL; /* integers n <= 0 */
+ }
+ else {
+ return 0.0; /* lgamma(1) = lgamma(2) = 0.0 */
+ }
+ }
- absx = fabs(x);
- /* tiny arguments: lgamma(x) ~ -log(fabs(x)) for small x */
- if (absx < 1e-20)
- return -log(absx);
+ absx = fabs(x);
+ /* tiny arguments: lgamma(x) ~ -log(fabs(x)) for small x */
+ if (absx < 1e-20)
+ return -log(absx);
- /* Lanczos' formula */
- if (x > 0.0) {
- /* we could save a fraction of a ulp in accuracy by having a
- second set of numerator coefficients for lanczos_sum that
- absorbed the exp(-lanczos_g) term, and throwing out the
- lanczos_g subtraction below; it's probably not worth it. */
- r = log(lanczos_sum(x)) - lanczos_g +
- (x-0.5)*(log(x+lanczos_g-0.5)-1);
- }
- else {
- r = log(pi) - log(fabs(sinpi(absx))) - log(absx) -
- (log(lanczos_sum(absx)) - lanczos_g +
- (absx-0.5)*(log(absx+lanczos_g-0.5)-1));
- }
- if (Py_IS_INFINITY(r))
- errno = ERANGE;
- return r;
+ /* Lanczos' formula */
+ if (x > 0.0) {
+ /* we could save a fraction of a ulp in accuracy by having a
+ second set of numerator coefficients for lanczos_sum that
+ absorbed the exp(-lanczos_g) term, and throwing out the
+ lanczos_g subtraction below; it's probably not worth it. */
+ r = log(lanczos_sum(x)) - lanczos_g +
+ (x-0.5)*(log(x+lanczos_g-0.5)-1);
+ }
+ else {
+ r = log(pi) - log(fabs(sinpi(absx))) - log(absx) -
+ (log(lanczos_sum(absx)) - lanczos_g +
+ (absx-0.5)*(log(absx+lanczos_g-0.5)-1));
+ }
+ if (Py_IS_INFINITY(r))
+ errno = ERANGE;
+ return r;
}
/*
@@ -428,17 +428,17 @@
static double
m_erf_series(double x)
{
- double x2, acc, fk;
- int i;
+ double x2, acc, fk;
+ int i;
- x2 = x * x;
- acc = 0.0;
- fk = (double)ERF_SERIES_TERMS + 0.5;
- for (i = 0; i < ERF_SERIES_TERMS; i++) {
- acc = 2.0 + x2 * acc / fk;
- fk -= 1.0;
- }
- return acc * x * exp(-x2) / sqrtpi;
+ x2 = x * x;
+ acc = 0.0;
+ fk = (double)ERF_SERIES_TERMS + 0.5;
+ for (i = 0; i < ERF_SERIES_TERMS; i++) {
+ acc = 2.0 + x2 * acc / fk;
+ fk -= 1.0;
+ }
+ return acc * x * exp(-x2) / sqrtpi;
}
/*
@@ -453,26 +453,26 @@
static double
m_erfc_contfrac(double x)
{
- double x2, a, da, p, p_last, q, q_last, b;
- int i;
+ double x2, a, da, p, p_last, q, q_last, b;
+ int i;
- if (x >= ERFC_CONTFRAC_CUTOFF)
- return 0.0;
+ if (x >= ERFC_CONTFRAC_CUTOFF)
+ return 0.0;
- x2 = x*x;
- a = 0.0;
- da = 0.5;
- p = 1.0; p_last = 0.0;
- q = da + x2; q_last = 1.0;
- for (i = 0; i < ERFC_CONTFRAC_TERMS; i++) {
- double temp;
- a += da;
- da += 2.0;
- b = da + x2;
- temp = p; p = b*p - a*p_last; p_last = temp;
- temp = q; q = b*q - a*q_last; q_last = temp;
- }
- return p / q * x * exp(-x2) / sqrtpi;
+ x2 = x*x;
+ a = 0.0;
+ da = 0.5;
+ p = 1.0; p_last = 0.0;
+ q = da + x2; q_last = 1.0;
+ for (i = 0; i < ERFC_CONTFRAC_TERMS; i++) {
+ double temp;
+ a += da;
+ da += 2.0;
+ b = da + x2;
+ temp = p; p = b*p - a*p_last; p_last = temp;
+ temp = q; q = b*q - a*q_last; q_last = temp;
+ }
+ return p / q * x * exp(-x2) / sqrtpi;
}
/* Error function erf(x), for general x */
@@ -480,17 +480,17 @@
static double
m_erf(double x)
{
- double absx, cf;
+ double absx, cf;
- if (Py_IS_NAN(x))
- return x;
- absx = fabs(x);
- if (absx < ERF_SERIES_CUTOFF)
- return m_erf_series(x);
- else {
- cf = m_erfc_contfrac(absx);
- return x > 0.0 ? 1.0 - cf : cf - 1.0;
- }
+ if (Py_IS_NAN(x))
+ return x;
+ absx = fabs(x);
+ if (absx < ERF_SERIES_CUTOFF)
+ return m_erf_series(x);
+ else {
+ cf = m_erfc_contfrac(absx);
+ return x > 0.0 ? 1.0 - cf : cf - 1.0;
+ }
}
/* Complementary error function erfc(x), for general x. */
@@ -498,17 +498,17 @@
static double
m_erfc(double x)
{
- double absx, cf;
+ double absx, cf;
- if (Py_IS_NAN(x))
- return x;
- absx = fabs(x);
- if (absx < ERF_SERIES_CUTOFF)
- return 1.0 - m_erf_series(x);
- else {
- cf = m_erfc_contfrac(absx);
- return x > 0.0 ? cf : 2.0 - cf;
- }
+ if (Py_IS_NAN(x))
+ return x;
+ absx = fabs(x);
+ if (absx < ERF_SERIES_CUTOFF)
+ return 1.0 - m_erf_series(x);
+ else {
+ cf = m_erfc_contfrac(absx);
+ return x > 0.0 ? cf : 2.0 - cf;
+ }
}
/*
@@ -522,29 +522,29 @@
static double
m_atan2(double y, double x)
{
- if (Py_IS_NAN(x) || Py_IS_NAN(y))
- return Py_NAN;
- if (Py_IS_INFINITY(y)) {
- if (Py_IS_INFINITY(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 (Py_IS_INFINITY(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);
+ if (Py_IS_NAN(x) || Py_IS_NAN(y))
+ return Py_NAN;
+ if (Py_IS_INFINITY(y)) {
+ if (Py_IS_INFINITY(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 (Py_IS_INFINITY(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);
}
/*
@@ -557,45 +557,45 @@
static double
m_log(double x)
{
- if (Py_IS_FINITE(x)) {
- if (x > 0.0)
- return log(x);
- errno = EDOM;
- if (x == 0.0)
- return -Py_HUGE_VAL; /* log(0) = -inf */
- else
- return Py_NAN; /* log(-ve) = nan */
- }
- else if (Py_IS_NAN(x))
- return x; /* log(nan) = nan */
- else if (x > 0.0)
- return x; /* log(inf) = inf */
- else {
- errno = EDOM;
- return Py_NAN; /* log(-inf) = nan */
- }
+ if (Py_IS_FINITE(x)) {
+ if (x > 0.0)
+ return log(x);
+ errno = EDOM;
+ if (x == 0.0)
+ return -Py_HUGE_VAL; /* log(0) = -inf */
+ else
+ return Py_NAN; /* log(-ve) = nan */
+ }
+ else if (Py_IS_NAN(x))
+ return x; /* log(nan) = nan */
+ else if (x > 0.0)
+ return x; /* log(inf) = inf */
+ else {
+ errno = EDOM;
+ return Py_NAN; /* log(-inf) = nan */
+ }
}
static double
m_log10(double x)
{
- if (Py_IS_FINITE(x)) {
- if (x > 0.0)
- return log10(x);
- errno = EDOM;
- if (x == 0.0)
- return -Py_HUGE_VAL; /* log10(0) = -inf */
- else
- return Py_NAN; /* log10(-ve) = nan */
- }
- else if (Py_IS_NAN(x))
- return x; /* log10(nan) = nan */
- else if (x > 0.0)
- return x; /* log10(inf) = inf */
- else {
- errno = EDOM;
- return Py_NAN; /* log10(-inf) = nan */
- }
+ if (Py_IS_FINITE(x)) {
+ if (x > 0.0)
+ return log10(x);
+ errno = EDOM;
+ if (x == 0.0)
+ return -Py_HUGE_VAL; /* log10(0) = -inf */
+ else
+ return Py_NAN; /* log10(-ve) = nan */
+ }
+ else if (Py_IS_NAN(x))
+ return x; /* log10(nan) = nan */
+ else if (x > 0.0)
+ return x; /* log10(inf) = inf */
+ else {
+ errno = EDOM;
+ return Py_NAN; /* log10(-inf) = nan */
+ }
}
@@ -606,37 +606,37 @@
static int
is_error(double x)
{
- int result = 1; /* presumption of guilt */
- assert(errno); /* non-zero errno is a precondition for calling */
- if (errno == EDOM)
- PyErr_SetString(PyExc_ValueError, "math domain error");
+ int result = 1; /* presumption of guilt */
+ assert(errno); /* non-zero errno is a precondition for calling */
+ if (errno == EDOM)
+ 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.
- * Alas, C99 never requires that errno be set.
- * 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).
- *
- * On some platforms (Ubuntu/ia64) it seems that errno can be
- * set to ERANGE for subnormal results that do *not* underflow
- * to zero. So to be safe, we'll ignore ERANGE whenever the
- * function result is less than one in absolute value.
- */
- if (fabs(x) < 1.0)
- result = 0;
- else
- PyErr_SetString(PyExc_OverflowError,
- "math range error");
- }
- else
- /* Unexpected math error */
- PyErr_SetFromErrno(PyExc_ValueError);
- return result;
+ 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.
+ * Alas, C99 never requires that errno be set.
+ * 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).
+ *
+ * On some platforms (Ubuntu/ia64) it seems that errno can be
+ * set to ERANGE for subnormal results that do *not* underflow
+ * to zero. So to be safe, we'll ignore ERANGE whenever the
+ * function result is less than one in absolute value.
+ */
+ if (fabs(x) < 1.0)
+ result = 0;
+ else
+ PyErr_SetString(PyExc_OverflowError,
+ "math range error");
+ }
+ else
+ /* Unexpected math error */
+ PyErr_SetFromErrno(PyExc_ValueError);
+ return result;
}
/*
@@ -672,30 +672,30 @@
static PyObject *
math_1(PyObject *arg, double (*func) (double), int can_overflow)
{
- double x, r;
- x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- errno = 0;
- PyFPE_START_PROTECT("in math_1", return 0);
- r = (*func)(x);
- PyFPE_END_PROTECT(r);
- if (Py_IS_NAN(r)) {
- if (!Py_IS_NAN(x))
- errno = EDOM;
- else
- errno = 0;
- }
- else if (Py_IS_INFINITY(r)) {
- if (Py_IS_FINITE(x))
- errno = can_overflow ? ERANGE : EDOM;
- else
- errno = 0;
- }
- if (errno && is_error(r))
- return NULL;
- else
- return PyFloat_FromDouble(r);
+ double x, r;
+ x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ errno = 0;
+ PyFPE_START_PROTECT("in math_1", return 0);
+ r = (*func)(x);
+ PyFPE_END_PROTECT(r);
+ if (Py_IS_NAN(r)) {
+ if (!Py_IS_NAN(x))
+ errno = EDOM;
+ else
+ errno = 0;
+ }
+ else if (Py_IS_INFINITY(r)) {
+ if (Py_IS_FINITE(x))
+ errno = can_overflow ? ERANGE : EDOM;
+ else
+ errno = 0;
+ }
+ if (errno && is_error(r))
+ return NULL;
+ else
+ return PyFloat_FromDouble(r);
}
/* variant of math_1, to be used when the function being wrapped is known to
@@ -705,17 +705,17 @@
static PyObject *
math_1a(PyObject *arg, double (*func) (double))
{
- double x, r;
- x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- errno = 0;
- PyFPE_START_PROTECT("in math_1a", return 0);
- r = (*func)(x);
- PyFPE_END_PROTECT(r);
- if (errno && is_error(r))
- return NULL;
- return PyFloat_FromDouble(r);
+ double x, r;
+ x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ errno = 0;
+ PyFPE_START_PROTECT("in math_1a", return 0);
+ r = (*func)(x);
+ PyFPE_END_PROTECT(r);
+ if (errno && is_error(r))
+ return NULL;
+ return PyFloat_FromDouble(r);
}
/*
@@ -748,53 +748,53 @@
static PyObject *
math_2(PyObject *args, double (*func) (double, double), char *funcname)
{
- PyObject *ox, *oy;
- double x, y, r;
- if (! PyArg_UnpackTuple(args, funcname, 2, 2, &ox, &oy))
- return NULL;
- x = PyFloat_AsDouble(ox);
- y = PyFloat_AsDouble(oy);
- if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
- return NULL;
- errno = 0;
- PyFPE_START_PROTECT("in math_2", return 0);
- r = (*func)(x, y);
- PyFPE_END_PROTECT(r);
- if (Py_IS_NAN(r)) {
- if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
- errno = EDOM;
- else
- errno = 0;
- }
- else if (Py_IS_INFINITY(r)) {
- if (Py_IS_FINITE(x) && Py_IS_FINITE(y))
- errno = ERANGE;
- else
- errno = 0;
- }
- if (errno && is_error(r))
- return NULL;
- else
- return PyFloat_FromDouble(r);
+ PyObject *ox, *oy;
+ double x, y, r;
+ if (! PyArg_UnpackTuple(args, funcname, 2, 2, &ox, &oy))
+ return NULL;
+ x = PyFloat_AsDouble(ox);
+ y = PyFloat_AsDouble(oy);
+ if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
+ return NULL;
+ errno = 0;
+ PyFPE_START_PROTECT("in math_2", return 0);
+ r = (*func)(x, y);
+ PyFPE_END_PROTECT(r);
+ if (Py_IS_NAN(r)) {
+ if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
+ errno = EDOM;
+ else
+ errno = 0;
+ }
+ else if (Py_IS_INFINITY(r)) {
+ if (Py_IS_FINITE(x) && Py_IS_FINITE(y))
+ errno = ERANGE;
+ else
+ errno = 0;
+ }
+ if (errno && is_error(r))
+ return NULL;
+ else
+ return PyFloat_FromDouble(r);
}
-#define FUNC1(funcname, func, can_overflow, docstring) \
- static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
- return math_1(args, func, can_overflow); \
- }\
- PyDoc_STRVAR(math_##funcname##_doc, docstring);
+#define FUNC1(funcname, func, can_overflow, docstring) \
+ static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
+ return math_1(args, func, can_overflow); \
+ }\
+ PyDoc_STRVAR(math_##funcname##_doc, docstring);
-#define FUNC1A(funcname, func, docstring) \
- static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
- return math_1a(args, func); \
- }\
- PyDoc_STRVAR(math_##funcname##_doc, docstring);
+#define FUNC1A(funcname, func, docstring) \
+ static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
+ return math_1a(args, func); \
+ }\
+ PyDoc_STRVAR(math_##funcname##_doc, docstring);
#define FUNC2(funcname, func, docstring) \
- static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
- return math_2(args, func, #funcname); \
- }\
- PyDoc_STRVAR(math_##funcname##_doc, docstring);
+ static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
+ return math_2(args, func, #funcname); \
+ }\
+ PyDoc_STRVAR(math_##funcname##_doc, docstring);
FUNC1(acos, acos, 0,
"acos(x)\n\nReturn the arc cosine (measured in radians) of x.")
@@ -873,7 +873,7 @@
Also, the volatile declaration forces the values to be stored in memory as
regular doubles instead of extended long precision (80-bit) values. This
prevents double rounding because any addition or subtraction of two doubles
- can be resolved exactly into double-sized hi and lo values. As long as the
+ can be resolved exactly into double-sized hi and lo values. As long as the
hi value gets forced into a double before yr and lo are computed, the extra
bits in downstream extended precision operations (x87 for example) will be
exactly zero and therefore can be losslessly stored back into a double,
@@ -896,27 +896,27 @@
_fsum_realloc(double **p_ptr, Py_ssize_t n,
double *ps, Py_ssize_t *m_ptr)
{
- void *v = NULL;
- Py_ssize_t m = *m_ptr;
+ void *v = NULL;
+ Py_ssize_t m = *m_ptr;
- m += m; /* double */
- if (n < m && m < (PY_SSIZE_T_MAX / sizeof(double))) {
- double *p = *p_ptr;
- if (p == ps) {
- v = PyMem_Malloc(sizeof(double) * m);
- if (v != NULL)
- memcpy(v, ps, sizeof(double) * n);
- }
- else
- v = PyMem_Realloc(p, sizeof(double) * m);
- }
- if (v == NULL) { /* size overflow or no memory */
- PyErr_SetString(PyExc_MemoryError, "math.fsum partials");
- return 1;
- }
- *p_ptr = (double*) v;
- *m_ptr = m;
- return 0;
+ m += m; /* double */
+ if (n < m && m < (PY_SSIZE_T_MAX / sizeof(double))) {
+ double *p = *p_ptr;
+ if (p == ps) {
+ v = PyMem_Malloc(sizeof(double) * m);
+ if (v != NULL)
+ memcpy(v, ps, sizeof(double) * n);
+ }
+ else
+ v = PyMem_Realloc(p, sizeof(double) * m);
+ }
+ if (v == NULL) { /* size overflow or no memory */
+ PyErr_SetString(PyExc_MemoryError, "math.fsum partials");
+ return 1;
+ }
+ *p_ptr = (double*) v;
+ *m_ptr = m;
+ return 0;
}
/* Full precision summation of a sequence of floats.
@@ -924,17 +924,17 @@
def msum(iterable):
partials = [] # sorted, non-overlapping partial sums
for x in iterable:
- i = 0
- for y in partials:
- if abs(x) < abs(y):
- x, y = y, x
- hi = x + y
- lo = y - (hi - x)
- if lo:
- partials[i] = lo
- i += 1
- x = hi
- partials[i:] = [x]
+ i = 0
+ for y in partials:
+ if abs(x) < abs(y):
+ x, y = y, x
+ hi = x + y
+ lo = y - (hi - x)
+ if lo:
+ partials[i] = lo
+ i += 1
+ x = hi
+ partials[i:] = [x]
return sum_exact(partials)
Rounded x+y stored in hi with the roundoff stored in lo. Together hi+lo
@@ -952,119 +952,119 @@
static PyObject*
math_fsum(PyObject *self, PyObject *seq)
{
- PyObject *item, *iter, *sum = NULL;
- Py_ssize_t i, j, n = 0, m = NUM_PARTIALS;
- double x, y, t, ps[NUM_PARTIALS], *p = ps;
- double xsave, special_sum = 0.0, inf_sum = 0.0;
- volatile double hi, yr, lo;
+ PyObject *item, *iter, *sum = NULL;
+ Py_ssize_t i, j, n = 0, m = NUM_PARTIALS;
+ double x, y, t, ps[NUM_PARTIALS], *p = ps;
+ double xsave, special_sum = 0.0, inf_sum = 0.0;
+ volatile double hi, yr, lo;
- iter = PyObject_GetIter(seq);
- if (iter == NULL)
- return NULL;
+ iter = PyObject_GetIter(seq);
+ if (iter == NULL)
+ return NULL;
- PyFPE_START_PROTECT("fsum", Py_DECREF(iter); return NULL)
+ PyFPE_START_PROTECT("fsum", Py_DECREF(iter); return NULL)
- for(;;) { /* for x in iterable */
- assert(0 <= n && n <= m);
- assert((m == NUM_PARTIALS && p == ps) ||
- (m > NUM_PARTIALS && p != NULL));
+ for(;;) { /* for x in iterable */
+ assert(0 <= n && n <= m);
+ assert((m == NUM_PARTIALS && p == ps) ||
+ (m > NUM_PARTIALS && p != NULL));
- item = PyIter_Next(iter);
- if (item == NULL) {
- if (PyErr_Occurred())
- goto _fsum_error;
- break;
- }
- x = PyFloat_AsDouble(item);
- Py_DECREF(item);
- if (PyErr_Occurred())
- goto _fsum_error;
+ item = PyIter_Next(iter);
+ if (item == NULL) {
+ if (PyErr_Occurred())
+ goto _fsum_error;
+ break;
+ }
+ x = PyFloat_AsDouble(item);
+ Py_DECREF(item);
+ if (PyErr_Occurred())
+ goto _fsum_error;
- xsave = x;
- for (i = j = 0; j < n; j++) { /* for y in partials */
- y = p[j];
- if (fabs(x) < fabs(y)) {
- t = x; x = y; y = t;
- }
- hi = x + y;
- yr = hi - x;
- lo = y - yr;
- if (lo != 0.0)
- p[i++] = lo;
- x = hi;
- }
+ xsave = x;
+ for (i = j = 0; j < n; j++) { /* for y in partials */
+ y = p[j];
+ if (fabs(x) < fabs(y)) {
+ t = x; x = y; y = t;
+ }
+ hi = x + y;
+ yr = hi - x;
+ lo = y - yr;
+ if (lo != 0.0)
+ p[i++] = lo;
+ x = hi;
+ }
- n = i; /* ps[i:] = [x] */
- if (x != 0.0) {
- if (! Py_IS_FINITE(x)) {
- /* a nonfinite x could arise either as
- a result of intermediate overflow, or
- as a result of a nan or inf in the
- summands */
- if (Py_IS_FINITE(xsave)) {
- PyErr_SetString(PyExc_OverflowError,
- "intermediate overflow in fsum");
- goto _fsum_error;
- }
- if (Py_IS_INFINITY(xsave))
- inf_sum += xsave;
- special_sum += xsave;
- /* reset partials */
- n = 0;
- }
- else if (n >= m && _fsum_realloc(&p, n, ps, &m))
- goto _fsum_error;
- else
- p[n++] = x;
- }
- }
+ n = i; /* ps[i:] = [x] */
+ if (x != 0.0) {
+ if (! Py_IS_FINITE(x)) {
+ /* a nonfinite x could arise either as
+ a result of intermediate overflow, or
+ as a result of a nan or inf in the
+ summands */
+ if (Py_IS_FINITE(xsave)) {
+ PyErr_SetString(PyExc_OverflowError,
+ "intermediate overflow in fsum");
+ goto _fsum_error;
+ }
+ if (Py_IS_INFINITY(xsave))
+ inf_sum += xsave;
+ special_sum += xsave;
+ /* reset partials */
+ n = 0;
+ }
+ else if (n >= m && _fsum_realloc(&p, n, ps, &m))
+ goto _fsum_error;
+ else
+ p[n++] = x;
+ }
+ }
- if (special_sum != 0.0) {
- if (Py_IS_NAN(inf_sum))
- PyErr_SetString(PyExc_ValueError,
- "-inf + inf in fsum");
- else
- sum = PyFloat_FromDouble(special_sum);
- goto _fsum_error;
- }
+ if (special_sum != 0.0) {
+ if (Py_IS_NAN(inf_sum))
+ PyErr_SetString(PyExc_ValueError,
+ "-inf + inf in fsum");
+ else
+ sum = PyFloat_FromDouble(special_sum);
+ goto _fsum_error;
+ }
- hi = 0.0;
- if (n > 0) {
- hi = p[--n];
- /* sum_exact(ps, hi) from the top, stop when the sum becomes
- inexact. */
- while (n > 0) {
- x = hi;
- y = p[--n];
- assert(fabs(y) < fabs(x));
- hi = x + y;
- yr = hi - x;
- lo = y - yr;
- if (lo != 0.0)
- break;
- }
- /* Make half-even rounding work across multiple partials.
- Needed so that sum([1e-16, 1, 1e16]) will round-up the last
- digit to two instead of down to zero (the 1e-16 makes the 1
- slightly closer to two). With a potential 1 ULP rounding
- error fixed-up, math.fsum() can guarantee commutativity. */
- if (n > 0 && ((lo < 0.0 && p[n-1] < 0.0) ||
- (lo > 0.0 && p[n-1] > 0.0))) {
- y = lo * 2.0;
- x = hi + y;
- yr = x - hi;
- if (y == yr)
- hi = x;
- }
- }
- sum = PyFloat_FromDouble(hi);
+ hi = 0.0;
+ if (n > 0) {
+ hi = p[--n];
+ /* sum_exact(ps, hi) from the top, stop when the sum becomes
+ inexact. */
+ while (n > 0) {
+ x = hi;
+ y = p[--n];
+ assert(fabs(y) < fabs(x));
+ hi = x + y;
+ yr = hi - x;
+ lo = y - yr;
+ if (lo != 0.0)
+ break;
+ }
+ /* Make half-even rounding work across multiple partials.
+ Needed so that sum([1e-16, 1, 1e16]) will round-up the last
+ digit to two instead of down to zero (the 1e-16 makes the 1
+ slightly closer to two). With a potential 1 ULP rounding
+ error fixed-up, math.fsum() can guarantee commutativity. */
+ if (n > 0 && ((lo < 0.0 && p[n-1] < 0.0) ||
+ (lo > 0.0 && p[n-1] > 0.0))) {
+ y = lo * 2.0;
+ x = hi + y;
+ yr = x - hi;
+ if (y == yr)
+ hi = x;
+ }
+ }
+ sum = PyFloat_FromDouble(hi);
_fsum_error:
- PyFPE_END_PROTECT(hi)
- Py_DECREF(iter);
- if (p != ps)
- PyMem_Free(p);
- return sum;
+ PyFPE_END_PROTECT(hi)
+ Py_DECREF(iter);
+ if (p != ps)
+ PyMem_Free(p);
+ return sum;
}
#undef NUM_PARTIALS
@@ -1077,53 +1077,53 @@
static PyObject *
math_factorial(PyObject *self, PyObject *arg)
{
- long i, x;
- PyObject *result, *iobj, *newresult;
+ long i, x;
+ PyObject *result, *iobj, *newresult;
- if (PyFloat_Check(arg)) {
- PyObject *lx;
- double dx = PyFloat_AS_DOUBLE((PyFloatObject *)arg);
- if (!(Py_IS_FINITE(dx) && dx == floor(dx))) {
- PyErr_SetString(PyExc_ValueError,
- "factorial() only accepts integral values");
- return NULL;
- }
- lx = PyLong_FromDouble(dx);
- if (lx == NULL)
- return NULL;
- x = PyLong_AsLong(lx);
- Py_DECREF(lx);
- }
- else
- x = PyInt_AsLong(arg);
+ if (PyFloat_Check(arg)) {
+ PyObject *lx;
+ double dx = PyFloat_AS_DOUBLE((PyFloatObject *)arg);
+ if (!(Py_IS_FINITE(dx) && dx == floor(dx))) {
+ PyErr_SetString(PyExc_ValueError,
+ "factorial() only accepts integral values");
+ return NULL;
+ }
+ lx = PyLong_FromDouble(dx);
+ if (lx == NULL)
+ return NULL;
+ x = PyLong_AsLong(lx);
+ Py_DECREF(lx);
+ }
+ else
+ x = PyInt_AsLong(arg);
- if (x == -1 && PyErr_Occurred())
- return NULL;
- if (x < 0) {
- PyErr_SetString(PyExc_ValueError,
- "factorial() not defined for negative values");
- return NULL;
- }
+ if (x == -1 && PyErr_Occurred())
+ return NULL;
+ if (x < 0) {
+ PyErr_SetString(PyExc_ValueError,
+ "factorial() not defined for negative values");
+ return NULL;
+ }
- result = (PyObject *)PyInt_FromLong(1);
- if (result == NULL)
- return NULL;
- for (i=1 ; i<=x ; i++) {
- iobj = (PyObject *)PyInt_FromLong(i);
- if (iobj == NULL)
- goto error;
- newresult = PyNumber_Multiply(result, iobj);
- Py_DECREF(iobj);
- if (newresult == NULL)
- goto error;
- Py_DECREF(result);
- result = newresult;
- }
- return result;
+ result = (PyObject *)PyInt_FromLong(1);
+ if (result == NULL)
+ return NULL;
+ for (i=1 ; i<=x ; i++) {
+ iobj = (PyObject *)PyInt_FromLong(i);
+ if (iobj == NULL)
+ goto error;
+ newresult = PyNumber_Multiply(result, iobj);
+ Py_DECREF(iobj);
+ if (newresult == NULL)
+ goto error;
+ Py_DECREF(result);
+ result = newresult;
+ }
+ return result;
error:
- Py_DECREF(result);
- return NULL;
+ Py_DECREF(result);
+ return NULL;
}
PyDoc_STRVAR(math_factorial_doc,
@@ -1134,7 +1134,7 @@
static PyObject *
math_trunc(PyObject *self, PyObject *number)
{
- return PyObject_CallMethod(number, "__trunc__", NULL);
+ return PyObject_CallMethod(number, "__trunc__", NULL);
}
PyDoc_STRVAR(math_trunc_doc,
@@ -1145,21 +1145,21 @@
static PyObject *
math_frexp(PyObject *self, PyObject *arg)
{
- int i;
- double x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- /* deal with special cases directly, to sidestep platform
- differences */
- if (Py_IS_NAN(x) || Py_IS_INFINITY(x) || !x) {
- i = 0;
- }
- else {
- PyFPE_START_PROTECT("in math_frexp", return 0);
- x = frexp(x, &i);
- PyFPE_END_PROTECT(x);
- }
- return Py_BuildValue("(di)", x, i);
+ int i;
+ double x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ /* deal with special cases directly, to sidestep platform
+ differences */
+ if (Py_IS_NAN(x) || Py_IS_INFINITY(x) || !x) {
+ i = 0;
+ }
+ else {
+ PyFPE_START_PROTECT("in math_frexp", return 0);
+ x = frexp(x, &i);
+ PyFPE_END_PROTECT(x);
+ }
+ return Py_BuildValue("(di)", x, i);
}
PyDoc_STRVAR(math_frexp_doc,
@@ -1172,53 +1172,53 @@
static PyObject *
math_ldexp(PyObject *self, PyObject *args)
{
- double x, r;
- PyObject *oexp;
- long exp;
- int overflow;
- if (! PyArg_ParseTuple(args, "dO:ldexp", &x, &oexp))
- return NULL;
+ double x, r;
+ PyObject *oexp;
+ long exp;
+ int overflow;
+ if (! PyArg_ParseTuple(args, "dO:ldexp", &x, &oexp))
+ return NULL;
- if (PyLong_Check(oexp) || PyInt_Check(oexp)) {
- /* on overflow, replace exponent with either LONG_MAX
- or LONG_MIN, depending on the sign. */
- exp = PyLong_AsLongAndOverflow(oexp, &overflow);
- if (exp == -1 && PyErr_Occurred())
- return NULL;
- if (overflow)
- exp = overflow < 0 ? LONG_MIN : LONG_MAX;
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "Expected an int or long as second argument "
- "to ldexp.");
- return NULL;
- }
+ if (PyLong_Check(oexp) || PyInt_Check(oexp)) {
+ /* on overflow, replace exponent with either LONG_MAX
+ or LONG_MIN, depending on the sign. */
+ exp = PyLong_AsLongAndOverflow(oexp, &overflow);
+ if (exp == -1 && PyErr_Occurred())
+ return NULL;
+ if (overflow)
+ exp = overflow < 0 ? LONG_MIN : LONG_MAX;
+ }
+ 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 (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;
- return PyFloat_FromDouble(r);
+ if (errno && is_error(r))
+ return NULL;
+ return PyFloat_FromDouble(r);
}
PyDoc_STRVAR(math_ldexp_doc,
@@ -1228,23 +1228,23 @@
static PyObject *
math_modf(PyObject *self, PyObject *arg)
{
- double y, x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- /* some platforms don't do the right thing for NaNs and
- infinities, so we take care of special cases directly. */
- if (!Py_IS_FINITE(x)) {
- if (Py_IS_INFINITY(x))
- return Py_BuildValue("(dd)", copysign(0., x), x);
- else if (Py_IS_NAN(x))
- return Py_BuildValue("(dd)", x, x);
- }
+ double y, x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ /* some platforms don't do the right thing for NaNs and
+ infinities, so we take care of special cases directly. */
+ if (!Py_IS_FINITE(x)) {
+ if (Py_IS_INFINITY(x))
+ return Py_BuildValue("(dd)", copysign(0., x), x);
+ else if (Py_IS_NAN(x))
+ return Py_BuildValue("(dd)", x, x);
+ }
- errno = 0;
- PyFPE_START_PROTECT("in math_modf", return 0);
- x = modf(x, &y);
- PyFPE_END_PROTECT(x);
- return Py_BuildValue("(dd)", x, y);
+ errno = 0;
+ PyFPE_START_PROTECT("in math_modf", return 0);
+ x = modf(x, &y);
+ PyFPE_END_PROTECT(x);
+ return Py_BuildValue("(dd)", x, y);
}
PyDoc_STRVAR(math_modf_doc,
@@ -1265,56 +1265,56 @@
static PyObject*
loghelper(PyObject* arg, double (*func)(double), char *funcname)
{
- /* If it is long, do it ourselves. */
- if (PyLong_Check(arg)) {
- double x;
- Py_ssize_t e;
- x = _PyLong_Frexp((PyLongObject *)arg, &e);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- if (x <= 0.0) {
- PyErr_SetString(PyExc_ValueError,
- "math domain error");
- return NULL;
- }
- /* Special case for log(1), to make sure we get an
- exact result there. */
- if (e == 1 && x == 0.5)
- return PyFloat_FromDouble(0.0);
- /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
- x = func(x) + func(2.0) * e;
- return PyFloat_FromDouble(x);
- }
+ /* If it is long, do it ourselves. */
+ if (PyLong_Check(arg)) {
+ double x;
+ Py_ssize_t e;
+ x = _PyLong_Frexp((PyLongObject *)arg, &e);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ if (x <= 0.0) {
+ PyErr_SetString(PyExc_ValueError,
+ "math domain error");
+ return NULL;
+ }
+ /* Special case for log(1), to make sure we get an
+ exact result there. */
+ if (e == 1 && x == 0.5)
+ return PyFloat_FromDouble(0.0);
+ /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
+ x = func(x) + func(2.0) * e;
+ return PyFloat_FromDouble(x);
+ }
- /* Else let libm handle it by itself. */
- return math_1(arg, func, 0);
+ /* Else let libm handle it by itself. */
+ return math_1(arg, func, 0);
}
static PyObject *
math_log(PyObject *self, PyObject *args)
{
- PyObject *arg;
- PyObject *base = NULL;
- PyObject *num, *den;
- PyObject *ans;
+ PyObject *arg;
+ PyObject *base = NULL;
+ PyObject *num, *den;
+ PyObject *ans;
- if (!PyArg_UnpackTuple(args, "log", 1, 2, &arg, &base))
- return NULL;
+ if (!PyArg_UnpackTuple(args, "log", 1, 2, &arg, &base))
+ return NULL;
- num = loghelper(arg, m_log, "log");
- if (num == NULL || base == NULL)
- return num;
+ num = loghelper(arg, m_log, "log");
+ if (num == NULL || base == NULL)
+ return num;
- den = loghelper(base, m_log, "log");
- if (den == NULL) {
- Py_DECREF(num);
- return NULL;
- }
+ den = loghelper(base, m_log, "log");
+ if (den == NULL) {
+ Py_DECREF(num);
+ return NULL;
+ }
- ans = PyNumber_Divide(num, den);
- Py_DECREF(num);
- Py_DECREF(den);
- return ans;
+ ans = PyNumber_Divide(num, den);
+ Py_DECREF(num);
+ Py_DECREF(den);
+ return ans;
}
PyDoc_STRVAR(math_log_doc,
@@ -1325,7 +1325,7 @@
static PyObject *
math_log10(PyObject *self, PyObject *arg)
{
- return loghelper(arg, m_log10, "log10");
+ return loghelper(arg, m_log10, "log10");
}
PyDoc_STRVAR(math_log10_doc,
@@ -1334,31 +1334,31 @@
static PyObject *
math_fmod(PyObject *self, PyObject *args)
{
- PyObject *ox, *oy;
- double r, x, y;
- if (! PyArg_UnpackTuple(args, "fmod", 2, 2, &ox, &oy))
- return NULL;
- x = PyFloat_AsDouble(ox);
- y = PyFloat_AsDouble(oy);
- if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
- return NULL;
- /* fmod(x, +/-Inf) returns x for finite x. */
- if (Py_IS_INFINITY(y) && Py_IS_FINITE(x))
- return PyFloat_FromDouble(x);
- errno = 0;
- PyFPE_START_PROTECT("in math_fmod", return 0);
- r = fmod(x, y);
- PyFPE_END_PROTECT(r);
- if (Py_IS_NAN(r)) {
- if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
- errno = EDOM;
- else
- errno = 0;
- }
- if (errno && is_error(r))
- return NULL;
- else
- return PyFloat_FromDouble(r);
+ PyObject *ox, *oy;
+ double r, x, y;
+ if (! PyArg_UnpackTuple(args, "fmod", 2, 2, &ox, &oy))
+ return NULL;
+ x = PyFloat_AsDouble(ox);
+ y = PyFloat_AsDouble(oy);
+ if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
+ return NULL;
+ /* fmod(x, +/-Inf) returns x for finite x. */
+ if (Py_IS_INFINITY(y) && Py_IS_FINITE(x))
+ return PyFloat_FromDouble(x);
+ errno = 0;
+ PyFPE_START_PROTECT("in math_fmod", return 0);
+ r = fmod(x, y);
+ PyFPE_END_PROTECT(r);
+ if (Py_IS_NAN(r)) {
+ if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
+ errno = EDOM;
+ else
+ errno = 0;
+ }
+ if (errno && is_error(r))
+ return NULL;
+ else
+ return PyFloat_FromDouble(r);
}
PyDoc_STRVAR(math_fmod_doc,
@@ -1368,39 +1368,39 @@
static PyObject *
math_hypot(PyObject *self, PyObject *args)
{
- PyObject *ox, *oy;
- double r, x, y;
- if (! PyArg_UnpackTuple(args, "hypot", 2, 2, &ox, &oy))
- return NULL;
- x = PyFloat_AsDouble(ox);
- y = PyFloat_AsDouble(oy);
- if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
- return NULL;
- /* hypot(x, +/-Inf) returns Inf, even if x is a NaN. */
- if (Py_IS_INFINITY(x))
- return PyFloat_FromDouble(fabs(x));
- if (Py_IS_INFINITY(y))
- return PyFloat_FromDouble(fabs(y));
- errno = 0;
- PyFPE_START_PROTECT("in math_hypot", return 0);
- r = hypot(x, y);
- PyFPE_END_PROTECT(r);
- if (Py_IS_NAN(r)) {
- if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
- errno = EDOM;
- else
- errno = 0;
- }
- else if (Py_IS_INFINITY(r)) {
- if (Py_IS_FINITE(x) && Py_IS_FINITE(y))
- errno = ERANGE;
- else
- errno = 0;
- }
- if (errno && is_error(r))
- return NULL;
- else
- return PyFloat_FromDouble(r);
+ PyObject *ox, *oy;
+ double r, x, y;
+ if (! PyArg_UnpackTuple(args, "hypot", 2, 2, &ox, &oy))
+ return NULL;
+ x = PyFloat_AsDouble(ox);
+ y = PyFloat_AsDouble(oy);
+ if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
+ return NULL;
+ /* hypot(x, +/-Inf) returns Inf, even if x is a NaN. */
+ if (Py_IS_INFINITY(x))
+ return PyFloat_FromDouble(fabs(x));
+ if (Py_IS_INFINITY(y))
+ return PyFloat_FromDouble(fabs(y));
+ errno = 0;
+ PyFPE_START_PROTECT("in math_hypot", return 0);
+ r = hypot(x, y);
+ PyFPE_END_PROTECT(r);
+ if (Py_IS_NAN(r)) {
+ if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
+ errno = EDOM;
+ else
+ errno = 0;
+ }
+ else if (Py_IS_INFINITY(r)) {
+ if (Py_IS_FINITE(x) && Py_IS_FINITE(y))
+ errno = ERANGE;
+ else
+ errno = 0;
+ }
+ if (errno && is_error(r))
+ return NULL;
+ else
+ return PyFloat_FromDouble(r);
}
PyDoc_STRVAR(math_hypot_doc,
@@ -1415,79 +1415,79 @@
static PyObject *
math_pow(PyObject *self, PyObject *args)
{
- PyObject *ox, *oy;
- double r, x, y;
- int odd_y;
+ PyObject *ox, *oy;
+ double r, x, y;
+ int odd_y;
- if (! PyArg_UnpackTuple(args, "pow", 2, 2, &ox, &oy))
- return NULL;
- x = PyFloat_AsDouble(ox);
- y = PyFloat_AsDouble(oy);
- if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
- return NULL;
+ if (! PyArg_UnpackTuple(args, "pow", 2, 2, &ox, &oy))
+ return NULL;
+ x = PyFloat_AsDouble(ox);
+ y = PyFloat_AsDouble(oy);
+ if ((x == -1.0 || y == -1.0) && PyErr_Occurred())
+ return NULL;
- /* deal directly with IEEE specials, to cope with problems on various
- platforms whose semantics don't exactly match C99 */
- r = 0.; /* silence compiler warning */
- if (!Py_IS_FINITE(x) || !Py_IS_FINITE(y)) {
- errno = 0;
- if (Py_IS_NAN(x))
- r = y == 0. ? 1. : x; /* NaN**0 = 1 */
- else if (Py_IS_NAN(y))
- r = x == 1. ? 1. : y; /* 1**NaN = 1 */
- else if (Py_IS_INFINITY(x)) {
- odd_y = Py_IS_FINITE(y) && fmod(fabs(y), 2.0) == 1.0;
- if (y > 0.)
- r = odd_y ? x : fabs(x);
- else if (y == 0.)
- r = 1.;
- else /* y < 0. */
- r = odd_y ? copysign(0., x) : 0.;
- }
- else if (Py_IS_INFINITY(y)) {
- if (fabs(x) == 1.0)
- r = 1.;
- else if (y > 0. && fabs(x) > 1.0)
- r = y;
- else if (y < 0. && fabs(x) < 1.0) {
- r = -y; /* result is +inf */
- if (x == 0.) /* 0**-inf: divide-by-zero */
- errno = EDOM;
- }
- else
- r = 0.;
- }
- }
- else {
- /* let libm handle finite**finite */
- errno = 0;
- PyFPE_START_PROTECT("in math_pow", return 0);
- r = pow(x, y);
- PyFPE_END_PROTECT(r);
- /* a NaN result should arise only from (-ve)**(finite
- non-integer); in this case we want to raise ValueError. */
- if (!Py_IS_FINITE(r)) {
- if (Py_IS_NAN(r)) {
- errno = EDOM;
- }
- /*
- an infinite result here arises either from:
- (A) (+/-0.)**negative (-> divide-by-zero)
- (B) overflow of x**y with x and y finite
- */
- else if (Py_IS_INFINITY(r)) {
- if (x == 0.)
- errno = EDOM;
- else
- errno = ERANGE;
- }
- }
- }
+ /* deal directly with IEEE specials, to cope with problems on various
+ platforms whose semantics don't exactly match C99 */
+ r = 0.; /* silence compiler warning */
+ if (!Py_IS_FINITE(x) || !Py_IS_FINITE(y)) {
+ errno = 0;
+ if (Py_IS_NAN(x))
+ r = y == 0. ? 1. : x; /* NaN**0 = 1 */
+ else if (Py_IS_NAN(y))
+ r = x == 1. ? 1. : y; /* 1**NaN = 1 */
+ else if (Py_IS_INFINITY(x)) {
+ odd_y = Py_IS_FINITE(y) && fmod(fabs(y), 2.0) == 1.0;
+ if (y > 0.)
+ r = odd_y ? x : fabs(x);
+ else if (y == 0.)
+ r = 1.;
+ else /* y < 0. */
+ r = odd_y ? copysign(0., x) : 0.;
+ }
+ else if (Py_IS_INFINITY(y)) {
+ if (fabs(x) == 1.0)
+ r = 1.;
+ else if (y > 0. && fabs(x) > 1.0)
+ r = y;
+ else if (y < 0. && fabs(x) < 1.0) {
+ r = -y; /* result is +inf */
+ if (x == 0.) /* 0**-inf: divide-by-zero */
+ errno = EDOM;
+ }
+ else
+ r = 0.;
+ }
+ }
+ else {
+ /* let libm handle finite**finite */
+ errno = 0;
+ PyFPE_START_PROTECT("in math_pow", return 0);
+ r = pow(x, y);
+ PyFPE_END_PROTECT(r);
+ /* a NaN result should arise only from (-ve)**(finite
+ non-integer); in this case we want to raise ValueError. */
+ if (!Py_IS_FINITE(r)) {
+ if (Py_IS_NAN(r)) {
+ errno = EDOM;
+ }
+ /*
+ an infinite result here arises either from:
+ (A) (+/-0.)**negative (-> divide-by-zero)
+ (B) overflow of x**y with x and y finite
+ */
+ else if (Py_IS_INFINITY(r)) {
+ if (x == 0.)
+ errno = EDOM;
+ else
+ errno = ERANGE;
+ }
+ }
+ }
- if (errno && is_error(r))
- return NULL;
- else
- return PyFloat_FromDouble(r);
+ if (errno && is_error(r))
+ return NULL;
+ else
+ return PyFloat_FromDouble(r);
}
PyDoc_STRVAR(math_pow_doc,
@@ -1499,10 +1499,10 @@
static PyObject *
math_degrees(PyObject *self, PyObject *arg)
{
- double x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- return PyFloat_FromDouble(x * radToDeg);
+ double x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ return PyFloat_FromDouble(x * radToDeg);
}
PyDoc_STRVAR(math_degrees_doc,
@@ -1512,10 +1512,10 @@
static PyObject *
math_radians(PyObject *self, PyObject *arg)
{
- double x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- return PyFloat_FromDouble(x * degToRad);
+ double x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ return PyFloat_FromDouble(x * degToRad);
}
PyDoc_STRVAR(math_radians_doc,
@@ -1525,10 +1525,10 @@
static PyObject *
math_isnan(PyObject *self, PyObject *arg)
{
- double x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- return PyBool_FromLong((long)Py_IS_NAN(x));
+ double x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ return PyBool_FromLong((long)Py_IS_NAN(x));
}
PyDoc_STRVAR(math_isnan_doc,
@@ -1538,10 +1538,10 @@
static PyObject *
math_isinf(PyObject *self, PyObject *arg)
{
- double x = PyFloat_AsDouble(arg);
- if (x == -1.0 && PyErr_Occurred())
- return NULL;
- return PyBool_FromLong((long)Py_IS_INFINITY(x));
+ double x = PyFloat_AsDouble(arg);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ return PyBool_FromLong((long)Py_IS_INFINITY(x));
}
PyDoc_STRVAR(math_isinf_doc,
@@ -1549,47 +1549,47 @@
Check if float x is infinite (positive or negative).");
static PyMethodDef math_methods[] = {
- {"acos", math_acos, METH_O, math_acos_doc},
- {"acosh", math_acosh, METH_O, math_acosh_doc},
- {"asin", math_asin, METH_O, math_asin_doc},
- {"asinh", math_asinh, METH_O, math_asinh_doc},
- {"atan", math_atan, METH_O, math_atan_doc},
- {"atan2", math_atan2, METH_VARARGS, math_atan2_doc},
- {"atanh", math_atanh, METH_O, math_atanh_doc},
- {"ceil", math_ceil, METH_O, math_ceil_doc},
- {"copysign", math_copysign, METH_VARARGS, math_copysign_doc},
- {"cos", math_cos, METH_O, math_cos_doc},
- {"cosh", math_cosh, METH_O, math_cosh_doc},
- {"degrees", math_degrees, METH_O, math_degrees_doc},
- {"erf", math_erf, METH_O, math_erf_doc},
- {"erfc", math_erfc, METH_O, math_erfc_doc},
- {"exp", math_exp, METH_O, math_exp_doc},
- {"expm1", math_expm1, METH_O, math_expm1_doc},
- {"fabs", math_fabs, METH_O, math_fabs_doc},
- {"factorial", math_factorial, METH_O, math_factorial_doc},
- {"floor", math_floor, METH_O, math_floor_doc},
- {"fmod", math_fmod, METH_VARARGS, math_fmod_doc},
- {"frexp", math_frexp, METH_O, math_frexp_doc},
- {"fsum", math_fsum, METH_O, math_fsum_doc},
- {"gamma", math_gamma, METH_O, math_gamma_doc},
- {"hypot", math_hypot, METH_VARARGS, math_hypot_doc},
- {"isinf", math_isinf, METH_O, math_isinf_doc},
- {"isnan", math_isnan, METH_O, math_isnan_doc},
- {"ldexp", math_ldexp, METH_VARARGS, math_ldexp_doc},
- {"lgamma", math_lgamma, METH_O, math_lgamma_doc},
- {"log", math_log, METH_VARARGS, math_log_doc},
- {"log1p", math_log1p, METH_O, math_log1p_doc},
- {"log10", math_log10, METH_O, math_log10_doc},
- {"modf", math_modf, METH_O, math_modf_doc},
- {"pow", math_pow, METH_VARARGS, math_pow_doc},
- {"radians", math_radians, METH_O, math_radians_doc},
- {"sin", math_sin, METH_O, math_sin_doc},
- {"sinh", math_sinh, METH_O, math_sinh_doc},
- {"sqrt", math_sqrt, METH_O, math_sqrt_doc},
- {"tan", math_tan, METH_O, math_tan_doc},
- {"tanh", math_tanh, METH_O, math_tanh_doc},
- {"trunc", math_trunc, METH_O, math_trunc_doc},
- {NULL, NULL} /* sentinel */
+ {"acos", math_acos, METH_O, math_acos_doc},
+ {"acosh", math_acosh, METH_O, math_acosh_doc},
+ {"asin", math_asin, METH_O, math_asin_doc},
+ {"asinh", math_asinh, METH_O, math_asinh_doc},
+ {"atan", math_atan, METH_O, math_atan_doc},
+ {"atan2", math_atan2, METH_VARARGS, math_atan2_doc},
+ {"atanh", math_atanh, METH_O, math_atanh_doc},
+ {"ceil", math_ceil, METH_O, math_ceil_doc},
+ {"copysign", math_copysign, METH_VARARGS, math_copysign_doc},
+ {"cos", math_cos, METH_O, math_cos_doc},
+ {"cosh", math_cosh, METH_O, math_cosh_doc},
+ {"degrees", math_degrees, METH_O, math_degrees_doc},
+ {"erf", math_erf, METH_O, math_erf_doc},
+ {"erfc", math_erfc, METH_O, math_erfc_doc},
+ {"exp", math_exp, METH_O, math_exp_doc},
+ {"expm1", math_expm1, METH_O, math_expm1_doc},
+ {"fabs", math_fabs, METH_O, math_fabs_doc},
+ {"factorial", math_factorial, METH_O, math_factorial_doc},
+ {"floor", math_floor, METH_O, math_floor_doc},
+ {"fmod", math_fmod, METH_VARARGS, math_fmod_doc},
+ {"frexp", math_frexp, METH_O, math_frexp_doc},
+ {"fsum", math_fsum, METH_O, math_fsum_doc},
+ {"gamma", math_gamma, METH_O, math_gamma_doc},
+ {"hypot", math_hypot, METH_VARARGS, math_hypot_doc},
+ {"isinf", math_isinf, METH_O, math_isinf_doc},
+ {"isnan", math_isnan, METH_O, math_isnan_doc},
+ {"ldexp", math_ldexp, METH_VARARGS, math_ldexp_doc},
+ {"lgamma", math_lgamma, METH_O, math_lgamma_doc},
+ {"log", math_log, METH_VARARGS, math_log_doc},
+ {"log1p", math_log1p, METH_O, math_log1p_doc},
+ {"log10", math_log10, METH_O, math_log10_doc},
+ {"modf", math_modf, METH_O, math_modf_doc},
+ {"pow", math_pow, METH_VARARGS, math_pow_doc},
+ {"radians", math_radians, METH_O, math_radians_doc},
+ {"sin", math_sin, METH_O, math_sin_doc},
+ {"sinh", math_sinh, METH_O, math_sinh_doc},
+ {"sqrt", math_sqrt, METH_O, math_sqrt_doc},
+ {"tan", math_tan, METH_O, math_tan_doc},
+ {"tanh", math_tanh, METH_O, math_tanh_doc},
+ {"trunc", math_trunc, METH_O, math_trunc_doc},
+ {NULL, NULL} /* sentinel */
};
@@ -1600,15 +1600,15 @@
PyMODINIT_FUNC
initmath(void)
{
- PyObject *m;
+ PyObject *m;
- m = Py_InitModule3("math", math_methods, module_doc);
- if (m == NULL)
- goto finally;
+ m = Py_InitModule3("math", math_methods, module_doc);
+ if (m == NULL)
+ goto finally;
- PyModule_AddObject(m, "pi", PyFloat_FromDouble(Py_MATH_PI));
- PyModule_AddObject(m, "e", PyFloat_FromDouble(Py_MATH_E));
+ PyModule_AddObject(m, "pi", PyFloat_FromDouble(Py_MATH_PI));
+ PyModule_AddObject(m, "e", PyFloat_FromDouble(Py_MATH_E));
finally:
- return;
+ return;
}