Back to index

python3.2  3.2.2
Defines | Functions | Variables
mathmodule.c File Reference
#include "Python.h"
#include "_math.h"

Go to the source code of this file.

Defines

#define LANCZOS_N   13
#define NGAMMA_INTEGRAL   23
#define ERF_SERIES_CUTOFF   1.5
#define ERF_SERIES_TERMS   25
#define ERFC_CONTFRAC_CUTOFF   30.0
#define ERFC_CONTFRAC_TERMS   50
#define FUNC1(funcname, func, can_overflow, docstring)
#define FUNC1A(funcname, func, docstring)
#define FUNC2(funcname, func, docstring)
#define NUM_PARTIALS   32 /* initial partials array size, on stack */

Functions

static double sinpi (double x)
static double lanczos_sum (double x)
static double m_tgamma (double x)
static double m_lgamma (double x)
static double m_erf_series (double x)
static double m_erfc_contfrac (double x)
static double m_erf (double x)
static double m_erfc (double x)
static double m_atan2 (double y, double x)
static double m_log (double x)
static double m_log10 (double x)
static int is_error (double x)
static PyObjectmath_1_to_whatever (PyObject *arg, double(*func)(double), PyObject *(*from_double_func)(double), int can_overflow)
static PyObjectmath_1a (PyObject *arg, double(*func)(double))
static PyObjectmath_1 (PyObject *arg, double(*func)(double), int can_overflow)
static PyObjectmath_1_to_int (PyObject *arg, double(*func)(double), int can_overflow)
static PyObjectmath_2 (PyObject *args, double(*func)(double, double), char *funcname)
 FUNC1 (acos, acos, FUNC1(0,"acos(x)\n\nReturn the arc cosine (measured in radians) of x.")
 PyDoc_STRVAR (math_ceil_doc,"ceil(x)\n\nReturn the ceiling of x as an int.\n""This is the smallest integral value >= x.")
 FUNC2 (copysign, copysign,"copysign(x, y)\n\nReturn x with the sign of y.")
 PyDoc_STRVAR (math_floor_doc,"floor(x)\n\nReturn the floor of x as an int.\n""This is the largest integral value <= x.")
 FUNC1A (gamma, m_tgamma,"gamma(x)\n\nGamma function at x.")
static PyObjectmath_fsum (PyObject *self, PyObject *seq)
 PyDoc_STRVAR (math_fsum_doc,"fsum(iterable)\n\n\ Return an accurate floating point sum of values in the iterable.\n\ Assumes IEEE-754 floating point arithmetic.")
static unsigned long bit_length (unsigned long n)
static unsigned long count_set_bits (unsigned long n)
static PyObjectfactorial_partial_product (unsigned long start, unsigned long stop, unsigned long max_bits)
static PyObjectfactorial_odd_part (unsigned long n)
static PyObjectmath_factorial (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_factorial_doc,"factorial(x) -> Integral\n""\n""Find x!. Raise a ValueError if x is negative or non-integral.")
static PyObjectmath_trunc (PyObject *self, PyObject *number)
 PyDoc_STRVAR (math_trunc_doc,"trunc(x:Real) -> Integral\n""\n""Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.")
static PyObjectmath_frexp (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (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.")
static PyObjectmath_ldexp (PyObject *self, PyObject *args)
 PyDoc_STRVAR (math_ldexp_doc,"ldexp(x, i)\n\n\ Return x * (2**i).")
static PyObjectmath_modf (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_modf_doc,"modf(x)\n""\n""Return the fractional and integer parts of x. Both results carry the sign\n""of x and are floats.")
static PyObjectloghelper (PyObject *arg, double(*func)(double), char *funcname)
static PyObjectmath_log (PyObject *self, PyObject *args)
 PyDoc_STRVAR (math_log_doc,"log(x[, base])\n\n\ Return the logarithm of x to the given base.\n\ If the base not specified, returns the natural logarithm (base e) of x.")
static PyObjectmath_log10 (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_log10_doc,"log10(x)\n\nReturn the base 10 logarithm of x.")
static PyObjectmath_fmod (PyObject *self, PyObject *args)
 PyDoc_STRVAR (math_fmod_doc,"fmod(x, y)\n\nReturn fmod(x, y), according to platform C."" x % y may differ.")
static PyObjectmath_hypot (PyObject *self, PyObject *args)
 PyDoc_STRVAR (math_hypot_doc,"hypot(x, y)\n\nReturn the Euclidean distance, sqrt(x*x + y*y).")
static PyObjectmath_pow (PyObject *self, PyObject *args)
 PyDoc_STRVAR (math_pow_doc,"pow(x, y)\n\nReturn x**y (x to the power of y).")
static PyObjectmath_degrees (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_degrees_doc,"degrees(x)\n\n\ Convert angle x from radians to degrees.")
static PyObjectmath_radians (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_radians_doc,"radians(x)\n\n\ Convert angle x from degrees to radians.")
static PyObjectmath_isfinite (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_isfinite_doc,"isfinite(x) -> bool\n\n\ Return True if x is neither an infinity nor a NaN, and False otherwise.")
static PyObjectmath_isnan (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_isnan_doc,"isnan(x) -> bool\n\n\ Return True if x is a NaN (not a number), and False otherwise.")
static PyObjectmath_isinf (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (math_isinf_doc,"isinf(x) -> bool\n\n\ Return True if x is a positive or negative infinity, and False otherwise.")
 PyDoc_STRVAR (module_doc,"This module is always available. It provides access to the\n""mathematical functions defined by the C standard.")
PyMODINIT_FUNC PyInit_math (void)

Variables

static const double pi = 3.141592653589793238462643383279502884197
static const double sqrtpi = 1.772453850905516027298167483341145182798
static const double logpi = 1.144729885849400174143427351353058711647
static const double lanczos_g = 6.024680040776729583740234375
static const double lanczos_g_minus_half = 5.524680040776729583740234375
static const double lanczos_num_coeffs [LANCZOS_N]
static const double lanczos_den_coeffs [LANCZOS_N]
static const double gamma_integral [NGAMMA_INTEGRAL]
static const unsigned long SmallFactorials []
static const double degToRad = Py_MATH_PI / 180.0
static const double radToDeg = 180.0 / Py_MATH_PI
static PyMethodDef math_methods []
static struct PyModuleDef

Define Documentation

#define ERF_SERIES_CUTOFF   1.5

Definition at line 412 of file mathmodule.c.

#define ERF_SERIES_TERMS   25

Definition at line 413 of file mathmodule.c.

#define ERFC_CONTFRAC_CUTOFF   30.0

Definition at line 414 of file mathmodule.c.

#define ERFC_CONTFRAC_TERMS   50

Definition at line 415 of file mathmodule.c.

#define FUNC1 (   funcname,
  func,
  can_overflow,
  docstring 
)
Value:
static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
        return math_1(args, func, can_overflow);                            \
    }\
    PyDoc_STRVAR(math_##funcname##_doc, docstring);

Definition at line 804 of file mathmodule.c.

#define FUNC1A (   funcname,
  func,
  docstring 
)
Value:
static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
        return math_1a(args, func);                                     \
    }\
    PyDoc_STRVAR(math_##funcname##_doc, docstring);

Definition at line 810 of file mathmodule.c.

#define FUNC2 (   funcname,
  func,
  docstring 
)
Value:
static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
        return math_2(args, func, #funcname); \
    }\
    PyDoc_STRVAR(math_##funcname##_doc, docstring);

Definition at line 816 of file mathmodule.c.

#define LANCZOS_N   13

Definition at line 166 of file mathmodule.c.

#define NGAMMA_INTEGRAL   23

Definition at line 191 of file mathmodule.c.

#define NUM_PARTIALS   32 /* initial partials array size, on stack */

Function Documentation

static unsigned long bit_length ( unsigned long  n) [static]

Definition at line 1146 of file mathmodule.c.

{
    unsigned long len = 0;
    while (n != 0) {
        ++len;
        n >>= 1;
    }
    return len;
}

Here is the caller graph for this function:

static unsigned long count_set_bits ( unsigned long  n) [static]

Definition at line 1157 of file mathmodule.c.

{
    unsigned long count = 0;
    while (n != 0) {
        ++count;
        n &= n - 1; /* clear least significant bit */
    }
    return count;
}

Here is the caller graph for this function:

static PyObject* factorial_odd_part ( unsigned long  n) [static]

Definition at line 1290 of file mathmodule.c.

{
    long i;
    unsigned long v, lower, upper;
    PyObject *partial, *tmp, *inner, *outer;

    inner = PyLong_FromLong(1);
    if (inner == NULL)
        return NULL;
    outer = inner;
    Py_INCREF(outer);

    upper = 3;
    for (i = bit_length(n) - 2; i >= 0; i--) {
        v = n >> i;
        if (v <= 2)
            continue;
        lower = upper;
        /* (v + 1) | 1 = least odd integer strictly larger than n / 2**i */
        upper = (v + 1) | 1;
        /* Here inner is the product of all odd integers j in the range (0,
           n/2**(i+1)].  The factorial_partial_product call below gives the
           product of all odd integers j in the range (n/2**(i+1), n/2**i]. */
        partial = factorial_partial_product(lower, upper, bit_length(upper-2));
        /* inner *= partial */
        if (partial == NULL)
            goto error;
        tmp = PyNumber_Multiply(inner, partial);
        Py_DECREF(partial);
        if (tmp == NULL)
            goto error;
        Py_DECREF(inner);
        inner = tmp;
        /* Now inner is the product of all odd integers j in the range (0,
           n/2**i], giving the inner product in the formula above. */

        /* outer *= inner; */
        tmp = PyNumber_Multiply(outer, inner);
        if (tmp == NULL)
            goto error;
        Py_DECREF(outer);
        outer = tmp;
    }

    goto done;

  error:
    Py_DECREF(outer);
  done:
    Py_DECREF(inner);
    return outer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* factorial_partial_product ( unsigned long  start,
unsigned long  stop,
unsigned long  max_bits 
) [static]

Definition at line 1237 of file mathmodule.c.

{
    unsigned long midpoint, num_operands;
    PyObject *left = NULL, *right = NULL, *result = NULL;

    /* If the return value will fit an unsigned long, then we can
     * multiply in a tight, fast loop where each multiply is O(1).
     * Compute an upper bound on the number of bits required to store
     * the answer.
     *
     * Storing some integer z requires floor(lg(z))+1 bits, which is
     * conveniently the value returned by bit_length(z).  The
     * product x*y will require at most
     * bit_length(x) + bit_length(y) bits to store, based
     * on the idea that lg product = lg x + lg y.
     *
     * We know that stop - 2 is the largest number to be multiplied.  From
     * there, we have: bit_length(answer) <= num_operands *
     * bit_length(stop - 2)
     */

    num_operands = (stop - start) / 2;
    /* The "num_operands <= 8 * SIZEOF_LONG" check guards against the
     * unlikely case of an overflow in num_operands * max_bits. */
    if (num_operands <= 8 * SIZEOF_LONG &&
        num_operands * max_bits <= 8 * SIZEOF_LONG) {
        unsigned long j, total;
        for (total = start, j = start + 2; j < stop; j += 2)
            total *= j;
        return PyLong_FromUnsignedLong(total);
    }

    /* find midpoint of range(start, stop), rounded up to next odd number. */
    midpoint = (start + num_operands) | 1;
    left = factorial_partial_product(start, midpoint,
                                     bit_length(midpoint - 2));
    if (left == NULL)
        goto error;
    right = factorial_partial_product(midpoint, stop, max_bits);
    if (right == NULL)
        goto error;
    result = PyNumber_Multiply(left, right);

  error:
    Py_XDECREF(left);
    Py_XDECREF(right);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FUNC1 ( acos  ,
acos  ,
FUNC1 0,
"acos(x)\n\nReturn the arc cosine (measured in radians) of x."   
)

Definition at line 822 of file mathmodule.c.

                                                              {
    static PyObject *ceil_str = NULL;
    PyObject *method, *result;

    method = _PyObject_LookupSpecial(number, "__ceil__", &ceil_str);
    if (method == NULL) {
        if (PyErr_Occurred())
            return NULL;
        return math_1_to_int(number, ceil, 0);
    }
    result = PyObject_CallFunctionObjArgs(method, NULL);
    Py_DECREF(method);
    return result;
}

Here is the call graph for this function:

FUNC1A ( gamma  ,
m_tgamma  ,
"gamma(x)\n\nGamma function at x."   
)

Definition at line 895 of file mathmodule.c.

{
    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;
}

Here is the call graph for this function:

FUNC2 ( copysign  ,
copysign  ,
"copysign(x, y)\n\nReturn x with the sign of y."   
)

Definition at line 857 of file mathmodule.c.

                                                               {
    static PyObject *floor_str = NULL;
    PyObject *method, *result;

    method = _PyObject_LookupSpecial(number, "__floor__", &floor_str);
    if (method == NULL) {
        if (PyErr_Occurred())
            return NULL;
        return math_1_to_int(number, floor, 0);
    }
    result = PyObject_CallFunctionObjArgs(method, NULL);
    Py_DECREF(method);
    return result;
}

Here is the call graph for this function:

static int is_error ( double  x) [static]

Definition at line 613 of file mathmodule.c.

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static double lanczos_sum ( double  x) [static]

Definition at line 203 of file mathmodule.c.

{
    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;
}

Here is the caller graph for this function:

static PyObject* loghelper ( PyObject arg,
double(*)(double)  func,
char *  funcname 
) [static]

Definition at line 1561 of file mathmodule.c.

{
    /* If it is long, do it ourselves. */
    if (PyLong_Check(arg)) {
        double x, result;
        Py_ssize_t e;

        /* Negative or zero inputs give a ValueError. */
        if (Py_SIZE(arg) <= 0) {
            PyErr_SetString(PyExc_ValueError,
                            "math domain error");
            return NULL;
        }

        x = PyLong_AsDouble(arg);
        if (x == -1.0 && PyErr_Occurred()) {
            if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                return NULL;
            /* Here the conversion to double overflowed, but it's possible
               to compute the log anyway.  Clear the exception and continue. */
            PyErr_Clear();
            x = _PyLong_Frexp((PyLongObject *)arg, &e);
            if (x == -1.0 && PyErr_Occurred())
                return NULL;
            /* Value is ~= x * 2**e, so the log ~= log(x) + log(2) * e. */
            result = func(x) + func(2.0) * e;
        }
        else
            /* Successfully converted x to a double. */
            result = func(x);
        return PyFloat_FromDouble(result);
    }

    /* Else let libm handle it by itself. */
    return math_1(arg, func, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static double m_atan2 ( double  y,
double  x 
) [static]

Definition at line 529 of file mathmodule.c.

{
    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);
}

Here is the call graph for this function:

static double m_erf ( double  x) [static]

Definition at line 487 of file mathmodule.c.

{
    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;
    }
}

Here is the call graph for this function:

static double m_erf_series ( double  x) [static]

Definition at line 425 of file mathmodule.c.

{
    double x2, acc, fk, result;
    int i, saved_errno;

    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;
    }
    /* Make sure the exp call doesn't affect errno;
       see m_erfc_contfrac for more. */
    saved_errno = errno;
    result = acc * x * exp(-x2) / sqrtpi;
    errno = saved_errno;
    return result;
}

Here is the caller graph for this function:

static double m_erfc ( double  x) [static]

Definition at line 505 of file mathmodule.c.

{
    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;
    }
}

Here is the call graph for this function:

static double m_erfc_contfrac ( double  x) [static]

Definition at line 455 of file mathmodule.c.

{
    double x2, a, da, p, p_last, q, q_last, b, result;
    int i, saved_errno;

    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;
    }
    /* Issue #8986: On some platforms, exp sets errno on underflow to zero;
       save the current errno value so that we can restore it later. */
    saved_errno = errno;
    result = p / q * x * exp(-x2) / sqrtpi;
    errno = saved_errno;
    return result;
}

Here is the caller graph for this function:

static double m_lgamma ( double  x) [static]

Definition at line 332 of file mathmodule.c.

{
    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 */
    }

    /* 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);

    /* Lanczos' formula.  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(absx)) - lanczos_g;
    r += (absx - 0.5) * (log(absx + lanczos_g - 0.5) - 1);
    if (x < 0.0)
        /* Use reflection formula to get value for negative x. */
        r = logpi - log(fabs(sinpi(absx))) - log(absx) - r;
    if (Py_IS_INFINITY(r))
        errno = ERANGE;
    return r;
}

Here is the call graph for this function:

static double m_log ( double  x) [static]

Definition at line 564 of file mathmodule.c.

{
    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 */
    }
}

Here is the caller graph for this function:

static double m_log10 ( double  x) [static]

Definition at line 586 of file mathmodule.c.

{
    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 */
    }
}

Here is the caller graph for this function:

static double m_tgamma ( double  x) [static]

Definition at line 232 of file mathmodule.c.

{
    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 */
    }

    /* 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;
    }

    /* 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;
}

Here is the call graph for this function:

static PyObject* math_1 ( PyObject arg,
double(*)(double)  func,
int  can_overflow 
) [static]

Definition at line 760 of file mathmodule.c.

{
    return math_1_to_whatever(arg, func, PyFloat_FromDouble, can_overflow);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* math_1_to_int ( PyObject arg,
double(*)(double)  func,
int  can_overflow 
) [static]

Definition at line 766 of file mathmodule.c.

{
    return math_1_to_whatever(arg, func, PyLong_FromDouble, can_overflow);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* math_1_to_whatever ( PyObject arg,
double(*)(double)  func,
PyObject *(*)(double)  from_double_func,
int  can_overflow 
) [static]

Definition at line 679 of file mathmodule.c.

{
    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) && !Py_IS_NAN(x)) {
        PyErr_SetString(PyExc_ValueError,
                        "math domain error"); /* invalid arg */
        return NULL;
    }
    if (Py_IS_INFINITY(r) && Py_IS_FINITE(x)) {
                    if (can_overflow)
                            PyErr_SetString(PyExc_OverflowError,
                                    "math range error"); /* overflow */
            else
                PyErr_SetString(PyExc_ValueError,
                    "math domain error"); /* singularity */
            return NULL;
    }
    if (Py_IS_FINITE(r) && errno && is_error(r))
        /* this branch unnecessary on most platforms */
        return NULL;

    return (*from_double_func)(r);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* math_1a ( PyObject arg,
double(*)(double)  func 
) [static]

Definition at line 717 of file mathmodule.c.

{
    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);
}

Here is the call graph for this function:

static PyObject* math_2 ( PyObject args,
double(*)(double, double)  func,
char *  funcname 
) [static]

Definition at line 772 of file mathmodule.c.

{
    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);
}

Here is the call graph for this function:

static PyObject* math_degrees ( PyObject self,
PyObject arg 
) [static]

Definition at line 1805 of file mathmodule.c.

{
    double x = PyFloat_AsDouble(arg);
    if (x == -1.0 && PyErr_Occurred())
        return NULL;
    return PyFloat_FromDouble(x * radToDeg);
}

Here is the call graph for this function:

static PyObject* math_factorial ( PyObject self,
PyObject arg 
) [static]

Definition at line 1356 of file mathmodule.c.

{
    long x;
    PyObject *result, *odd_part, *two_valuation;

    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 = PyLong_AsLong(arg);

    if (x == -1 && PyErr_Occurred())
        return NULL;
    if (x < 0) {
        PyErr_SetString(PyExc_ValueError,
                        "factorial() not defined for negative values");
        return NULL;
    }

    /* use lookup table if x is small */
    if (x < (long)(sizeof(SmallFactorials)/sizeof(SmallFactorials[0])))
        return PyLong_FromUnsignedLong(SmallFactorials[x]);

    /* else express in the form odd_part * 2**two_valuation, and compute as
       odd_part << two_valuation. */
    odd_part = factorial_odd_part(x);
    if (odd_part == NULL)
        return NULL;
    two_valuation = PyLong_FromLong(x - count_set_bits(x));
    if (two_valuation == NULL) {
        Py_DECREF(odd_part);
        return NULL;
    }
    result = PyNumber_Lshift(odd_part, two_valuation);
    Py_DECREF(two_valuation);
    Py_DECREF(odd_part);
    return result;
}

Here is the call graph for this function:

static PyObject* math_fmod ( PyObject self,
PyObject args 
) [static]

Definition at line 1640 of file mathmodule.c.

{
    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);
}

Here is the call graph for this function:

static PyObject* math_frexp ( PyObject self,
PyObject arg 
) [static]

Definition at line 1441 of file mathmodule.c.

{
    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);
}

Here is the call graph for this function:

static PyObject* math_fsum ( PyObject self,
PyObject seq 
) [static]

Definition at line 1010 of file mathmodule.c.

{
    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;

    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));

        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;
        }

        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;
    }

    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;
}

Here is the call graph for this function:

static PyObject* math_hypot ( PyObject self,
PyObject args 
) [static]

Definition at line 1674 of file mathmodule.c.

{
    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);
}

Here is the call graph for this function:

static PyObject* math_isfinite ( PyObject self,
PyObject arg 
) [static]

Definition at line 1831 of file mathmodule.c.

{
    double x = PyFloat_AsDouble(arg);
    if (x == -1.0 && PyErr_Occurred())
        return NULL;
    return PyBool_FromLong((long)Py_IS_FINITE(x));
}

Here is the call graph for this function:

static PyObject* math_isinf ( PyObject self,
PyObject arg 
) [static]

Definition at line 1857 of file mathmodule.c.

{
    double x = PyFloat_AsDouble(arg);
    if (x == -1.0 && PyErr_Occurred())
        return NULL;
    return PyBool_FromLong((long)Py_IS_INFINITY(x));
}

Here is the call graph for this function:

static PyObject* math_isnan ( PyObject self,
PyObject arg 
) [static]

Definition at line 1844 of file mathmodule.c.

{
    double x = PyFloat_AsDouble(arg);
    if (x == -1.0 && PyErr_Occurred())
        return NULL;
    return PyBool_FromLong((long)Py_IS_NAN(x));
}

Here is the call graph for this function:

static PyObject* math_ldexp ( PyObject self,
PyObject args 
) [static]

Definition at line 1468 of file mathmodule.c.

{
    double x, r;
    PyObject *oexp;
    long exp;
    int overflow;
    if (! PyArg_ParseTuple(args, "dO:ldexp", &x, &oexp))
        return NULL;

    if (PyLong_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 (errno && is_error(r))
        return NULL;
    return PyFloat_FromDouble(r);
}

Here is the call graph for this function:

static PyObject* math_log ( PyObject self,
PyObject args 
) [static]

Definition at line 1599 of file mathmodule.c.

{
    PyObject *arg;
    PyObject *base = NULL;
    PyObject *num, *den;
    PyObject *ans;

    if (!PyArg_UnpackTuple(args, "log", 1, 2, &arg, &base))
        return NULL;

    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;
    }

    ans = PyNumber_TrueDivide(num, den);
    Py_DECREF(num);
    Py_DECREF(den);
    return ans;
}

Here is the call graph for this function:

static PyObject* math_log10 ( PyObject self,
PyObject arg 
) [static]

Definition at line 1631 of file mathmodule.c.

{
    return loghelper(arg, m_log10, "log10");
}

Here is the call graph for this function:

static PyObject* math_modf ( PyObject self,
PyObject arg 
) [static]

Definition at line 1524 of file mathmodule.c.

{
    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);
}

Here is the call graph for this function:

static PyObject* math_pow ( PyObject self,
PyObject args 
) [static]

Definition at line 1721 of file mathmodule.c.

{
    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;

    /* 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);
}

Here is the call graph for this function:

static PyObject* math_radians ( PyObject self,
PyObject arg 
) [static]

Definition at line 1818 of file mathmodule.c.

{
    double x = PyFloat_AsDouble(arg);
    if (x == -1.0 && PyErr_Occurred())
        return NULL;
    return PyFloat_FromDouble(x * degToRad);
}

Here is the call graph for this function:

static PyObject* math_trunc ( PyObject self,
PyObject number 
) [static]

Definition at line 1412 of file mathmodule.c.

{
    static PyObject *trunc_str = NULL;
    PyObject *trunc, *result;

    if (Py_TYPE(number)->tp_dict == NULL) {
        if (PyType_Ready(Py_TYPE(number)) < 0)
            return NULL;
    }

    trunc = _PyObject_LookupSpecial(number, "__trunc__", &trunc_str);
    if (trunc == NULL) {
        if (!PyErr_Occurred())
            PyErr_Format(PyExc_TypeError,
                         "type %.100s doesn't define __trunc__ method",
                         Py_TYPE(number)->tp_name);
        return NULL;
    }
    result = PyObject_CallFunctionObjArgs(trunc, NULL);
    Py_DECREF(trunc);
    return result;
}

Here is the call graph for this function:

PyDoc_STRVAR ( math_ceil_doc  ,
"ceil(x)\n\nReturn the ceiling of x as an int.\n""This is the smallest integral value >= x."   
)
PyDoc_STRVAR ( math_floor_doc  ,
"floor(x)\n\nReturn the floor of x as an int.\n""This is the largest integral value <= x."   
)
PyDoc_STRVAR ( math_fsum_doc  ,
"fsum(iterable)\n\n\Return an accurate floating point sum of values in the iterable.\n\Assumes IEEE-754 floating point arithmetic."   
)
PyDoc_STRVAR ( math_factorial_doc  ,
"factorial(x) -> Integral\n""\n""Find x!. Raise a ValueError if x is negative or non-integral."   
)
PyDoc_STRVAR ( math_trunc_doc  ,
"trunc(x:Real) -> Integral\n""\n""Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method."   
)
PyDoc_STRVAR ( 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 
)
PyDoc_STRVAR ( math_ldexp_doc  ,
"ldexp(x, i)\n\n\Return x * (2**i)."   
)
PyDoc_STRVAR ( math_modf_doc  ,
"modf(x)\n""\n""Return the fractional and integer parts of x. Both results carry the sign\n""of x and are floats."   
)
PyDoc_STRVAR ( math_log_doc  ,
"log(x[, base])\n\n\Return the logarithm of x to the given base.\n\If the base not  specified,
returns the natural logarithm(base e) of x."   
)
PyDoc_STRVAR ( math_log10_doc  ,
"log10(x)\n\nReturn the base 10 logarithm of x."   
)
PyDoc_STRVAR ( math_fmod_doc  ,
fmodx, y)\n\nReturn fmod(x, y,
according to platform C.""x% y may differ."   
)
PyDoc_STRVAR ( math_hypot_doc  ,
"hypot(x, y)\n\nReturn the Euclidean  distance,
sqrt(x *x+y *y)."   
)
PyDoc_STRVAR ( math_pow_doc  ,
"pow(x, y)\n\nReturn x**y (x to the power of y)."   
)
PyDoc_STRVAR ( math_degrees_doc  ,
"degrees(x)\n\n\Convert angle x from radians to degrees."   
)
PyDoc_STRVAR ( math_radians_doc  ,
"radians(x)\n\n\Convert angle x from degrees to radians."   
)
PyDoc_STRVAR ( math_isfinite_doc  ,
"isfinite(x) -> bool\n\n\Return True if x is neither an infinity nor a  NaN,
and False otherwise."   
)
PyDoc_STRVAR ( math_isnan_doc  ,
isnanx) -> bool\n\n\Return True if x is a NaN (not a number,
and False otherwise."   
)
PyDoc_STRVAR ( math_isinf_doc  ,
"isinf(x) -> bool\n\n\Return True if x is a positive or negative  infinity,
and False otherwise."   
)
PyDoc_STRVAR ( module_doc  ,
"This module is always available. It provides access to the\n""mathematical functions defined by the C standard."   
)

Definition at line 1933 of file mathmodule.c.

{
    PyObject *m;

    m = PyModule_Create(&mathmodule);
    if (m == NULL)
        goto finally;

    PyModule_AddObject(m, "pi", PyFloat_FromDouble(Py_MATH_PI));
    PyModule_AddObject(m, "e", PyFloat_FromDouble(Py_MATH_E));

    finally:
    return m;
}

Here is the call graph for this function:

static double sinpi ( double  x) [static]

Definition at line 75 of file mathmodule.c.

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

const double degToRad = Py_MATH_PI / 180.0 [static]

Definition at line 1801 of file mathmodule.c.

Initial value:
 {
    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,
}

Definition at line 192 of file mathmodule.c.

Initial value:
 {
    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}

Definition at line 186 of file mathmodule.c.

const double lanczos_g = 6.024680040776729583740234375 [static]

Definition at line 167 of file mathmodule.c.

const double lanczos_g_minus_half = 5.524680040776729583740234375 [static]

Definition at line 168 of file mathmodule.c.

Initial value:
 {
    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
}

Definition at line 169 of file mathmodule.c.

const double logpi = 1.144729885849400174143427351353058711647 [static]

Definition at line 72 of file mathmodule.c.

Definition at line 1869 of file mathmodule.c.

const double pi = 3.141592653589793238462643383279502884197 [static]

Definition at line 70 of file mathmodule.c.

struct PyModuleDef [static]
Initial value:
 {
    PyModuleDef_HEAD_INIT,
    "math",
    module_doc,
    -1,
    math_methods,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 1920 of file mathmodule.c.

const double radToDeg = 180.0 / Py_MATH_PI [static]

Definition at line 1802 of file mathmodule.c.

const unsigned long SmallFactorials[] [static]
Initial value:
 {
    1, 1, 2, 6, 24, 120, 720, 5040, 40320,
    362880, 3628800, 39916800, 479001600,





}

Definition at line 1345 of file mathmodule.c.

const double sqrtpi = 1.772453850905516027298167483341145182798 [static]

Definition at line 71 of file mathmodule.c.