/* Complex math module */ /* much code borrowed from mathmodule.c */ #ifndef Py_BUILD_CORE_BUILTIN #define Py_BUILD_CORE_MODULE … #endif #include "Python.h" #include "pycore_complexobject.h" // _Py_c_neg() #include "pycore_pymath.h" // _PY_SHORT_FLOAT_REPR /* 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> /* For _Py_log1p with workarounds for buggy handling of zeros. */ #include "_math.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 … #endif #ifndef M_LN10 #define M_LN10 … #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 … #define CM_SQRT_LARGE_DOUBLE … #define CM_LOG_LARGE_DOUBLE … #define CM_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 … #elif FLT_RADIX==16 #define CM_SCALE_UP … #endif #define CM_SCALE_DOWN … /* 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 { … }; static enum special_types special_type(double d) { … } #define SPECIAL_VALUE(z, table) … #define P … #define P14 … #define P12 … #define P34 … #define INF … #define N … #define U … /* 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]*/ { … } 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]*/ { … } /*[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]*/ { … } 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]*/ { … } /*[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]*/ { … } 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]*/ { … } /*[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]*/ { … } /* 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]*/ { … } /* 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]*/ { … } static Py_complex log_special_values[7][7]; static Py_complex c_log(Py_complex z) { … } /*[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]*/ { … } /*[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]*/ { … } /* 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]*/ { … } 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]*/ { … } /*[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]*/ { … } /* 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]*/ { … } /*[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 is 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=e1f81d4fcfd26497]*/ { … } /* And now the glue to make them available from Python: */ static PyObject * math_error(void) { … } /*[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]*/ { … } /*[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]*/ { … } /* 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]*/ { … } /*[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]*/ { … } /*[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]*/ { … } /*[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]*/ { … } /*[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]*/ { … } PyDoc_STRVAR(module_doc, "This module provides access to mathematical functions for complex\n" "numbers."); static PyMethodDef cmath_methods[] = …; static int cmath_exec(PyObject *mod) { … } static PyModuleDef_Slot cmath_slots[] = …; static struct PyModuleDef cmathmodule = …; PyMODINIT_FUNC PyInit_cmath(void) { … }
Codebase Browser
cpython