| /* Complex math module */ |
| |
| /* much code borrowed from mathmodule.c */ |
| |
| #include "Python.h" |
| #include "pycore_dtoa.h" |
| #include "_math.h" |
| /* we need DBL_MAX, DBL_MIN, DBL_EPSILON, DBL_MANT_DIG and FLT_RADIX from |
| float.h. We assume that FLT_RADIX is either 2 or 16. */ |
| #include <float.h> |
| |
| #include "clinic/cmathmodule.c.h" |
| /*[clinic input] |
| module cmath |
| [clinic start generated code]*/ |
| /*[clinic end generated code: output=da39a3ee5e6b4b0d input=308d6839f4a46333]*/ |
| |
| /*[python input] |
| class Py_complex_protected_converter(Py_complex_converter): |
| def modify(self): |
| return 'errno = 0;' |
| |
| |
| class Py_complex_protected_return_converter(CReturnConverter): |
| type = "Py_complex" |
| |
| def render(self, function, data): |
| self.declare(data) |
| data.return_conversion.append(""" |
| if (errno == EDOM) { |
| PyErr_SetString(PyExc_ValueError, "math domain error"); |
| goto exit; |
| } |
| else if (errno == ERANGE) { |
| PyErr_SetString(PyExc_OverflowError, "math range error"); |
| goto exit; |
| } |
| else { |
| return_value = PyComplex_FromCComplex(_return_value); |
| } |
| """.strip()) |
| [python start generated code]*/ |
| /*[python end generated code: output=da39a3ee5e6b4b0d input=8b27adb674c08321]*/ |
| |
| #if (FLT_RADIX != 2 && FLT_RADIX != 16) |
| #error "Modules/cmathmodule.c expects FLT_RADIX to be 2 or 16" |
| #endif |
| |
| #ifndef M_LN2 |
| #define M_LN2 (0.6931471805599453094) /* natural log of 2 */ |
| #endif |
| |
| #ifndef M_LN10 |
| #define M_LN10 (2.302585092994045684) /* natural log of 10 */ |
| #endif |
| |
| /* |
| CM_LARGE_DOUBLE is used to avoid spurious overflow in the sqrt, log, |
| inverse trig and inverse hyperbolic trig functions. Its log is used in the |
| evaluation of exp, cos, cosh, sin, sinh, tan, and tanh to avoid unnecessary |
| overflow. |
| */ |
| |
| #define CM_LARGE_DOUBLE (DBL_MAX/4.) |
| #define CM_SQRT_LARGE_DOUBLE (sqrt(CM_LARGE_DOUBLE)) |
| #define CM_LOG_LARGE_DOUBLE (log(CM_LARGE_DOUBLE)) |
| #define CM_SQRT_DBL_MIN (sqrt(DBL_MIN)) |
| |
| /* |
| CM_SCALE_UP is an odd integer chosen such that multiplication by |
| 2**CM_SCALE_UP is sufficient to turn a subnormal into a normal. |
| CM_SCALE_DOWN is (-(CM_SCALE_UP+1)/2). These scalings are used to compute |
| square roots accurately when the real and imaginary parts of the argument |
| are subnormal. |
| */ |
| |
| #if FLT_RADIX==2 |
| #define CM_SCALE_UP (2*(DBL_MANT_DIG/2) + 1) |
| #elif FLT_RADIX==16 |
| #define CM_SCALE_UP (4*DBL_MANT_DIG+1) |
| #endif |
| #define CM_SCALE_DOWN (-(CM_SCALE_UP+1)/2) |
| |
| /* Constants cmath.inf, cmath.infj, cmath.nan, cmath.nanj. |
| cmath.nan and cmath.nanj are defined only when either |
| PY_NO_SHORT_FLOAT_REPR is *not* defined (which should be |
| the most common situation on machines using an IEEE 754 |
| representation), or Py_NAN is defined. */ |
| |
| static double |
| m_inf(void) |
| { |
| #ifndef PY_NO_SHORT_FLOAT_REPR |
| return _Py_dg_infinity(0); |
| #else |
| return Py_HUGE_VAL; |
| #endif |
| } |
| |
| static Py_complex |
| c_infj(void) |
| { |
| Py_complex r; |
| r.real = 0.0; |
| r.imag = m_inf(); |
| return r; |
| } |
| |
| #if !defined(PY_NO_SHORT_FLOAT_REPR) || defined(Py_NAN) |
| |
| static double |
| m_nan(void) |
| { |
| #ifndef PY_NO_SHORT_FLOAT_REPR |
| return _Py_dg_stdnan(0); |
| #else |
| return Py_NAN; |
| #endif |
| } |
| |
| static Py_complex |
| c_nanj(void) |
| { |
| Py_complex r; |
| r.real = 0.0; |
| r.imag = m_nan(); |
| return r; |
| } |
| |
| #endif |
| |
| /* forward declarations */ |
| static Py_complex cmath_asinh_impl(PyObject *, Py_complex); |
| static Py_complex cmath_atanh_impl(PyObject *, Py_complex); |
| static Py_complex cmath_cosh_impl(PyObject *, Py_complex); |
| static Py_complex cmath_sinh_impl(PyObject *, Py_complex); |
| static Py_complex cmath_sqrt_impl(PyObject *, Py_complex); |
| static Py_complex cmath_tanh_impl(PyObject *, Py_complex); |
| static PyObject * math_error(void); |
| |
| /* Code to deal with special values (infinities, NaNs, etc.). */ |
| |
| /* special_type takes a double and returns an integer code indicating |
| the type of the double as follows: |
| */ |
| |
| enum special_types { |
| ST_NINF, /* 0, negative infinity */ |
| ST_NEG, /* 1, negative finite number (nonzero) */ |
| ST_NZERO, /* 2, -0. */ |
| ST_PZERO, /* 3, +0. */ |
| ST_POS, /* 4, positive finite number (nonzero) */ |
| ST_PINF, /* 5, positive infinity */ |
| ST_NAN /* 6, Not a Number */ |
| }; |
| |
| static enum special_types |
| special_type(double d) |
| { |
| if (Py_IS_FINITE(d)) { |
| if (d != 0) { |
| if (copysign(1., d) == 1.) |
| return ST_POS; |
| else |
| return ST_NEG; |
| } |
| else { |
| if (copysign(1., d) == 1.) |
| return ST_PZERO; |
| else |
| return ST_NZERO; |
| } |
| } |
| if (Py_IS_NAN(d)) |
| return ST_NAN; |
| if (copysign(1., d) == 1.) |
| return ST_PINF; |
| else |
| return ST_NINF; |
| } |
| |
| #define SPECIAL_VALUE(z, table) \ |
| if (!Py_IS_FINITE((z).real) || !Py_IS_FINITE((z).imag)) { \ |
| errno = 0; \ |
| return table[special_type((z).real)] \ |
| [special_type((z).imag)]; \ |
| } |
| |
| #define P Py_MATH_PI |
| #define P14 0.25*Py_MATH_PI |
| #define P12 0.5*Py_MATH_PI |
| #define P34 0.75*Py_MATH_PI |
| #define INF Py_HUGE_VAL |
| #define N Py_NAN |
| #define U -9.5426319407711027e33 /* unlikely value, used as placeholder */ |
| |
| /* First, the C functions that do the real work. Each of the c_* |
| functions computes and returns the C99 Annex G recommended result |
| and also sets errno as follows: errno = 0 if no floating-point |
| exception is associated with the result; errno = EDOM if C99 Annex |
| G recommends raising divide-by-zero or invalid for this result; and |
| errno = ERANGE where the overflow floating-point signal should be |
| raised. |
| */ |
| |
| static Py_complex acos_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.acos -> Py_complex_protected |
| |
| z: Py_complex_protected |
| / |
| |
| Return the arc cosine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_acos_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=40bd42853fd460ae input=bd6cbd78ae851927]*/ |
| { |
| Py_complex s1, s2, r; |
| |
| SPECIAL_VALUE(z, acos_special_values); |
| |
| if (fabs(z.real) > CM_LARGE_DOUBLE || fabs(z.imag) > CM_LARGE_DOUBLE) { |
| /* avoid unnecessary overflow for large arguments */ |
| r.real = atan2(fabs(z.imag), z.real); |
| /* split into cases to make sure that the branch cut has the |
| correct continuity on systems with unsigned zeros */ |
| if (z.real < 0.) { |
| r.imag = -copysign(log(hypot(z.real/2., z.imag/2.)) + |
| M_LN2*2., z.imag); |
| } else { |
| r.imag = copysign(log(hypot(z.real/2., z.imag/2.)) + |
| M_LN2*2., -z.imag); |
| } |
| } else { |
| s1.real = 1.-z.real; |
| s1.imag = -z.imag; |
| s1 = cmath_sqrt_impl(module, s1); |
| s2.real = 1.+z.real; |
| s2.imag = z.imag; |
| s2 = cmath_sqrt_impl(module, s2); |
| r.real = 2.*atan2(s1.real, s2.real); |
| r.imag = m_asinh(s2.real*s1.imag - s2.imag*s1.real); |
| } |
| errno = 0; |
| return r; |
| } |
| |
| |
| static Py_complex acosh_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.acosh = cmath.acos |
| |
| Return the inverse hyperbolic cosine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_acosh_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=3e2454d4fcf404ca input=3f61bee7d703e53c]*/ |
| { |
| Py_complex s1, s2, r; |
| |
| SPECIAL_VALUE(z, acosh_special_values); |
| |
| if (fabs(z.real) > CM_LARGE_DOUBLE || fabs(z.imag) > CM_LARGE_DOUBLE) { |
| /* avoid unnecessary overflow for large arguments */ |
| r.real = log(hypot(z.real/2., z.imag/2.)) + M_LN2*2.; |
| r.imag = atan2(z.imag, z.real); |
| } else { |
| s1.real = z.real - 1.; |
| s1.imag = z.imag; |
| s1 = cmath_sqrt_impl(module, s1); |
| s2.real = z.real + 1.; |
| s2.imag = z.imag; |
| s2 = cmath_sqrt_impl(module, s2); |
| r.real = m_asinh(s1.real*s2.real + s1.imag*s2.imag); |
| r.imag = 2.*atan2(s1.imag, s2.real); |
| } |
| errno = 0; |
| return r; |
| } |
| |
| /*[clinic input] |
| cmath.asin = cmath.acos |
| |
| Return the arc sine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_asin_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=3b264cd1b16bf4e1 input=be0bf0cfdd5239c5]*/ |
| { |
| /* asin(z) = -i asinh(iz) */ |
| Py_complex s, r; |
| s.real = -z.imag; |
| s.imag = z.real; |
| s = cmath_asinh_impl(module, s); |
| r.real = s.imag; |
| r.imag = -s.real; |
| return r; |
| } |
| |
| |
| static Py_complex asinh_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.asinh = cmath.acos |
| |
| Return the inverse hyperbolic sine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_asinh_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=733d8107841a7599 input=5c09448fcfc89a79]*/ |
| { |
| Py_complex s1, s2, r; |
| |
| SPECIAL_VALUE(z, asinh_special_values); |
| |
| if (fabs(z.real) > CM_LARGE_DOUBLE || fabs(z.imag) > CM_LARGE_DOUBLE) { |
| if (z.imag >= 0.) { |
| r.real = copysign(log(hypot(z.real/2., z.imag/2.)) + |
| M_LN2*2., z.real); |
| } else { |
| r.real = -copysign(log(hypot(z.real/2., z.imag/2.)) + |
| M_LN2*2., -z.real); |
| } |
| r.imag = atan2(z.imag, fabs(z.real)); |
| } else { |
| s1.real = 1.+z.imag; |
| s1.imag = -z.real; |
| s1 = cmath_sqrt_impl(module, s1); |
| s2.real = 1.-z.imag; |
| s2.imag = z.real; |
| s2 = cmath_sqrt_impl(module, s2); |
| r.real = m_asinh(s1.real*s2.imag-s2.real*s1.imag); |
| r.imag = atan2(z.imag, s1.real*s2.real-s1.imag*s2.imag); |
| } |
| errno = 0; |
| return r; |
| } |
| |
| |
| /*[clinic input] |
| cmath.atan = cmath.acos |
| |
| Return the arc tangent of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_atan_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=b6bfc497058acba4 input=3b21ff7d5eac632a]*/ |
| { |
| /* atan(z) = -i atanh(iz) */ |
| Py_complex s, r; |
| s.real = -z.imag; |
| s.imag = z.real; |
| s = cmath_atanh_impl(module, s); |
| r.real = s.imag; |
| r.imag = -s.real; |
| return r; |
| } |
| |
| /* Windows screws up atan2 for inf and nan, and alpha Tru64 5.1 doesn't follow |
| C99 for atan2(0., 0.). */ |
| static double |
| c_atan2(Py_complex z) |
| { |
| if (Py_IS_NAN(z.real) || Py_IS_NAN(z.imag)) |
| return Py_NAN; |
| if (Py_IS_INFINITY(z.imag)) { |
| if (Py_IS_INFINITY(z.real)) { |
| if (copysign(1., z.real) == 1.) |
| /* atan2(+-inf, +inf) == +-pi/4 */ |
| return copysign(0.25*Py_MATH_PI, z.imag); |
| else |
| /* atan2(+-inf, -inf) == +-pi*3/4 */ |
| return copysign(0.75*Py_MATH_PI, z.imag); |
| } |
| /* atan2(+-inf, x) == +-pi/2 for finite x */ |
| return copysign(0.5*Py_MATH_PI, z.imag); |
| } |
| if (Py_IS_INFINITY(z.real) || z.imag == 0.) { |
| if (copysign(1., z.real) == 1.) |
| /* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */ |
| return copysign(0., z.imag); |
| else |
| /* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */ |
| return copysign(Py_MATH_PI, z.imag); |
| } |
| return atan2(z.imag, z.real); |
| } |
| |
| |
| static Py_complex atanh_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.atanh = cmath.acos |
| |
| Return the inverse hyperbolic tangent of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_atanh_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=e83355f93a989c9e input=2b3fdb82fb34487b]*/ |
| { |
| Py_complex r; |
| double ay, h; |
| |
| SPECIAL_VALUE(z, atanh_special_values); |
| |
| /* Reduce to case where z.real >= 0., using atanh(z) = -atanh(-z). */ |
| if (z.real < 0.) { |
| return _Py_c_neg(cmath_atanh_impl(module, _Py_c_neg(z))); |
| } |
| |
| ay = fabs(z.imag); |
| if (z.real > CM_SQRT_LARGE_DOUBLE || ay > CM_SQRT_LARGE_DOUBLE) { |
| /* |
| if abs(z) is large then we use the approximation |
| atanh(z) ~ 1/z +/- i*pi/2 (+/- depending on the sign |
| of z.imag) |
| */ |
| h = hypot(z.real/2., z.imag/2.); /* safe from overflow */ |
| r.real = z.real/4./h/h; |
| /* the two negations in the next line cancel each other out |
| except when working with unsigned zeros: they're there to |
| ensure that the branch cut has the correct continuity on |
| systems that don't support signed zeros */ |
| r.imag = -copysign(Py_MATH_PI/2., -z.imag); |
| errno = 0; |
| } else if (z.real == 1. && ay < CM_SQRT_DBL_MIN) { |
| /* C99 standard says: atanh(1+/-0.) should be inf +/- 0i */ |
| if (ay == 0.) { |
| r.real = INF; |
| r.imag = z.imag; |
| errno = EDOM; |
| } else { |
| r.real = -log(sqrt(ay)/sqrt(hypot(ay, 2.))); |
| r.imag = copysign(atan2(2., -ay)/2, z.imag); |
| errno = 0; |
| } |
| } else { |
| r.real = m_log1p(4.*z.real/((1-z.real)*(1-z.real) + ay*ay))/4.; |
| r.imag = -atan2(-2.*z.imag, (1-z.real)*(1+z.real) - ay*ay)/2.; |
| errno = 0; |
| } |
| return r; |
| } |
| |
| |
| /*[clinic input] |
| cmath.cos = cmath.acos |
| |
| Return the cosine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_cos_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=fd64918d5b3186db input=6022e39b77127ac7]*/ |
| { |
| /* cos(z) = cosh(iz) */ |
| Py_complex r; |
| r.real = -z.imag; |
| r.imag = z.real; |
| r = cmath_cosh_impl(module, r); |
| return r; |
| } |
| |
| |
| /* cosh(infinity + i*y) needs to be dealt with specially */ |
| static Py_complex cosh_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.cosh = cmath.acos |
| |
| Return the hyperbolic cosine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_cosh_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=2e969047da601bdb input=d6b66339e9cc332b]*/ |
| { |
| Py_complex r; |
| double x_minus_one; |
| |
| /* special treatment for cosh(+/-inf + iy) if y is not a NaN */ |
| if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) { |
| if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag) && |
| (z.imag != 0.)) { |
| if (z.real > 0) { |
| r.real = copysign(INF, cos(z.imag)); |
| r.imag = copysign(INF, sin(z.imag)); |
| } |
| else { |
| r.real = copysign(INF, cos(z.imag)); |
| r.imag = -copysign(INF, sin(z.imag)); |
| } |
| } |
| else { |
| r = cosh_special_values[special_type(z.real)] |
| [special_type(z.imag)]; |
| } |
| /* need to set errno = EDOM if y is +/- infinity and x is not |
| a NaN */ |
| if (Py_IS_INFINITY(z.imag) && !Py_IS_NAN(z.real)) |
| errno = EDOM; |
| else |
| errno = 0; |
| return r; |
| } |
| |
| if (fabs(z.real) > CM_LOG_LARGE_DOUBLE) { |
| /* deal correctly with cases where cosh(z.real) overflows but |
| cosh(z) does not. */ |
| x_minus_one = z.real - copysign(1., z.real); |
| r.real = cos(z.imag) * cosh(x_minus_one) * Py_MATH_E; |
| r.imag = sin(z.imag) * sinh(x_minus_one) * Py_MATH_E; |
| } else { |
| r.real = cos(z.imag) * cosh(z.real); |
| r.imag = sin(z.imag) * sinh(z.real); |
| } |
| /* detect overflow, and set errno accordingly */ |
| if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag)) |
| errno = ERANGE; |
| else |
| errno = 0; |
| return r; |
| } |
| |
| |
| /* exp(infinity + i*y) and exp(-infinity + i*y) need special treatment for |
| finite y */ |
| static Py_complex exp_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.exp = cmath.acos |
| |
| Return the exponential value e**z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_exp_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=edcec61fb9dfda6c input=8b9e6cf8a92174c3]*/ |
| { |
| Py_complex r; |
| double l; |
| |
| if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) { |
| if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag) |
| && (z.imag != 0.)) { |
| if (z.real > 0) { |
| r.real = copysign(INF, cos(z.imag)); |
| r.imag = copysign(INF, sin(z.imag)); |
| } |
| else { |
| r.real = copysign(0., cos(z.imag)); |
| r.imag = copysign(0., sin(z.imag)); |
| } |
| } |
| else { |
| r = exp_special_values[special_type(z.real)] |
| [special_type(z.imag)]; |
| } |
| /* need to set errno = EDOM if y is +/- infinity and x is not |
| a NaN and not -infinity */ |
| if (Py_IS_INFINITY(z.imag) && |
| (Py_IS_FINITE(z.real) || |
| (Py_IS_INFINITY(z.real) && z.real > 0))) |
| errno = EDOM; |
| else |
| errno = 0; |
| return r; |
| } |
| |
| if (z.real > CM_LOG_LARGE_DOUBLE) { |
| l = exp(z.real-1.); |
| r.real = l*cos(z.imag)*Py_MATH_E; |
| r.imag = l*sin(z.imag)*Py_MATH_E; |
| } else { |
| l = exp(z.real); |
| r.real = l*cos(z.imag); |
| r.imag = l*sin(z.imag); |
| } |
| /* detect overflow, and set errno accordingly */ |
| if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag)) |
| errno = ERANGE; |
| else |
| errno = 0; |
| return r; |
| } |
| |
| static Py_complex log_special_values[7][7]; |
| |
| static Py_complex |
| c_log(Py_complex z) |
| { |
| /* |
| The usual formula for the real part is log(hypot(z.real, z.imag)). |
| There are four situations where this formula is potentially |
| problematic: |
| |
| (1) the absolute value of z is subnormal. Then hypot is subnormal, |
| so has fewer than the usual number of bits of accuracy, hence may |
| have large relative error. This then gives a large absolute error |
| in the log. This can be solved by rescaling z by a suitable power |
| of 2. |
| |
| (2) the absolute value of z is greater than DBL_MAX (e.g. when both |
| z.real and z.imag are within a factor of 1/sqrt(2) of DBL_MAX) |
| Again, rescaling solves this. |
| |
| (3) the absolute value of z is close to 1. In this case it's |
| difficult to achieve good accuracy, at least in part because a |
| change of 1ulp in the real or imaginary part of z can result in a |
| change of billions of ulps in the correctly rounded answer. |
| |
| (4) z = 0. The simplest thing to do here is to call the |
| floating-point log with an argument of 0, and let its behaviour |
| (returning -infinity, signaling a floating-point exception, setting |
| errno, or whatever) determine that of c_log. So the usual formula |
| is fine here. |
| |
| */ |
| |
| Py_complex r; |
| double ax, ay, am, an, h; |
| |
| SPECIAL_VALUE(z, log_special_values); |
| |
| ax = fabs(z.real); |
| ay = fabs(z.imag); |
| |
| if (ax > CM_LARGE_DOUBLE || ay > CM_LARGE_DOUBLE) { |
| r.real = log(hypot(ax/2., ay/2.)) + M_LN2; |
| } else if (ax < DBL_MIN && ay < DBL_MIN) { |
| if (ax > 0. || ay > 0.) { |
| /* catch cases where hypot(ax, ay) is subnormal */ |
| r.real = log(hypot(ldexp(ax, DBL_MANT_DIG), |
| ldexp(ay, DBL_MANT_DIG))) - DBL_MANT_DIG*M_LN2; |
| } |
| else { |
| /* log(+/-0. +/- 0i) */ |
| r.real = -INF; |
| r.imag = atan2(z.imag, z.real); |
| errno = EDOM; |
| return r; |
| } |
| } else { |
| h = hypot(ax, ay); |
| if (0.71 <= h && h <= 1.73) { |
| am = ax > ay ? ax : ay; /* max(ax, ay) */ |
| an = ax > ay ? ay : ax; /* min(ax, ay) */ |
| r.real = m_log1p((am-1)*(am+1)+an*an)/2.; |
| } else { |
| r.real = log(h); |
| } |
| } |
| r.imag = atan2(z.imag, z.real); |
| errno = 0; |
| return r; |
| } |
| |
| |
| /*[clinic input] |
| cmath.log10 = cmath.acos |
| |
| Return the base-10 logarithm of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_log10_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=2922779a7c38cbe1 input=cff5644f73c1519c]*/ |
| { |
| Py_complex r; |
| int errno_save; |
| |
| r = c_log(z); |
| errno_save = errno; /* just in case the divisions affect errno */ |
| r.real = r.real / M_LN10; |
| r.imag = r.imag / M_LN10; |
| errno = errno_save; |
| return r; |
| } |
| |
| |
| /*[clinic input] |
| cmath.sin = cmath.acos |
| |
| Return the sine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_sin_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=980370d2ff0bb5aa input=2d3519842a8b4b85]*/ |
| { |
| /* sin(z) = -i sin(iz) */ |
| Py_complex s, r; |
| s.real = -z.imag; |
| s.imag = z.real; |
| s = cmath_sinh_impl(module, s); |
| r.real = s.imag; |
| r.imag = -s.real; |
| return r; |
| } |
| |
| |
| /* sinh(infinity + i*y) needs to be dealt with specially */ |
| static Py_complex sinh_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.sinh = cmath.acos |
| |
| Return the hyperbolic sine of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_sinh_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=38b0a6cce26f3536 input=d2d3fc8c1ddfd2dd]*/ |
| { |
| Py_complex r; |
| double x_minus_one; |
| |
| /* special treatment for sinh(+/-inf + iy) if y is finite and |
| nonzero */ |
| if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) { |
| if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag) |
| && (z.imag != 0.)) { |
| if (z.real > 0) { |
| r.real = copysign(INF, cos(z.imag)); |
| r.imag = copysign(INF, sin(z.imag)); |
| } |
| else { |
| r.real = -copysign(INF, cos(z.imag)); |
| r.imag = copysign(INF, sin(z.imag)); |
| } |
| } |
| else { |
| r = sinh_special_values[special_type(z.real)] |
| [special_type(z.imag)]; |
| } |
| /* need to set errno = EDOM if y is +/- infinity and x is not |
| a NaN */ |
| if (Py_IS_INFINITY(z.imag) && !Py_IS_NAN(z.real)) |
| errno = EDOM; |
| else |
| errno = 0; |
| return r; |
| } |
| |
| if (fabs(z.real) > CM_LOG_LARGE_DOUBLE) { |
| x_minus_one = z.real - copysign(1., z.real); |
| r.real = cos(z.imag) * sinh(x_minus_one) * Py_MATH_E; |
| r.imag = sin(z.imag) * cosh(x_minus_one) * Py_MATH_E; |
| } else { |
| r.real = cos(z.imag) * sinh(z.real); |
| r.imag = sin(z.imag) * cosh(z.real); |
| } |
| /* detect overflow, and set errno accordingly */ |
| if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag)) |
| errno = ERANGE; |
| else |
| errno = 0; |
| return r; |
| } |
| |
| |
| static Py_complex sqrt_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.sqrt = cmath.acos |
| |
| Return the square root of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_sqrt_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=b6507b3029c339fc input=7088b166fc9a58c7]*/ |
| { |
| /* |
| Method: use symmetries to reduce to the case when x = z.real and y |
| = z.imag are nonnegative. Then the real part of the result is |
| given by |
| |
| s = sqrt((x + hypot(x, y))/2) |
| |
| and the imaginary part is |
| |
| d = (y/2)/s |
| |
| If either x or y is very large then there's a risk of overflow in |
| computation of the expression x + hypot(x, y). We can avoid this |
| by rewriting the formula for s as: |
| |
| s = 2*sqrt(x/8 + hypot(x/8, y/8)) |
| |
| This costs us two extra multiplications/divisions, but avoids the |
| overhead of checking for x and y large. |
| |
| If both x and y are subnormal then hypot(x, y) may also be |
| subnormal, so will lack full precision. We solve this by rescaling |
| x and y by a sufficiently large power of 2 to ensure that x and y |
| are normal. |
| */ |
| |
| |
| Py_complex r; |
| double s,d; |
| double ax, ay; |
| |
| SPECIAL_VALUE(z, sqrt_special_values); |
| |
| if (z.real == 0. && z.imag == 0.) { |
| r.real = 0.; |
| r.imag = z.imag; |
| return r; |
| } |
| |
| ax = fabs(z.real); |
| ay = fabs(z.imag); |
| |
| if (ax < DBL_MIN && ay < DBL_MIN && (ax > 0. || ay > 0.)) { |
| /* here we catch cases where hypot(ax, ay) is subnormal */ |
| ax = ldexp(ax, CM_SCALE_UP); |
| s = ldexp(sqrt(ax + hypot(ax, ldexp(ay, CM_SCALE_UP))), |
| CM_SCALE_DOWN); |
| } else { |
| ax /= 8.; |
| s = 2.*sqrt(ax + hypot(ax, ay/8.)); |
| } |
| d = ay/(2.*s); |
| |
| if (z.real >= 0.) { |
| r.real = s; |
| r.imag = copysign(d, z.imag); |
| } else { |
| r.real = d; |
| r.imag = copysign(s, z.imag); |
| } |
| errno = 0; |
| return r; |
| } |
| |
| |
| /*[clinic input] |
| cmath.tan = cmath.acos |
| |
| Return the tangent of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_tan_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=7c5f13158a72eb13 input=fc167e528767888e]*/ |
| { |
| /* tan(z) = -i tanh(iz) */ |
| Py_complex s, r; |
| s.real = -z.imag; |
| s.imag = z.real; |
| s = cmath_tanh_impl(module, s); |
| r.real = s.imag; |
| r.imag = -s.real; |
| return r; |
| } |
| |
| |
| /* tanh(infinity + i*y) needs to be dealt with specially */ |
| static Py_complex tanh_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.tanh = cmath.acos |
| |
| Return the hyperbolic tangent of z. |
| [clinic start generated code]*/ |
| |
| static Py_complex |
| cmath_tanh_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=36d547ef7aca116c input=22f67f9dc6d29685]*/ |
| { |
| /* Formula: |
| |
| tanh(x+iy) = (tanh(x)(1+tan(y)^2) + i tan(y)(1-tanh(x))^2) / |
| (1+tan(y)^2 tanh(x)^2) |
| |
| To avoid excessive roundoff error, 1-tanh(x)^2 is better computed |
| as 1/cosh(x)^2. When abs(x) is large, we approximate 1-tanh(x)^2 |
| by 4 exp(-2*x) instead, to avoid possible overflow in the |
| computation of cosh(x). |
| |
| */ |
| |
| Py_complex r; |
| double tx, ty, cx, txty, denom; |
| |
| /* special treatment for tanh(+/-inf + iy) if y is finite and |
| nonzero */ |
| if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) { |
| if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag) |
| && (z.imag != 0.)) { |
| if (z.real > 0) { |
| r.real = 1.0; |
| r.imag = copysign(0., |
| 2.*sin(z.imag)*cos(z.imag)); |
| } |
| else { |
| r.real = -1.0; |
| r.imag = copysign(0., |
| 2.*sin(z.imag)*cos(z.imag)); |
| } |
| } |
| else { |
| r = tanh_special_values[special_type(z.real)] |
| [special_type(z.imag)]; |
| } |
| /* need to set errno = EDOM if z.imag is +/-infinity and |
| z.real is finite */ |
| if (Py_IS_INFINITY(z.imag) && Py_IS_FINITE(z.real)) |
| errno = EDOM; |
| else |
| errno = 0; |
| return r; |
| } |
| |
| /* danger of overflow in 2.*z.imag !*/ |
| if (fabs(z.real) > CM_LOG_LARGE_DOUBLE) { |
| r.real = copysign(1., z.real); |
| r.imag = 4.*sin(z.imag)*cos(z.imag)*exp(-2.*fabs(z.real)); |
| } else { |
| tx = tanh(z.real); |
| ty = tan(z.imag); |
| cx = 1./cosh(z.real); |
| txty = tx*ty; |
| denom = 1. + txty*txty; |
| r.real = tx*(1.+ty*ty)/denom; |
| r.imag = ((ty/denom)*cx)*cx; |
| } |
| errno = 0; |
| return r; |
| } |
| |
| |
| /*[clinic input] |
| cmath.log |
| |
| z as x: Py_complex |
| base as y_obj: object = NULL |
| / |
| |
| log(z[, base]) -> the logarithm of z to the given base. |
| |
| If the base not specified, returns the natural logarithm (base e) of z. |
| [clinic start generated code]*/ |
| |
| static PyObject * |
| cmath_log_impl(PyObject *module, Py_complex x, PyObject *y_obj) |
| /*[clinic end generated code: output=4effdb7d258e0d94 input=230ed3a71ecd000a]*/ |
| { |
| Py_complex y; |
| |
| errno = 0; |
| x = c_log(x); |
| if (y_obj != NULL) { |
| y = PyComplex_AsCComplex(y_obj); |
| if (PyErr_Occurred()) { |
| return NULL; |
| } |
| y = c_log(y); |
| x = _Py_c_quot(x, y); |
| } |
| if (errno != 0) |
| return math_error(); |
| return PyComplex_FromCComplex(x); |
| } |
| |
| |
| /* And now the glue to make them available from Python: */ |
| |
| static PyObject * |
| math_error(void) |
| { |
| if (errno == EDOM) |
| PyErr_SetString(PyExc_ValueError, "math domain error"); |
| else if (errno == ERANGE) |
| PyErr_SetString(PyExc_OverflowError, "math range error"); |
| else /* Unexpected math error */ |
| PyErr_SetFromErrno(PyExc_ValueError); |
| return NULL; |
| } |
| |
| |
| /*[clinic input] |
| cmath.phase |
| |
| z: Py_complex |
| / |
| |
| Return argument, also known as the phase angle, of a complex. |
| [clinic start generated code]*/ |
| |
| static PyObject * |
| cmath_phase_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=50725086a7bfd253 input=5cf75228ba94b69d]*/ |
| { |
| double phi; |
| |
| errno = 0; |
| phi = c_atan2(z); |
| if (errno != 0) |
| return math_error(); |
| else |
| return PyFloat_FromDouble(phi); |
| } |
| |
| /*[clinic input] |
| cmath.polar |
| |
| z: Py_complex |
| / |
| |
| Convert a complex from rectangular coordinates to polar coordinates. |
| |
| r is the distance from 0 and phi the phase angle. |
| [clinic start generated code]*/ |
| |
| static PyObject * |
| cmath_polar_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=d0a8147c41dbb654 input=26c353574fd1a861]*/ |
| { |
| double r, phi; |
| |
| errno = 0; |
| phi = c_atan2(z); /* should not cause any exception */ |
| r = _Py_c_abs(z); /* sets errno to ERANGE on overflow */ |
| if (errno != 0) |
| return math_error(); |
| else |
| return Py_BuildValue("dd", r, phi); |
| } |
| |
| /* |
| rect() isn't covered by the C99 standard, but it's not too hard to |
| figure out 'spirit of C99' rules for special value handing: |
| |
| rect(x, t) should behave like exp(log(x) + it) for positive-signed x |
| rect(x, t) should behave like -exp(log(-x) + it) for negative-signed x |
| rect(nan, t) should behave like exp(nan + it), except that rect(nan, 0) |
| gives nan +- i0 with the sign of the imaginary part unspecified. |
| |
| */ |
| |
| static Py_complex rect_special_values[7][7]; |
| |
| /*[clinic input] |
| cmath.rect |
| |
| r: double |
| phi: double |
| / |
| |
| Convert from polar coordinates to rectangular coordinates. |
| [clinic start generated code]*/ |
| |
| static PyObject * |
| cmath_rect_impl(PyObject *module, double r, double phi) |
| /*[clinic end generated code: output=385a0690925df2d5 input=24c5646d147efd69]*/ |
| { |
| Py_complex z; |
| errno = 0; |
| |
| /* deal with special values */ |
| if (!Py_IS_FINITE(r) || !Py_IS_FINITE(phi)) { |
| /* if r is +/-infinity and phi is finite but nonzero then |
| result is (+-INF +-INF i), but we need to compute cos(phi) |
| and sin(phi) to figure out the signs. */ |
| if (Py_IS_INFINITY(r) && (Py_IS_FINITE(phi) |
| && (phi != 0.))) { |
| if (r > 0) { |
| z.real = copysign(INF, cos(phi)); |
| z.imag = copysign(INF, sin(phi)); |
| } |
| else { |
| z.real = -copysign(INF, cos(phi)); |
| z.imag = -copysign(INF, sin(phi)); |
| } |
| } |
| else { |
| z = rect_special_values[special_type(r)] |
| [special_type(phi)]; |
| } |
| /* need to set errno = EDOM if r is a nonzero number and phi |
| is infinite */ |
| if (r != 0. && !Py_IS_NAN(r) && Py_IS_INFINITY(phi)) |
| errno = EDOM; |
| else |
| errno = 0; |
| } |
| else if (phi == 0.0) { |
| /* Workaround for buggy results with phi=-0.0 on OS X 10.8. See |
| bugs.python.org/issue18513. */ |
| z.real = r; |
| z.imag = r * phi; |
| errno = 0; |
| } |
| else { |
| z.real = r * cos(phi); |
| z.imag = r * sin(phi); |
| errno = 0; |
| } |
| |
| if (errno != 0) |
| return math_error(); |
| else |
| return PyComplex_FromCComplex(z); |
| } |
| |
| /*[clinic input] |
| cmath.isfinite = cmath.polar |
| |
| Return True if both the real and imaginary parts of z are finite, else False. |
| [clinic start generated code]*/ |
| |
| static PyObject * |
| cmath_isfinite_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=ac76611e2c774a36 input=848e7ee701895815]*/ |
| { |
| return PyBool_FromLong(Py_IS_FINITE(z.real) && Py_IS_FINITE(z.imag)); |
| } |
| |
| /*[clinic input] |
| cmath.isnan = cmath.polar |
| |
| Checks if the real or imaginary part of z not a number (NaN). |
| [clinic start generated code]*/ |
| |
| static PyObject * |
| cmath_isnan_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=e7abf6e0b28beab7 input=71799f5d284c9baf]*/ |
| { |
| return PyBool_FromLong(Py_IS_NAN(z.real) || Py_IS_NAN(z.imag)); |
| } |
| |
| /*[clinic input] |
| cmath.isinf = cmath.polar |
| |
| Checks if the real or imaginary part of z is infinite. |
| [clinic start generated code]*/ |
| |
| static PyObject * |
| cmath_isinf_impl(PyObject *module, Py_complex z) |
| /*[clinic end generated code: output=502a75a79c773469 input=363df155c7181329]*/ |
| { |
| return PyBool_FromLong(Py_IS_INFINITY(z.real) || |
| Py_IS_INFINITY(z.imag)); |
| } |
| |
| /*[clinic input] |
| cmath.isclose -> bool |
| |
| a: Py_complex |
| b: Py_complex |
| * |
| rel_tol: double = 1e-09 |
| maximum difference for being considered "close", relative to the |
| magnitude of the input values |
| abs_tol: double = 0.0 |
| maximum difference for being considered "close", regardless of the |
| magnitude of the input values |
| |
| Determine whether two complex numbers are close in value. |
| |
| Return True if a is close in value to b, and False otherwise. |
| |
| For the values to be considered close, the difference between them must be |
| smaller than at least one of the tolerances. |
| |
| -inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is |
| not close to anything, even itself. inf and -inf are only close to themselves. |
| [clinic start generated code]*/ |
| |
| static int |
| cmath_isclose_impl(PyObject *module, Py_complex a, Py_complex b, |
| double rel_tol, double abs_tol) |
| /*[clinic end generated code: output=8a2486cc6e0014d1 input=df9636d7de1d4ac3]*/ |
| { |
| double diff; |
| |
| /* sanity check on the inputs */ |
| if (rel_tol < 0.0 || abs_tol < 0.0 ) { |
| PyErr_SetString(PyExc_ValueError, |
| "tolerances must be non-negative"); |
| return -1; |
| } |
| |
| if ( (a.real == b.real) && (a.imag == b.imag) ) { |
| /* short circuit exact equality -- needed to catch two infinities of |
| the same sign. And perhaps speeds things up a bit sometimes. |
| */ |
| return 1; |
| } |
| |
| /* This catches the case of two infinities of opposite sign, or |
| one infinity and one finite number. Two infinities of opposite |
| sign would otherwise have an infinite relative tolerance. |
| Two infinities of the same sign are caught by the equality check |
| above. |
| */ |
| |
| if (Py_IS_INFINITY(a.real) || Py_IS_INFINITY(a.imag) || |
| Py_IS_INFINITY(b.real) || Py_IS_INFINITY(b.imag)) { |
| return 0; |
| } |
| |
| /* now do the regular computation |
| this is essentially the "weak" test from the Boost library |
| */ |
| |
| diff = _Py_c_abs(_Py_c_diff(a, b)); |
| |
| return (((diff <= rel_tol * _Py_c_abs(b)) || |
| (diff <= rel_tol * _Py_c_abs(a))) || |
| (diff <= abs_tol)); |
| } |
| |
| PyDoc_STRVAR(module_doc, |
| "This module provides access to mathematical functions for complex\n" |
| "numbers."); |
| |
| static PyMethodDef cmath_methods[] = { |
| CMATH_ACOS_METHODDEF |
| CMATH_ACOSH_METHODDEF |
| CMATH_ASIN_METHODDEF |
| CMATH_ASINH_METHODDEF |
| CMATH_ATAN_METHODDEF |
| CMATH_ATANH_METHODDEF |
| CMATH_COS_METHODDEF |
| CMATH_COSH_METHODDEF |
| CMATH_EXP_METHODDEF |
| CMATH_ISCLOSE_METHODDEF |
| CMATH_ISFINITE_METHODDEF |
| CMATH_ISINF_METHODDEF |
| CMATH_ISNAN_METHODDEF |
| CMATH_LOG_METHODDEF |
| CMATH_LOG10_METHODDEF |
| CMATH_PHASE_METHODDEF |
| CMATH_POLAR_METHODDEF |
| CMATH_RECT_METHODDEF |
| CMATH_SIN_METHODDEF |
| CMATH_SINH_METHODDEF |
| CMATH_SQRT_METHODDEF |
| CMATH_TAN_METHODDEF |
| CMATH_TANH_METHODDEF |
| {NULL, NULL} /* sentinel */ |
| }; |
| |
| static int |
| cmath_exec(PyObject *mod) |
| { |
| if (PyModule_AddObject(mod, "pi", PyFloat_FromDouble(Py_MATH_PI)) < 0) { |
| return -1; |
| } |
| if (PyModule_AddObject(mod, "e", PyFloat_FromDouble(Py_MATH_E)) < 0) { |
| return -1; |
| } |
| // 2pi |
| if (PyModule_AddObject(mod, "tau", PyFloat_FromDouble(Py_MATH_TAU)) < 0) { |
| return -1; |
| } |
| if (PyModule_AddObject(mod, "inf", PyFloat_FromDouble(m_inf())) < 0) { |
| return -1; |
| } |
| |
| if (PyModule_AddObject(mod, "infj", |
| PyComplex_FromCComplex(c_infj())) < 0) { |
| return -1; |
| } |
| #if !defined(PY_NO_SHORT_FLOAT_REPR) || defined(Py_NAN) |
| if (PyModule_AddObject(mod, "nan", PyFloat_FromDouble(m_nan())) < 0) { |
| return -1; |
| } |
| if (PyModule_AddObject(mod, "nanj", |
| PyComplex_FromCComplex(c_nanj())) < 0) { |
| return -1; |
| } |
| #endif |
| |
| /* initialize special value tables */ |
| |
| #define INIT_SPECIAL_VALUES(NAME, BODY) { Py_complex* p = (Py_complex*)NAME; BODY } |
| #define C(REAL, IMAG) p->real = REAL; p->imag = IMAG; ++p; |
| |
| INIT_SPECIAL_VALUES(acos_special_values, { |
| C(P34,INF) C(P,INF) C(P,INF) C(P,-INF) C(P,-INF) C(P34,-INF) C(N,INF) |
| C(P12,INF) C(U,U) C(U,U) C(U,U) C(U,U) C(P12,-INF) C(N,N) |
| C(P12,INF) C(U,U) C(P12,0.) C(P12,-0.) C(U,U) C(P12,-INF) C(P12,N) |
| C(P12,INF) C(U,U) C(P12,0.) C(P12,-0.) C(U,U) C(P12,-INF) C(P12,N) |
| C(P12,INF) C(U,U) C(U,U) C(U,U) C(U,U) C(P12,-INF) C(N,N) |
| C(P14,INF) C(0.,INF) C(0.,INF) C(0.,-INF) C(0.,-INF) C(P14,-INF) C(N,INF) |
| C(N,INF) C(N,N) C(N,N) C(N,N) C(N,N) C(N,-INF) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(acosh_special_values, { |
| C(INF,-P34) C(INF,-P) C(INF,-P) C(INF,P) C(INF,P) C(INF,P34) C(INF,N) |
| C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(0.,-P12) C(0.,P12) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(0.,-P12) C(0.,P12) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P14) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,P14) C(INF,N) |
| C(INF,N) C(N,N) C(N,N) C(N,N) C(N,N) C(INF,N) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(asinh_special_values, { |
| C(-INF,-P14) C(-INF,-0.) C(-INF,-0.) C(-INF,0.) C(-INF,0.) C(-INF,P14) C(-INF,N) |
| C(-INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(-INF,P12) C(N,N) |
| C(-INF,-P12) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(-INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P14) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,P14) C(INF,N) |
| C(INF,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(INF,N) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(atanh_special_values, { |
| C(-0.,-P12) C(-0.,-P12) C(-0.,-P12) C(-0.,P12) C(-0.,P12) C(-0.,P12) C(-0.,N) |
| C(-0.,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(-0.,P12) C(N,N) |
| C(-0.,-P12) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(-0.,P12) C(-0.,N) |
| C(0.,-P12) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,P12) C(0.,N) |
| C(0.,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(0.,P12) C(N,N) |
| C(0.,-P12) C(0.,-P12) C(0.,-P12) C(0.,P12) C(0.,P12) C(0.,P12) C(0.,N) |
| C(0.,-P12) C(N,N) C(N,N) C(N,N) C(N,N) C(0.,P12) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(cosh_special_values, { |
| C(INF,N) C(U,U) C(INF,0.) C(INF,-0.) C(U,U) C(INF,N) C(INF,N) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(N,0.) C(U,U) C(1.,0.) C(1.,-0.) C(U,U) C(N,0.) C(N,0.) |
| C(N,0.) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(N,0.) C(N,0.) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N) |
| C(N,N) C(N,N) C(N,0.) C(N,0.) C(N,N) C(N,N) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(exp_special_values, { |
| C(0.,0.) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,0.) C(0.,0.) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(N,N) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(N,N) C(N,N) |
| C(N,N) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(N,N) C(N,N) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N) |
| C(N,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(N,N) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(log_special_values, { |
| C(INF,-P34) C(INF,-P) C(INF,-P) C(INF,P) C(INF,P) C(INF,P34) C(INF,N) |
| C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(-INF,-P) C(-INF,P) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(-INF,-0.) C(-INF,0.) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N) |
| C(INF,-P14) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,P14) C(INF,N) |
| C(INF,N) C(N,N) C(N,N) C(N,N) C(N,N) C(INF,N) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(sinh_special_values, { |
| C(INF,N) C(U,U) C(-INF,-0.) C(-INF,0.) C(U,U) C(INF,N) C(INF,N) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(0.,N) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(0.,N) C(0.,N) |
| C(0.,N) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,N) C(0.,N) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N) |
| C(N,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(N,N) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(sqrt_special_values, { |
| C(INF,-INF) C(0.,-INF) C(0.,-INF) C(0.,INF) C(0.,INF) C(INF,INF) C(N,INF) |
| C(INF,-INF) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,INF) C(N,N) |
| C(INF,-INF) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(INF,INF) C(N,N) |
| C(INF,-INF) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(INF,INF) C(N,N) |
| C(INF,-INF) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,INF) C(N,N) |
| C(INF,-INF) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,INF) C(INF,N) |
| C(INF,-INF) C(N,N) C(N,N) C(N,N) C(N,N) C(INF,INF) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(tanh_special_values, { |
| C(-1.,0.) C(U,U) C(-1.,-0.) C(-1.,0.) C(U,U) C(-1.,0.) C(-1.,0.) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(N,N) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(N,N) C(N,N) |
| C(N,N) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(N,N) C(N,N) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(1.,0.) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(1.,0.) C(1.,0.) |
| C(N,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(N,N) C(N,N) |
| }) |
| |
| INIT_SPECIAL_VALUES(rect_special_values, { |
| C(INF,N) C(U,U) C(-INF,0.) C(-INF,-0.) C(U,U) C(INF,N) C(INF,N) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(0.,0.) C(U,U) C(-0.,0.) C(-0.,-0.) C(U,U) C(0.,0.) C(0.,0.) |
| C(0.,0.) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,0.) C(0.,0.) |
| C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N) |
| C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N) |
| C(N,N) C(N,N) C(N,0.) C(N,0.) C(N,N) C(N,N) C(N,N) |
| }) |
| return 0; |
| } |
| |
| static PyModuleDef_Slot cmath_slots[] = { |
| {Py_mod_exec, cmath_exec}, |
| {0, NULL} |
| }; |
| |
| static struct PyModuleDef cmathmodule = { |
| PyModuleDef_HEAD_INIT, |
| .m_name = "cmath", |
| .m_doc = module_doc, |
| .m_size = 0, |
| .m_methods = cmath_methods, |
| .m_slots = cmath_slots |
| }; |
| |
| PyMODINIT_FUNC |
| PyInit_cmath(void) |
| { |
| return PyModuleDef_Init(&cmathmodule); |
| } |