1
/* Complex math module */
3
/* much code borrowed from mathmodule.c */
6
/* we need DBL_MAX, DBL_MIN, DBL_EPSILON, DBL_MANT_DIG and FLT_RADIX from
7
float.h. We assume that FLT_RADIX is either 2 or 16. */
10
#if (FLT_RADIX != 2 && FLT_RADIX != 16)
11
#error "Modules/cmathmodule.c expects FLT_RADIX to be 2 or 16"
15
#define M_LN2 (0.6931471805599453094) /* natural log of 2 */
19
#define M_LN10 (2.302585092994045684) /* natural log of 10 */
23
CM_LARGE_DOUBLE is used to avoid spurious overflow in the sqrt, log,
24
inverse trig and inverse hyperbolic trig functions. Its log is used in the
25
evaluation of exp, cos, cosh, sin, sinh, tan, and tanh to avoid unecessary
29
#define CM_LARGE_DOUBLE (DBL_MAX/4.)
30
#define CM_SQRT_LARGE_DOUBLE (sqrt(CM_LARGE_DOUBLE))
31
#define CM_LOG_LARGE_DOUBLE (log(CM_LARGE_DOUBLE))
32
#define CM_SQRT_DBL_MIN (sqrt(DBL_MIN))
35
CM_SCALE_UP is an odd integer chosen such that multiplication by
36
2**CM_SCALE_UP is sufficient to turn a subnormal into a normal.
37
CM_SCALE_DOWN is (-(CM_SCALE_UP+1)/2). These scalings are used to compute
38
square roots accurately when the real and imaginary parts of the argument
43
#define CM_SCALE_UP (2*(DBL_MANT_DIG/2) + 1)
45
#define CM_SCALE_UP (4*DBL_MANT_DIG+1)
47
#define CM_SCALE_DOWN (-(CM_SCALE_UP+1)/2)
49
/* forward declarations */
50
static Py_complex c_asinh(Py_complex);
51
static Py_complex c_atanh(Py_complex);
52
static Py_complex c_cosh(Py_complex);
53
static Py_complex c_sinh(Py_complex);
54
static Py_complex c_sqrt(Py_complex);
55
static Py_complex c_tanh(Py_complex);
56
static PyObject * math_error(void);
58
/* Code to deal with special values (infinities, NaNs, etc.). */
60
/* special_type takes a double and returns an integer code indicating
61
the type of the double as follows:
65
ST_NINF, /* 0, negative infinity */
66
ST_NEG, /* 1, negative finite number (nonzero) */
67
ST_NZERO, /* 2, -0. */
68
ST_PZERO, /* 3, +0. */
69
ST_POS, /* 4, positive finite number (nonzero) */
70
ST_PINF, /* 5, positive infinity */
71
ST_NAN, /* 6, Not a Number */
74
static enum special_types
75
special_type(double d)
77
if (Py_IS_FINITE(d)) {
79
if (copysign(1., d) == 1.)
85
if (copysign(1., d) == 1.)
93
if (copysign(1., d) == 1.)
99
#define SPECIAL_VALUE(z, table) \
100
if (!Py_IS_FINITE((z).real) || !Py_IS_FINITE((z).imag)) { \
102
return table[special_type((z).real)] \
103
[special_type((z).imag)]; \
107
#define P14 0.25*Py_MATH_PI
108
#define P12 0.5*Py_MATH_PI
109
#define P34 0.75*Py_MATH_PI
110
#define INF Py_HUGE_VAL
112
#define U -9.5426319407711027e33 /* unlikely value, used as placeholder */
114
/* First, the C functions that do the real work. Each of the c_*
115
functions computes and returns the C99 Annex G recommended result
116
and also sets errno as follows: errno = 0 if no floating-point
117
exception is associated with the result; errno = EDOM if C99 Annex
118
G recommends raising divide-by-zero or invalid for this result; and
119
errno = ERANGE where the overflow floating-point signal should be
123
static Py_complex acos_special_values[7][7];
128
Py_complex s1, s2, r;
130
SPECIAL_VALUE(z, acos_special_values);
132
if (fabs(z.real) > CM_LARGE_DOUBLE || fabs(z.imag) > CM_LARGE_DOUBLE) {
133
/* avoid unnecessary overflow for large arguments */
134
r.real = atan2(fabs(z.imag), z.real);
135
/* split into cases to make sure that the branch cut has the
136
correct continuity on systems with unsigned zeros */
138
r.imag = -copysign(log(hypot(z.real/2., z.imag/2.)) +
141
r.imag = copysign(log(hypot(z.real/2., z.imag/2.)) +
151
r.real = 2.*atan2(s1.real, s2.real);
152
r.imag = asinh(s2.real*s1.imag - s2.imag*s1.real);
158
PyDoc_STRVAR(c_acos_doc,
161
"Return the arc cosine of x.");
164
static Py_complex acosh_special_values[7][7];
167
c_acosh(Py_complex z)
169
Py_complex s1, s2, r;
171
SPECIAL_VALUE(z, acosh_special_values);
173
if (fabs(z.real) > CM_LARGE_DOUBLE || fabs(z.imag) > CM_LARGE_DOUBLE) {
174
/* avoid unnecessary overflow for large arguments */
175
r.real = log(hypot(z.real/2., z.imag/2.)) + M_LN2*2.;
176
r.imag = atan2(z.imag, z.real);
178
s1.real = z.real - 1.;
181
s2.real = z.real + 1.;
184
r.real = asinh(s1.real*s2.real + s1.imag*s2.imag);
185
r.imag = 2.*atan2(s1.imag, s2.real);
191
PyDoc_STRVAR(c_acosh_doc,
194
"Return the hyperbolic arccosine of x.");
200
/* asin(z) = -i asinh(iz) */
210
PyDoc_STRVAR(c_asin_doc,
213
"Return the arc sine of x.");
216
static Py_complex asinh_special_values[7][7];
219
c_asinh(Py_complex z)
221
Py_complex s1, s2, r;
223
SPECIAL_VALUE(z, asinh_special_values);
225
if (fabs(z.real) > CM_LARGE_DOUBLE || fabs(z.imag) > CM_LARGE_DOUBLE) {
227
r.real = copysign(log(hypot(z.real/2., z.imag/2.)) +
230
r.real = -copysign(log(hypot(z.real/2., z.imag/2.)) +
233
r.imag = atan2(z.imag, fabs(z.real));
241
r.real = asinh(s1.real*s2.imag-s2.real*s1.imag);
242
r.imag = atan2(z.imag, s1.real*s2.real-s1.imag*s2.imag);
248
PyDoc_STRVAR(c_asinh_doc,
251
"Return the hyperbolic arc sine of x.");
257
/* atan(z) = -i atanh(iz) */
267
/* Windows screws up atan2 for inf and nan, and alpha Tru64 5.1 doesn't follow
268
C99 for atan2(0., 0.). */
270
c_atan2(Py_complex z)
272
if (Py_IS_NAN(z.real) || Py_IS_NAN(z.imag))
274
if (Py_IS_INFINITY(z.imag)) {
275
if (Py_IS_INFINITY(z.real)) {
276
if (copysign(1., z.real) == 1.)
277
/* atan2(+-inf, +inf) == +-pi/4 */
278
return copysign(0.25*Py_MATH_PI, z.imag);
280
/* atan2(+-inf, -inf) == +-pi*3/4 */
281
return copysign(0.75*Py_MATH_PI, z.imag);
283
/* atan2(+-inf, x) == +-pi/2 for finite x */
284
return copysign(0.5*Py_MATH_PI, z.imag);
286
if (Py_IS_INFINITY(z.real) || z.imag == 0.) {
287
if (copysign(1., z.real) == 1.)
288
/* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
289
return copysign(0., z.imag);
291
/* atan2(+-y, -inf) = atan2(+-0., -x) = +-pi. */
292
return copysign(Py_MATH_PI, z.imag);
294
return atan2(z.imag, z.real);
297
PyDoc_STRVAR(c_atan_doc,
300
"Return the arc tangent of x.");
303
static Py_complex atanh_special_values[7][7];
306
c_atanh(Py_complex z)
311
SPECIAL_VALUE(z, atanh_special_values);
313
/* Reduce to case where z.real >= 0., using atanh(z) = -atanh(-z). */
315
return c_neg(c_atanh(c_neg(z)));
319
if (z.real > CM_SQRT_LARGE_DOUBLE || ay > CM_SQRT_LARGE_DOUBLE) {
321
if abs(z) is large then we use the approximation
322
atanh(z) ~ 1/z +/- i*pi/2 (+/- depending on the sign
325
h = hypot(z.real/2., z.imag/2.); /* safe from overflow */
326
r.real = z.real/4./h/h;
327
/* the two negations in the next line cancel each other out
328
except when working with unsigned zeros: they're there to
329
ensure that the branch cut has the correct continuity on
330
systems that don't support signed zeros */
331
r.imag = -copysign(Py_MATH_PI/2., -z.imag);
333
} else if (z.real == 1. && ay < CM_SQRT_DBL_MIN) {
334
/* C99 standard says: atanh(1+/-0.) should be inf +/- 0i */
340
r.real = -log(sqrt(ay)/sqrt(hypot(ay, 2.)));
341
r.imag = copysign(atan2(2., -ay)/2, z.imag);
345
r.real = log1p(4.*z.real/((1-z.real)*(1-z.real) + ay*ay))/4.;
346
r.imag = -atan2(-2.*z.imag, (1-z.real)*(1+z.real) - ay*ay)/2.;
352
PyDoc_STRVAR(c_atanh_doc,
355
"Return the hyperbolic arc tangent of x.");
361
/* cos(z) = cosh(iz) */
369
PyDoc_STRVAR(c_cos_doc,
372
"Return the cosine of x.");
375
/* cosh(infinity + i*y) needs to be dealt with specially */
376
static Py_complex cosh_special_values[7][7];
384
/* special treatment for cosh(+/-inf + iy) if y is not a NaN */
385
if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
386
if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag) &&
389
r.real = copysign(INF, cos(z.imag));
390
r.imag = copysign(INF, sin(z.imag));
393
r.real = copysign(INF, cos(z.imag));
394
r.imag = -copysign(INF, sin(z.imag));
398
r = cosh_special_values[special_type(z.real)]
399
[special_type(z.imag)];
401
/* need to set errno = EDOM if y is +/- infinity and x is not
403
if (Py_IS_INFINITY(z.imag) && !Py_IS_NAN(z.real))
410
if (fabs(z.real) > CM_LOG_LARGE_DOUBLE) {
411
/* deal correctly with cases where cosh(z.real) overflows but
413
x_minus_one = z.real - copysign(1., z.real);
414
r.real = cos(z.imag) * cosh(x_minus_one) * Py_MATH_E;
415
r.imag = sin(z.imag) * sinh(x_minus_one) * Py_MATH_E;
417
r.real = cos(z.imag) * cosh(z.real);
418
r.imag = sin(z.imag) * sinh(z.real);
420
/* detect overflow, and set errno accordingly */
421
if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag))
428
PyDoc_STRVAR(c_cosh_doc,
431
"Return the hyperbolic cosine of x.");
434
/* exp(infinity + i*y) and exp(-infinity + i*y) need special treatment for
436
static Py_complex exp_special_values[7][7];
444
if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
445
if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag)
448
r.real = copysign(INF, cos(z.imag));
449
r.imag = copysign(INF, sin(z.imag));
452
r.real = copysign(0., cos(z.imag));
453
r.imag = copysign(0., sin(z.imag));
457
r = exp_special_values[special_type(z.real)]
458
[special_type(z.imag)];
460
/* need to set errno = EDOM if y is +/- infinity and x is not
461
a NaN and not -infinity */
462
if (Py_IS_INFINITY(z.imag) &&
463
(Py_IS_FINITE(z.real) ||
464
(Py_IS_INFINITY(z.real) && z.real > 0)))
471
if (z.real > CM_LOG_LARGE_DOUBLE) {
473
r.real = l*cos(z.imag)*Py_MATH_E;
474
r.imag = l*sin(z.imag)*Py_MATH_E;
477
r.real = l*cos(z.imag);
478
r.imag = l*sin(z.imag);
480
/* detect overflow, and set errno accordingly */
481
if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag))
488
PyDoc_STRVAR(c_exp_doc,
491
"Return the exponential value e**x.");
494
static Py_complex log_special_values[7][7];
500
The usual formula for the real part is log(hypot(z.real, z.imag)).
501
There are four situations where this formula is potentially
504
(1) the absolute value of z is subnormal. Then hypot is subnormal,
505
so has fewer than the usual number of bits of accuracy, hence may
506
have large relative error. This then gives a large absolute error
507
in the log. This can be solved by rescaling z by a suitable power
510
(2) the absolute value of z is greater than DBL_MAX (e.g. when both
511
z.real and z.imag are within a factor of 1/sqrt(2) of DBL_MAX)
512
Again, rescaling solves this.
514
(3) the absolute value of z is close to 1. In this case it's
515
difficult to achieve good accuracy, at least in part because a
516
change of 1ulp in the real or imaginary part of z can result in a
517
change of billions of ulps in the correctly rounded answer.
519
(4) z = 0. The simplest thing to do here is to call the
520
floating-point log with an argument of 0, and let its behaviour
521
(returning -infinity, signaling a floating-point exception, setting
522
errno, or whatever) determine that of c_log. So the usual formula
528
double ax, ay, am, an, h;
530
SPECIAL_VALUE(z, log_special_values);
535
if (ax > CM_LARGE_DOUBLE || ay > CM_LARGE_DOUBLE) {
536
r.real = log(hypot(ax/2., ay/2.)) + M_LN2;
537
} else if (ax < DBL_MIN && ay < DBL_MIN) {
538
if (ax > 0. || ay > 0.) {
539
/* catch cases where hypot(ax, ay) is subnormal */
540
r.real = log(hypot(ldexp(ax, DBL_MANT_DIG),
541
ldexp(ay, DBL_MANT_DIG))) - DBL_MANT_DIG*M_LN2;
544
/* log(+/-0. +/- 0i) */
546
r.imag = atan2(z.imag, z.real);
552
if (0.71 <= h && h <= 1.73) {
553
am = ax > ay ? ax : ay; /* max(ax, ay) */
554
an = ax > ay ? ay : ax; /* min(ax, ay) */
555
r.real = log1p((am-1)*(am+1)+an*an)/2.;
560
r.imag = atan2(z.imag, z.real);
567
c_log10(Py_complex z)
573
errno_save = errno; /* just in case the divisions affect errno */
574
r.real = r.real / M_LN10;
575
r.imag = r.imag / M_LN10;
580
PyDoc_STRVAR(c_log10_doc,
583
"Return the base-10 logarithm of x.");
589
/* sin(z) = -i sin(iz) */
599
PyDoc_STRVAR(c_sin_doc,
602
"Return the sine of x.");
605
/* sinh(infinity + i*y) needs to be dealt with specially */
606
static Py_complex sinh_special_values[7][7];
614
/* special treatment for sinh(+/-inf + iy) if y is finite and
616
if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
617
if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag)
620
r.real = copysign(INF, cos(z.imag));
621
r.imag = copysign(INF, sin(z.imag));
624
r.real = -copysign(INF, cos(z.imag));
625
r.imag = copysign(INF, sin(z.imag));
629
r = sinh_special_values[special_type(z.real)]
630
[special_type(z.imag)];
632
/* need to set errno = EDOM if y is +/- infinity and x is not
634
if (Py_IS_INFINITY(z.imag) && !Py_IS_NAN(z.real))
641
if (fabs(z.real) > CM_LOG_LARGE_DOUBLE) {
642
x_minus_one = z.real - copysign(1., z.real);
643
r.real = cos(z.imag) * sinh(x_minus_one) * Py_MATH_E;
644
r.imag = sin(z.imag) * cosh(x_minus_one) * Py_MATH_E;
646
r.real = cos(z.imag) * sinh(z.real);
647
r.imag = sin(z.imag) * cosh(z.real);
649
/* detect overflow, and set errno accordingly */
650
if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag))
657
PyDoc_STRVAR(c_sinh_doc,
660
"Return the hyperbolic sine of x.");
663
static Py_complex sqrt_special_values[7][7];
669
Method: use symmetries to reduce to the case when x = z.real and y
670
= z.imag are nonnegative. Then the real part of the result is
673
s = sqrt((x + hypot(x, y))/2)
675
and the imaginary part is
679
If either x or y is very large then there's a risk of overflow in
680
computation of the expression x + hypot(x, y). We can avoid this
681
by rewriting the formula for s as:
683
s = 2*sqrt(x/8 + hypot(x/8, y/8))
685
This costs us two extra multiplications/divisions, but avoids the
686
overhead of checking for x and y large.
688
If both x and y are subnormal then hypot(x, y) may also be
689
subnormal, so will lack full precision. We solve this by rescaling
690
x and y by a sufficiently large power of 2 to ensure that x and y
699
SPECIAL_VALUE(z, sqrt_special_values);
701
if (z.real == 0. && z.imag == 0.) {
710
if (ax < DBL_MIN && ay < DBL_MIN && (ax > 0. || ay > 0.)) {
711
/* here we catch cases where hypot(ax, ay) is subnormal */
712
ax = ldexp(ax, CM_SCALE_UP);
713
s = ldexp(sqrt(ax + hypot(ax, ldexp(ay, CM_SCALE_UP))),
717
s = 2.*sqrt(ax + hypot(ax, ay/8.));
723
r.imag = copysign(d, z.imag);
726
r.imag = copysign(s, z.imag);
732
PyDoc_STRVAR(c_sqrt_doc,
735
"Return the square root of x.");
741
/* tan(z) = -i tanh(iz) */
751
PyDoc_STRVAR(c_tan_doc,
754
"Return the tangent of x.");
757
/* tanh(infinity + i*y) needs to be dealt with specially */
758
static Py_complex tanh_special_values[7][7];
765
tanh(x+iy) = (tanh(x)(1+tan(y)^2) + i tan(y)(1-tanh(x))^2) /
766
(1+tan(y)^2 tanh(x)^2)
768
To avoid excessive roundoff error, 1-tanh(x)^2 is better computed
769
as 1/cosh(x)^2. When abs(x) is large, we approximate 1-tanh(x)^2
770
by 4 exp(-2*x) instead, to avoid possible overflow in the
771
computation of cosh(x).
776
double tx, ty, cx, txty, denom;
778
/* special treatment for tanh(+/-inf + iy) if y is finite and
780
if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
781
if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag)
785
r.imag = copysign(0.,
786
2.*sin(z.imag)*cos(z.imag));
790
r.imag = copysign(0.,
791
2.*sin(z.imag)*cos(z.imag));
795
r = tanh_special_values[special_type(z.real)]
796
[special_type(z.imag)];
798
/* need to set errno = EDOM if z.imag is +/-infinity and
800
if (Py_IS_INFINITY(z.imag) && Py_IS_FINITE(z.real))
807
/* danger of overflow in 2.*z.imag !*/
808
if (fabs(z.real) > CM_LOG_LARGE_DOUBLE) {
809
r.real = copysign(1., z.real);
810
r.imag = 4.*sin(z.imag)*cos(z.imag)*exp(-2.*fabs(z.real));
814
cx = 1./cosh(z.real);
816
denom = 1. + txty*txty;
817
r.real = tx*(1.+ty*ty)/denom;
818
r.imag = ((ty/denom)*cx)*cx;
824
PyDoc_STRVAR(c_tanh_doc,
827
"Return the hyperbolic tangent of x.");
831
cmath_log(PyObject *self, PyObject *args)
836
if (!PyArg_ParseTuple(args, "D|D", &x, &y))
840
PyFPE_START_PROTECT("complex function", return 0)
842
if (PyTuple_GET_SIZE(args) == 2) {
849
return PyComplex_FromCComplex(x);
852
PyDoc_STRVAR(cmath_log_doc,
853
"log(x[, base]) -> the logarithm of x to the given base.\n\
854
If the base not specified, returns the natural logarithm (base e) of x.");
857
/* And now the glue to make them available from Python: */
863
PyErr_SetString(PyExc_ValueError, "math domain error");
864
else if (errno == ERANGE)
865
PyErr_SetString(PyExc_OverflowError, "math range error");
866
else /* Unexpected math error */
867
PyErr_SetFromErrno(PyExc_ValueError);
872
math_1(PyObject *args, Py_complex (*func)(Py_complex))
875
if (!PyArg_ParseTuple(args, "D", &x))
878
PyFPE_START_PROTECT("complex function", return 0);
880
PyFPE_END_PROTECT(r);
882
PyErr_SetString(PyExc_ValueError, "math domain error");
885
else if (errno == ERANGE) {
886
PyErr_SetString(PyExc_OverflowError, "math range error");
890
return PyComplex_FromCComplex(r);
894
#define FUNC1(stubname, func) \
895
static PyObject * stubname(PyObject *self, PyObject *args) { \
896
return math_1(args, func); \
899
FUNC1(cmath_acos, c_acos)
900
FUNC1(cmath_acosh, c_acosh)
901
FUNC1(cmath_asin, c_asin)
902
FUNC1(cmath_asinh, c_asinh)
903
FUNC1(cmath_atan, c_atan)
904
FUNC1(cmath_atanh, c_atanh)
905
FUNC1(cmath_cos, c_cos)
906
FUNC1(cmath_cosh, c_cosh)
907
FUNC1(cmath_exp, c_exp)
908
FUNC1(cmath_log10, c_log10)
909
FUNC1(cmath_sin, c_sin)
910
FUNC1(cmath_sinh, c_sinh)
911
FUNC1(cmath_sqrt, c_sqrt)
912
FUNC1(cmath_tan, c_tan)
913
FUNC1(cmath_tanh, c_tanh)
916
cmath_phase(PyObject *self, PyObject *args)
920
if (!PyArg_ParseTuple(args, "D:phase", &z))
923
PyFPE_START_PROTECT("arg function", return 0)
925
PyFPE_END_PROTECT(phi)
929
return PyFloat_FromDouble(phi);
932
PyDoc_STRVAR(cmath_phase_doc,
933
"phase(z) -> float\n\n\
934
Return argument, also known as the phase angle, of a complex.");
937
cmath_polar(PyObject *self, PyObject *args)
941
if (!PyArg_ParseTuple(args, "D:polar", &z))
943
PyFPE_START_PROTECT("polar function", return 0)
944
phi = c_atan2(z); /* should not cause any exception */
945
r = c_abs(z); /* sets errno to ERANGE on overflow; otherwise 0 */
950
return Py_BuildValue("dd", r, phi);
953
PyDoc_STRVAR(cmath_polar_doc,
954
"polar(z) -> r: float, phi: float\n\n\
955
Convert a complex from rectangular coordinates to polar coordinates. r is\n\
956
the distance from 0 and phi the phase angle.");
959
rect() isn't covered by the C99 standard, but it's not too hard to
960
figure out 'spirit of C99' rules for special value handing:
962
rect(x, t) should behave like exp(log(x) + it) for positive-signed x
963
rect(x, t) should behave like -exp(log(-x) + it) for negative-signed x
964
rect(nan, t) should behave like exp(nan + it), except that rect(nan, 0)
965
gives nan +- i0 with the sign of the imaginary part unspecified.
969
static Py_complex rect_special_values[7][7];
972
cmath_rect(PyObject *self, PyObject *args)
976
if (!PyArg_ParseTuple(args, "dd:rect", &r, &phi))
979
PyFPE_START_PROTECT("rect function", return 0)
981
/* deal with special values */
982
if (!Py_IS_FINITE(r) || !Py_IS_FINITE(phi)) {
983
/* if r is +/-infinity and phi is finite but nonzero then
984
result is (+-INF +-INF i), but we need to compute cos(phi)
985
and sin(phi) to figure out the signs. */
986
if (Py_IS_INFINITY(r) && (Py_IS_FINITE(phi)
989
z.real = copysign(INF, cos(phi));
990
z.imag = copysign(INF, sin(phi));
993
z.real = -copysign(INF, cos(phi));
994
z.imag = -copysign(INF, sin(phi));
998
z = rect_special_values[special_type(r)]
1001
/* need to set errno = EDOM if r is a nonzero number and phi
1003
if (r != 0. && !Py_IS_NAN(r) && Py_IS_INFINITY(phi))
1009
z.real = r * cos(phi);
1010
z.imag = r * sin(phi);
1014
PyFPE_END_PROTECT(z)
1016
return math_error();
1018
return PyComplex_FromCComplex(z);
1021
PyDoc_STRVAR(cmath_rect_doc,
1022
"rect(r, phi) -> z: complex\n\n\
1023
Convert from polar coordinates to rectangular coordinates.");
1026
cmath_isnan(PyObject *self, PyObject *args)
1029
if (!PyArg_ParseTuple(args, "D:isnan", &z))
1031
return PyBool_FromLong(Py_IS_NAN(z.real) || Py_IS_NAN(z.imag));
1034
PyDoc_STRVAR(cmath_isnan_doc,
1035
"isnan(z) -> bool\n\
1036
Checks if the real or imaginary part of z not a number (NaN)");
1039
cmath_isinf(PyObject *self, PyObject *args)
1042
if (!PyArg_ParseTuple(args, "D:isnan", &z))
1044
return PyBool_FromLong(Py_IS_INFINITY(z.real) ||
1045
Py_IS_INFINITY(z.imag));
1048
PyDoc_STRVAR(cmath_isinf_doc,
1049
"isinf(z) -> bool\n\
1050
Checks if the real or imaginary part of z is infinite.");
1053
PyDoc_STRVAR(module_doc,
1054
"This module is always available. It provides access to mathematical\n"
1055
"functions for complex numbers.");
1057
static PyMethodDef cmath_methods[] = {
1058
{"acos", cmath_acos, METH_VARARGS, c_acos_doc},
1059
{"acosh", cmath_acosh, METH_VARARGS, c_acosh_doc},
1060
{"asin", cmath_asin, METH_VARARGS, c_asin_doc},
1061
{"asinh", cmath_asinh, METH_VARARGS, c_asinh_doc},
1062
{"atan", cmath_atan, METH_VARARGS, c_atan_doc},
1063
{"atanh", cmath_atanh, METH_VARARGS, c_atanh_doc},
1064
{"cos", cmath_cos, METH_VARARGS, c_cos_doc},
1065
{"cosh", cmath_cosh, METH_VARARGS, c_cosh_doc},
1066
{"exp", cmath_exp, METH_VARARGS, c_exp_doc},
1067
{"isinf", cmath_isinf, METH_VARARGS, cmath_isinf_doc},
1068
{"isnan", cmath_isnan, METH_VARARGS, cmath_isnan_doc},
1069
{"log", cmath_log, METH_VARARGS, cmath_log_doc},
1070
{"log10", cmath_log10, METH_VARARGS, c_log10_doc},
1071
{"phase", cmath_phase, METH_VARARGS, cmath_phase_doc},
1072
{"polar", cmath_polar, METH_VARARGS, cmath_polar_doc},
1073
{"rect", cmath_rect, METH_VARARGS, cmath_rect_doc},
1074
{"sin", cmath_sin, METH_VARARGS, c_sin_doc},
1075
{"sinh", cmath_sinh, METH_VARARGS, c_sinh_doc},
1076
{"sqrt", cmath_sqrt, METH_VARARGS, c_sqrt_doc},
1077
{"tan", cmath_tan, METH_VARARGS, c_tan_doc},
1078
{"tanh", cmath_tanh, METH_VARARGS, c_tanh_doc},
1079
{NULL, NULL} /* sentinel */
1083
static struct PyModuleDef cmathmodule = {
1084
PyModuleDef_HEAD_INIT,
1100
m = PyModule_Create(&cmathmodule);
1104
PyModule_AddObject(m, "pi",
1105
PyFloat_FromDouble(Py_MATH_PI));
1106
PyModule_AddObject(m, "e", PyFloat_FromDouble(Py_MATH_E));
1108
/* initialize special value tables */
1110
#define INIT_SPECIAL_VALUES(NAME, BODY) { Py_complex* p = (Py_complex*)NAME; BODY }
1111
#define C(REAL, IMAG) p->real = REAL; p->imag = IMAG; ++p;
1113
INIT_SPECIAL_VALUES(acos_special_values, {
1114
C(P34,INF) C(P,INF) C(P,INF) C(P,-INF) C(P,-INF) C(P34,-INF) C(N,INF)
1115
C(P12,INF) C(U,U) C(U,U) C(U,U) C(U,U) C(P12,-INF) C(N,N)
1116
C(P12,INF) C(U,U) C(P12,0.) C(P12,-0.) C(U,U) C(P12,-INF) C(P12,N)
1117
C(P12,INF) C(U,U) C(P12,0.) C(P12,-0.) C(U,U) C(P12,-INF) C(P12,N)
1118
C(P12,INF) C(U,U) C(U,U) C(U,U) C(U,U) C(P12,-INF) C(N,N)
1119
C(P14,INF) C(0.,INF) C(0.,INF) C(0.,-INF) C(0.,-INF) C(P14,-INF) C(N,INF)
1120
C(N,INF) C(N,N) C(N,N) C(N,N) C(N,N) C(N,-INF) C(N,N)
1123
INIT_SPECIAL_VALUES(acosh_special_values, {
1124
C(INF,-P34) C(INF,-P) C(INF,-P) C(INF,P) C(INF,P) C(INF,P34) C(INF,N)
1125
C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N)
1126
C(INF,-P12) C(U,U) C(0.,-P12) C(0.,P12) C(U,U) C(INF,P12) C(N,N)
1127
C(INF,-P12) C(U,U) C(0.,-P12) C(0.,P12) C(U,U) C(INF,P12) C(N,N)
1128
C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N)
1129
C(INF,-P14) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,P14) C(INF,N)
1130
C(INF,N) C(N,N) C(N,N) C(N,N) C(N,N) C(INF,N) C(N,N)
1133
INIT_SPECIAL_VALUES(asinh_special_values, {
1134
C(-INF,-P14) C(-INF,-0.) C(-INF,-0.) C(-INF,0.) C(-INF,0.) C(-INF,P14) C(-INF,N)
1135
C(-INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(-INF,P12) C(N,N)
1136
C(-INF,-P12) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(-INF,P12) C(N,N)
1137
C(INF,-P12) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(INF,P12) C(N,N)
1138
C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N)
1139
C(INF,-P14) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,P14) C(INF,N)
1140
C(INF,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(INF,N) C(N,N)
1143
INIT_SPECIAL_VALUES(atanh_special_values, {
1144
C(-0.,-P12) C(-0.,-P12) C(-0.,-P12) C(-0.,P12) C(-0.,P12) C(-0.,P12) C(-0.,N)
1145
C(-0.,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(-0.,P12) C(N,N)
1146
C(-0.,-P12) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(-0.,P12) C(-0.,N)
1147
C(0.,-P12) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,P12) C(0.,N)
1148
C(0.,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(0.,P12) C(N,N)
1149
C(0.,-P12) C(0.,-P12) C(0.,-P12) C(0.,P12) C(0.,P12) C(0.,P12) C(0.,N)
1150
C(0.,-P12) C(N,N) C(N,N) C(N,N) C(N,N) C(0.,P12) C(N,N)
1153
INIT_SPECIAL_VALUES(cosh_special_values, {
1154
C(INF,N) C(U,U) C(INF,0.) C(INF,-0.) C(U,U) C(INF,N) C(INF,N)
1155
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1156
C(N,0.) C(U,U) C(1.,0.) C(1.,-0.) C(U,U) C(N,0.) C(N,0.)
1157
C(N,0.) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(N,0.) C(N,0.)
1158
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1159
C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N)
1160
C(N,N) C(N,N) C(N,0.) C(N,0.) C(N,N) C(N,N) C(N,N)
1163
INIT_SPECIAL_VALUES(exp_special_values, {
1164
C(0.,0.) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,0.) C(0.,0.)
1165
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1166
C(N,N) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(N,N) C(N,N)
1167
C(N,N) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(N,N) C(N,N)
1168
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1169
C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N)
1170
C(N,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(N,N) C(N,N)
1173
INIT_SPECIAL_VALUES(log_special_values, {
1174
C(INF,-P34) C(INF,-P) C(INF,-P) C(INF,P) C(INF,P) C(INF,P34) C(INF,N)
1175
C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N)
1176
C(INF,-P12) C(U,U) C(-INF,-P) C(-INF,P) C(U,U) C(INF,P12) C(N,N)
1177
C(INF,-P12) C(U,U) C(-INF,-0.) C(-INF,0.) C(U,U) C(INF,P12) C(N,N)
1178
C(INF,-P12) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,P12) C(N,N)
1179
C(INF,-P14) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,P14) C(INF,N)
1180
C(INF,N) C(N,N) C(N,N) C(N,N) C(N,N) C(INF,N) C(N,N)
1183
INIT_SPECIAL_VALUES(sinh_special_values, {
1184
C(INF,N) C(U,U) C(-INF,-0.) C(-INF,0.) C(U,U) C(INF,N) C(INF,N)
1185
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1186
C(0.,N) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(0.,N) C(0.,N)
1187
C(0.,N) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,N) C(0.,N)
1188
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1189
C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N)
1190
C(N,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(N,N) C(N,N)
1193
INIT_SPECIAL_VALUES(sqrt_special_values, {
1194
C(INF,-INF) C(0.,-INF) C(0.,-INF) C(0.,INF) C(0.,INF) C(INF,INF) C(N,INF)
1195
C(INF,-INF) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,INF) C(N,N)
1196
C(INF,-INF) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(INF,INF) C(N,N)
1197
C(INF,-INF) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(INF,INF) C(N,N)
1198
C(INF,-INF) C(U,U) C(U,U) C(U,U) C(U,U) C(INF,INF) C(N,N)
1199
C(INF,-INF) C(INF,-0.) C(INF,-0.) C(INF,0.) C(INF,0.) C(INF,INF) C(INF,N)
1200
C(INF,-INF) C(N,N) C(N,N) C(N,N) C(N,N) C(INF,INF) C(N,N)
1203
INIT_SPECIAL_VALUES(tanh_special_values, {
1204
C(-1.,0.) C(U,U) C(-1.,-0.) C(-1.,0.) C(U,U) C(-1.,0.) C(-1.,0.)
1205
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1206
C(N,N) C(U,U) C(-0.,-0.) C(-0.,0.) C(U,U) C(N,N) C(N,N)
1207
C(N,N) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(N,N) C(N,N)
1208
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1209
C(1.,0.) C(U,U) C(1.,-0.) C(1.,0.) C(U,U) C(1.,0.) C(1.,0.)
1210
C(N,N) C(N,N) C(N,-0.) C(N,0.) C(N,N) C(N,N) C(N,N)
1213
INIT_SPECIAL_VALUES(rect_special_values, {
1214
C(INF,N) C(U,U) C(-INF,0.) C(-INF,-0.) C(U,U) C(INF,N) C(INF,N)
1215
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1216
C(0.,0.) C(U,U) C(-0.,0.) C(-0.,-0.) C(U,U) C(0.,0.) C(0.,0.)
1217
C(0.,0.) C(U,U) C(0.,-0.) C(0.,0.) C(U,U) C(0.,0.) C(0.,0.)
1218
C(N,N) C(U,U) C(U,U) C(U,U) C(U,U) C(N,N) C(N,N)
1219
C(INF,N) C(U,U) C(INF,-0.) C(INF,0.) C(U,U) C(INF,N) C(INF,N)
1220
C(N,N) C(N,N) C(N,0.) C(N,0.) C(N,N) C(N,N) C(N,N)
added
removed
Modules/cmathmodule.c
