1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 PyDoc_STRVAR(cmath_acos__doc__,
6 "acos($module, z, /)\n"
7 "--\n"
8 "\n"
9 "Return the arc cosine of z.");
10
11 #define CMATH_ACOS_METHODDEF \
12 {"acos", (PyCFunction)cmath_acos, METH_O, cmath_acos__doc__},
13
14 static Py_complex
15 cmath_acos_impl(PyObject *module, Py_complex z);
16
17 static PyObject *
cmath_acos(PyObject * module,PyObject * arg)18 cmath_acos(PyObject *module, PyObject *arg)
19 {
20 PyObject *return_value = NULL;
21 Py_complex z;
22 Py_complex _return_value;
23
24 z = PyComplex_AsCComplex(arg);
25 if (PyErr_Occurred()) {
26 goto exit;
27 }
28 /* modifications for z */
29 errno = 0;
30 _return_value = cmath_acos_impl(module, z);
31 if (errno == EDOM) {
32 PyErr_SetString(PyExc_ValueError, "math domain error");
33 goto exit;
34 }
35 else if (errno == ERANGE) {
36 PyErr_SetString(PyExc_OverflowError, "math range error");
37 goto exit;
38 }
39 else {
40 return_value = PyComplex_FromCComplex(_return_value);
41 }
42
43 exit:
44 return return_value;
45 }
46
47 PyDoc_STRVAR(cmath_acosh__doc__,
48 "acosh($module, z, /)\n"
49 "--\n"
50 "\n"
51 "Return the inverse hyperbolic cosine of z.");
52
53 #define CMATH_ACOSH_METHODDEF \
54 {"acosh", (PyCFunction)cmath_acosh, METH_O, cmath_acosh__doc__},
55
56 static Py_complex
57 cmath_acosh_impl(PyObject *module, Py_complex z);
58
59 static PyObject *
cmath_acosh(PyObject * module,PyObject * arg)60 cmath_acosh(PyObject *module, PyObject *arg)
61 {
62 PyObject *return_value = NULL;
63 Py_complex z;
64 Py_complex _return_value;
65
66 z = PyComplex_AsCComplex(arg);
67 if (PyErr_Occurred()) {
68 goto exit;
69 }
70 /* modifications for z */
71 errno = 0;
72 _return_value = cmath_acosh_impl(module, z);
73 if (errno == EDOM) {
74 PyErr_SetString(PyExc_ValueError, "math domain error");
75 goto exit;
76 }
77 else if (errno == ERANGE) {
78 PyErr_SetString(PyExc_OverflowError, "math range error");
79 goto exit;
80 }
81 else {
82 return_value = PyComplex_FromCComplex(_return_value);
83 }
84
85 exit:
86 return return_value;
87 }
88
89 PyDoc_STRVAR(cmath_asin__doc__,
90 "asin($module, z, /)\n"
91 "--\n"
92 "\n"
93 "Return the arc sine of z.");
94
95 #define CMATH_ASIN_METHODDEF \
96 {"asin", (PyCFunction)cmath_asin, METH_O, cmath_asin__doc__},
97
98 static Py_complex
99 cmath_asin_impl(PyObject *module, Py_complex z);
100
101 static PyObject *
cmath_asin(PyObject * module,PyObject * arg)102 cmath_asin(PyObject *module, PyObject *arg)
103 {
104 PyObject *return_value = NULL;
105 Py_complex z;
106 Py_complex _return_value;
107
108 z = PyComplex_AsCComplex(arg);
109 if (PyErr_Occurred()) {
110 goto exit;
111 }
112 /* modifications for z */
113 errno = 0;
114 _return_value = cmath_asin_impl(module, z);
115 if (errno == EDOM) {
116 PyErr_SetString(PyExc_ValueError, "math domain error");
117 goto exit;
118 }
119 else if (errno == ERANGE) {
120 PyErr_SetString(PyExc_OverflowError, "math range error");
121 goto exit;
122 }
123 else {
124 return_value = PyComplex_FromCComplex(_return_value);
125 }
126
127 exit:
128 return return_value;
129 }
130
131 PyDoc_STRVAR(cmath_asinh__doc__,
132 "asinh($module, z, /)\n"
133 "--\n"
134 "\n"
135 "Return the inverse hyperbolic sine of z.");
136
137 #define CMATH_ASINH_METHODDEF \
138 {"asinh", (PyCFunction)cmath_asinh, METH_O, cmath_asinh__doc__},
139
140 static Py_complex
141 cmath_asinh_impl(PyObject *module, Py_complex z);
142
143 static PyObject *
cmath_asinh(PyObject * module,PyObject * arg)144 cmath_asinh(PyObject *module, PyObject *arg)
145 {
146 PyObject *return_value = NULL;
147 Py_complex z;
148 Py_complex _return_value;
149
150 z = PyComplex_AsCComplex(arg);
151 if (PyErr_Occurred()) {
152 goto exit;
153 }
154 /* modifications for z */
155 errno = 0;
156 _return_value = cmath_asinh_impl(module, z);
157 if (errno == EDOM) {
158 PyErr_SetString(PyExc_ValueError, "math domain error");
159 goto exit;
160 }
161 else if (errno == ERANGE) {
162 PyErr_SetString(PyExc_OverflowError, "math range error");
163 goto exit;
164 }
165 else {
166 return_value = PyComplex_FromCComplex(_return_value);
167 }
168
169 exit:
170 return return_value;
171 }
172
173 PyDoc_STRVAR(cmath_atan__doc__,
174 "atan($module, z, /)\n"
175 "--\n"
176 "\n"
177 "Return the arc tangent of z.");
178
179 #define CMATH_ATAN_METHODDEF \
180 {"atan", (PyCFunction)cmath_atan, METH_O, cmath_atan__doc__},
181
182 static Py_complex
183 cmath_atan_impl(PyObject *module, Py_complex z);
184
185 static PyObject *
cmath_atan(PyObject * module,PyObject * arg)186 cmath_atan(PyObject *module, PyObject *arg)
187 {
188 PyObject *return_value = NULL;
189 Py_complex z;
190 Py_complex _return_value;
191
192 z = PyComplex_AsCComplex(arg);
193 if (PyErr_Occurred()) {
194 goto exit;
195 }
196 /* modifications for z */
197 errno = 0;
198 _return_value = cmath_atan_impl(module, z);
199 if (errno == EDOM) {
200 PyErr_SetString(PyExc_ValueError, "math domain error");
201 goto exit;
202 }
203 else if (errno == ERANGE) {
204 PyErr_SetString(PyExc_OverflowError, "math range error");
205 goto exit;
206 }
207 else {
208 return_value = PyComplex_FromCComplex(_return_value);
209 }
210
211 exit:
212 return return_value;
213 }
214
215 PyDoc_STRVAR(cmath_atanh__doc__,
216 "atanh($module, z, /)\n"
217 "--\n"
218 "\n"
219 "Return the inverse hyperbolic tangent of z.");
220
221 #define CMATH_ATANH_METHODDEF \
222 {"atanh", (PyCFunction)cmath_atanh, METH_O, cmath_atanh__doc__},
223
224 static Py_complex
225 cmath_atanh_impl(PyObject *module, Py_complex z);
226
227 static PyObject *
cmath_atanh(PyObject * module,PyObject * arg)228 cmath_atanh(PyObject *module, PyObject *arg)
229 {
230 PyObject *return_value = NULL;
231 Py_complex z;
232 Py_complex _return_value;
233
234 z = PyComplex_AsCComplex(arg);
235 if (PyErr_Occurred()) {
236 goto exit;
237 }
238 /* modifications for z */
239 errno = 0;
240 _return_value = cmath_atanh_impl(module, z);
241 if (errno == EDOM) {
242 PyErr_SetString(PyExc_ValueError, "math domain error");
243 goto exit;
244 }
245 else if (errno == ERANGE) {
246 PyErr_SetString(PyExc_OverflowError, "math range error");
247 goto exit;
248 }
249 else {
250 return_value = PyComplex_FromCComplex(_return_value);
251 }
252
253 exit:
254 return return_value;
255 }
256
257 PyDoc_STRVAR(cmath_cos__doc__,
258 "cos($module, z, /)\n"
259 "--\n"
260 "\n"
261 "Return the cosine of z.");
262
263 #define CMATH_COS_METHODDEF \
264 {"cos", (PyCFunction)cmath_cos, METH_O, cmath_cos__doc__},
265
266 static Py_complex
267 cmath_cos_impl(PyObject *module, Py_complex z);
268
269 static PyObject *
cmath_cos(PyObject * module,PyObject * arg)270 cmath_cos(PyObject *module, PyObject *arg)
271 {
272 PyObject *return_value = NULL;
273 Py_complex z;
274 Py_complex _return_value;
275
276 z = PyComplex_AsCComplex(arg);
277 if (PyErr_Occurred()) {
278 goto exit;
279 }
280 /* modifications for z */
281 errno = 0;
282 _return_value = cmath_cos_impl(module, z);
283 if (errno == EDOM) {
284 PyErr_SetString(PyExc_ValueError, "math domain error");
285 goto exit;
286 }
287 else if (errno == ERANGE) {
288 PyErr_SetString(PyExc_OverflowError, "math range error");
289 goto exit;
290 }
291 else {
292 return_value = PyComplex_FromCComplex(_return_value);
293 }
294
295 exit:
296 return return_value;
297 }
298
299 PyDoc_STRVAR(cmath_cosh__doc__,
300 "cosh($module, z, /)\n"
301 "--\n"
302 "\n"
303 "Return the hyperbolic cosine of z.");
304
305 #define CMATH_COSH_METHODDEF \
306 {"cosh", (PyCFunction)cmath_cosh, METH_O, cmath_cosh__doc__},
307
308 static Py_complex
309 cmath_cosh_impl(PyObject *module, Py_complex z);
310
311 static PyObject *
cmath_cosh(PyObject * module,PyObject * arg)312 cmath_cosh(PyObject *module, PyObject *arg)
313 {
314 PyObject *return_value = NULL;
315 Py_complex z;
316 Py_complex _return_value;
317
318 z = PyComplex_AsCComplex(arg);
319 if (PyErr_Occurred()) {
320 goto exit;
321 }
322 /* modifications for z */
323 errno = 0;
324 _return_value = cmath_cosh_impl(module, z);
325 if (errno == EDOM) {
326 PyErr_SetString(PyExc_ValueError, "math domain error");
327 goto exit;
328 }
329 else if (errno == ERANGE) {
330 PyErr_SetString(PyExc_OverflowError, "math range error");
331 goto exit;
332 }
333 else {
334 return_value = PyComplex_FromCComplex(_return_value);
335 }
336
337 exit:
338 return return_value;
339 }
340
341 PyDoc_STRVAR(cmath_exp__doc__,
342 "exp($module, z, /)\n"
343 "--\n"
344 "\n"
345 "Return the exponential value e**z.");
346
347 #define CMATH_EXP_METHODDEF \
348 {"exp", (PyCFunction)cmath_exp, METH_O, cmath_exp__doc__},
349
350 static Py_complex
351 cmath_exp_impl(PyObject *module, Py_complex z);
352
353 static PyObject *
cmath_exp(PyObject * module,PyObject * arg)354 cmath_exp(PyObject *module, PyObject *arg)
355 {
356 PyObject *return_value = NULL;
357 Py_complex z;
358 Py_complex _return_value;
359
360 z = PyComplex_AsCComplex(arg);
361 if (PyErr_Occurred()) {
362 goto exit;
363 }
364 /* modifications for z */
365 errno = 0;
366 _return_value = cmath_exp_impl(module, z);
367 if (errno == EDOM) {
368 PyErr_SetString(PyExc_ValueError, "math domain error");
369 goto exit;
370 }
371 else if (errno == ERANGE) {
372 PyErr_SetString(PyExc_OverflowError, "math range error");
373 goto exit;
374 }
375 else {
376 return_value = PyComplex_FromCComplex(_return_value);
377 }
378
379 exit:
380 return return_value;
381 }
382
383 PyDoc_STRVAR(cmath_log10__doc__,
384 "log10($module, z, /)\n"
385 "--\n"
386 "\n"
387 "Return the base-10 logarithm of z.");
388
389 #define CMATH_LOG10_METHODDEF \
390 {"log10", (PyCFunction)cmath_log10, METH_O, cmath_log10__doc__},
391
392 static Py_complex
393 cmath_log10_impl(PyObject *module, Py_complex z);
394
395 static PyObject *
cmath_log10(PyObject * module,PyObject * arg)396 cmath_log10(PyObject *module, PyObject *arg)
397 {
398 PyObject *return_value = NULL;
399 Py_complex z;
400 Py_complex _return_value;
401
402 z = PyComplex_AsCComplex(arg);
403 if (PyErr_Occurred()) {
404 goto exit;
405 }
406 /* modifications for z */
407 errno = 0;
408 _return_value = cmath_log10_impl(module, z);
409 if (errno == EDOM) {
410 PyErr_SetString(PyExc_ValueError, "math domain error");
411 goto exit;
412 }
413 else if (errno == ERANGE) {
414 PyErr_SetString(PyExc_OverflowError, "math range error");
415 goto exit;
416 }
417 else {
418 return_value = PyComplex_FromCComplex(_return_value);
419 }
420
421 exit:
422 return return_value;
423 }
424
425 PyDoc_STRVAR(cmath_sin__doc__,
426 "sin($module, z, /)\n"
427 "--\n"
428 "\n"
429 "Return the sine of z.");
430
431 #define CMATH_SIN_METHODDEF \
432 {"sin", (PyCFunction)cmath_sin, METH_O, cmath_sin__doc__},
433
434 static Py_complex
435 cmath_sin_impl(PyObject *module, Py_complex z);
436
437 static PyObject *
cmath_sin(PyObject * module,PyObject * arg)438 cmath_sin(PyObject *module, PyObject *arg)
439 {
440 PyObject *return_value = NULL;
441 Py_complex z;
442 Py_complex _return_value;
443
444 z = PyComplex_AsCComplex(arg);
445 if (PyErr_Occurred()) {
446 goto exit;
447 }
448 /* modifications for z */
449 errno = 0;
450 _return_value = cmath_sin_impl(module, z);
451 if (errno == EDOM) {
452 PyErr_SetString(PyExc_ValueError, "math domain error");
453 goto exit;
454 }
455 else if (errno == ERANGE) {
456 PyErr_SetString(PyExc_OverflowError, "math range error");
457 goto exit;
458 }
459 else {
460 return_value = PyComplex_FromCComplex(_return_value);
461 }
462
463 exit:
464 return return_value;
465 }
466
467 PyDoc_STRVAR(cmath_sinh__doc__,
468 "sinh($module, z, /)\n"
469 "--\n"
470 "\n"
471 "Return the hyperbolic sine of z.");
472
473 #define CMATH_SINH_METHODDEF \
474 {"sinh", (PyCFunction)cmath_sinh, METH_O, cmath_sinh__doc__},
475
476 static Py_complex
477 cmath_sinh_impl(PyObject *module, Py_complex z);
478
479 static PyObject *
cmath_sinh(PyObject * module,PyObject * arg)480 cmath_sinh(PyObject *module, PyObject *arg)
481 {
482 PyObject *return_value = NULL;
483 Py_complex z;
484 Py_complex _return_value;
485
486 z = PyComplex_AsCComplex(arg);
487 if (PyErr_Occurred()) {
488 goto exit;
489 }
490 /* modifications for z */
491 errno = 0;
492 _return_value = cmath_sinh_impl(module, z);
493 if (errno == EDOM) {
494 PyErr_SetString(PyExc_ValueError, "math domain error");
495 goto exit;
496 }
497 else if (errno == ERANGE) {
498 PyErr_SetString(PyExc_OverflowError, "math range error");
499 goto exit;
500 }
501 else {
502 return_value = PyComplex_FromCComplex(_return_value);
503 }
504
505 exit:
506 return return_value;
507 }
508
509 PyDoc_STRVAR(cmath_sqrt__doc__,
510 "sqrt($module, z, /)\n"
511 "--\n"
512 "\n"
513 "Return the square root of z.");
514
515 #define CMATH_SQRT_METHODDEF \
516 {"sqrt", (PyCFunction)cmath_sqrt, METH_O, cmath_sqrt__doc__},
517
518 static Py_complex
519 cmath_sqrt_impl(PyObject *module, Py_complex z);
520
521 static PyObject *
cmath_sqrt(PyObject * module,PyObject * arg)522 cmath_sqrt(PyObject *module, PyObject *arg)
523 {
524 PyObject *return_value = NULL;
525 Py_complex z;
526 Py_complex _return_value;
527
528 z = PyComplex_AsCComplex(arg);
529 if (PyErr_Occurred()) {
530 goto exit;
531 }
532 /* modifications for z */
533 errno = 0;
534 _return_value = cmath_sqrt_impl(module, z);
535 if (errno == EDOM) {
536 PyErr_SetString(PyExc_ValueError, "math domain error");
537 goto exit;
538 }
539 else if (errno == ERANGE) {
540 PyErr_SetString(PyExc_OverflowError, "math range error");
541 goto exit;
542 }
543 else {
544 return_value = PyComplex_FromCComplex(_return_value);
545 }
546
547 exit:
548 return return_value;
549 }
550
551 PyDoc_STRVAR(cmath_tan__doc__,
552 "tan($module, z, /)\n"
553 "--\n"
554 "\n"
555 "Return the tangent of z.");
556
557 #define CMATH_TAN_METHODDEF \
558 {"tan", (PyCFunction)cmath_tan, METH_O, cmath_tan__doc__},
559
560 static Py_complex
561 cmath_tan_impl(PyObject *module, Py_complex z);
562
563 static PyObject *
cmath_tan(PyObject * module,PyObject * arg)564 cmath_tan(PyObject *module, PyObject *arg)
565 {
566 PyObject *return_value = NULL;
567 Py_complex z;
568 Py_complex _return_value;
569
570 z = PyComplex_AsCComplex(arg);
571 if (PyErr_Occurred()) {
572 goto exit;
573 }
574 /* modifications for z */
575 errno = 0;
576 _return_value = cmath_tan_impl(module, z);
577 if (errno == EDOM) {
578 PyErr_SetString(PyExc_ValueError, "math domain error");
579 goto exit;
580 }
581 else if (errno == ERANGE) {
582 PyErr_SetString(PyExc_OverflowError, "math range error");
583 goto exit;
584 }
585 else {
586 return_value = PyComplex_FromCComplex(_return_value);
587 }
588
589 exit:
590 return return_value;
591 }
592
593 PyDoc_STRVAR(cmath_tanh__doc__,
594 "tanh($module, z, /)\n"
595 "--\n"
596 "\n"
597 "Return the hyperbolic tangent of z.");
598
599 #define CMATH_TANH_METHODDEF \
600 {"tanh", (PyCFunction)cmath_tanh, METH_O, cmath_tanh__doc__},
601
602 static Py_complex
603 cmath_tanh_impl(PyObject *module, Py_complex z);
604
605 static PyObject *
cmath_tanh(PyObject * module,PyObject * arg)606 cmath_tanh(PyObject *module, PyObject *arg)
607 {
608 PyObject *return_value = NULL;
609 Py_complex z;
610 Py_complex _return_value;
611
612 z = PyComplex_AsCComplex(arg);
613 if (PyErr_Occurred()) {
614 goto exit;
615 }
616 /* modifications for z */
617 errno = 0;
618 _return_value = cmath_tanh_impl(module, z);
619 if (errno == EDOM) {
620 PyErr_SetString(PyExc_ValueError, "math domain error");
621 goto exit;
622 }
623 else if (errno == ERANGE) {
624 PyErr_SetString(PyExc_OverflowError, "math range error");
625 goto exit;
626 }
627 else {
628 return_value = PyComplex_FromCComplex(_return_value);
629 }
630
631 exit:
632 return return_value;
633 }
634
635 PyDoc_STRVAR(cmath_log__doc__,
636 "log($module, z, base=<unrepresentable>, /)\n"
637 "--\n"
638 "\n"
639 "log(z[, base]) -> the logarithm of z to the given base.\n"
640 "\n"
641 "If the base not specified, returns the natural logarithm (base e) of z.");
642
643 #define CMATH_LOG_METHODDEF \
644 {"log", (PyCFunction)(void(*)(void))cmath_log, METH_FASTCALL, cmath_log__doc__},
645
646 static PyObject *
647 cmath_log_impl(PyObject *module, Py_complex x, PyObject *y_obj);
648
649 static PyObject *
cmath_log(PyObject * module,PyObject * const * args,Py_ssize_t nargs)650 cmath_log(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
651 {
652 PyObject *return_value = NULL;
653 Py_complex x;
654 PyObject *y_obj = NULL;
655
656 if (!_PyArg_CheckPositional("log", nargs, 1, 2)) {
657 goto exit;
658 }
659 x = PyComplex_AsCComplex(args[0]);
660 if (PyErr_Occurred()) {
661 goto exit;
662 }
663 if (nargs < 2) {
664 goto skip_optional;
665 }
666 y_obj = args[1];
667 skip_optional:
668 return_value = cmath_log_impl(module, x, y_obj);
669
670 exit:
671 return return_value;
672 }
673
674 PyDoc_STRVAR(cmath_phase__doc__,
675 "phase($module, z, /)\n"
676 "--\n"
677 "\n"
678 "Return argument, also known as the phase angle, of a complex.");
679
680 #define CMATH_PHASE_METHODDEF \
681 {"phase", (PyCFunction)cmath_phase, METH_O, cmath_phase__doc__},
682
683 static PyObject *
684 cmath_phase_impl(PyObject *module, Py_complex z);
685
686 static PyObject *
cmath_phase(PyObject * module,PyObject * arg)687 cmath_phase(PyObject *module, PyObject *arg)
688 {
689 PyObject *return_value = NULL;
690 Py_complex z;
691
692 z = PyComplex_AsCComplex(arg);
693 if (PyErr_Occurred()) {
694 goto exit;
695 }
696 return_value = cmath_phase_impl(module, z);
697
698 exit:
699 return return_value;
700 }
701
702 PyDoc_STRVAR(cmath_polar__doc__,
703 "polar($module, z, /)\n"
704 "--\n"
705 "\n"
706 "Convert a complex from rectangular coordinates to polar coordinates.\n"
707 "\n"
708 "r is the distance from 0 and phi the phase angle.");
709
710 #define CMATH_POLAR_METHODDEF \
711 {"polar", (PyCFunction)cmath_polar, METH_O, cmath_polar__doc__},
712
713 static PyObject *
714 cmath_polar_impl(PyObject *module, Py_complex z);
715
716 static PyObject *
cmath_polar(PyObject * module,PyObject * arg)717 cmath_polar(PyObject *module, PyObject *arg)
718 {
719 PyObject *return_value = NULL;
720 Py_complex z;
721
722 z = PyComplex_AsCComplex(arg);
723 if (PyErr_Occurred()) {
724 goto exit;
725 }
726 return_value = cmath_polar_impl(module, z);
727
728 exit:
729 return return_value;
730 }
731
732 PyDoc_STRVAR(cmath_rect__doc__,
733 "rect($module, r, phi, /)\n"
734 "--\n"
735 "\n"
736 "Convert from polar coordinates to rectangular coordinates.");
737
738 #define CMATH_RECT_METHODDEF \
739 {"rect", (PyCFunction)(void(*)(void))cmath_rect, METH_FASTCALL, cmath_rect__doc__},
740
741 static PyObject *
742 cmath_rect_impl(PyObject *module, double r, double phi);
743
744 static PyObject *
cmath_rect(PyObject * module,PyObject * const * args,Py_ssize_t nargs)745 cmath_rect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
746 {
747 PyObject *return_value = NULL;
748 double r;
749 double phi;
750
751 if (!_PyArg_CheckPositional("rect", nargs, 2, 2)) {
752 goto exit;
753 }
754 if (PyFloat_CheckExact(args[0])) {
755 r = PyFloat_AS_DOUBLE(args[0]);
756 }
757 else
758 {
759 r = PyFloat_AsDouble(args[0]);
760 if (r == -1.0 && PyErr_Occurred()) {
761 goto exit;
762 }
763 }
764 if (PyFloat_CheckExact(args[1])) {
765 phi = PyFloat_AS_DOUBLE(args[1]);
766 }
767 else
768 {
769 phi = PyFloat_AsDouble(args[1]);
770 if (phi == -1.0 && PyErr_Occurred()) {
771 goto exit;
772 }
773 }
774 return_value = cmath_rect_impl(module, r, phi);
775
776 exit:
777 return return_value;
778 }
779
780 PyDoc_STRVAR(cmath_isfinite__doc__,
781 "isfinite($module, z, /)\n"
782 "--\n"
783 "\n"
784 "Return True if both the real and imaginary parts of z are finite, else False.");
785
786 #define CMATH_ISFINITE_METHODDEF \
787 {"isfinite", (PyCFunction)cmath_isfinite, METH_O, cmath_isfinite__doc__},
788
789 static PyObject *
790 cmath_isfinite_impl(PyObject *module, Py_complex z);
791
792 static PyObject *
cmath_isfinite(PyObject * module,PyObject * arg)793 cmath_isfinite(PyObject *module, PyObject *arg)
794 {
795 PyObject *return_value = NULL;
796 Py_complex z;
797
798 z = PyComplex_AsCComplex(arg);
799 if (PyErr_Occurred()) {
800 goto exit;
801 }
802 return_value = cmath_isfinite_impl(module, z);
803
804 exit:
805 return return_value;
806 }
807
808 PyDoc_STRVAR(cmath_isnan__doc__,
809 "isnan($module, z, /)\n"
810 "--\n"
811 "\n"
812 "Checks if the real or imaginary part of z not a number (NaN).");
813
814 #define CMATH_ISNAN_METHODDEF \
815 {"isnan", (PyCFunction)cmath_isnan, METH_O, cmath_isnan__doc__},
816
817 static PyObject *
818 cmath_isnan_impl(PyObject *module, Py_complex z);
819
820 static PyObject *
cmath_isnan(PyObject * module,PyObject * arg)821 cmath_isnan(PyObject *module, PyObject *arg)
822 {
823 PyObject *return_value = NULL;
824 Py_complex z;
825
826 z = PyComplex_AsCComplex(arg);
827 if (PyErr_Occurred()) {
828 goto exit;
829 }
830 return_value = cmath_isnan_impl(module, z);
831
832 exit:
833 return return_value;
834 }
835
836 PyDoc_STRVAR(cmath_isinf__doc__,
837 "isinf($module, z, /)\n"
838 "--\n"
839 "\n"
840 "Checks if the real or imaginary part of z is infinite.");
841
842 #define CMATH_ISINF_METHODDEF \
843 {"isinf", (PyCFunction)cmath_isinf, METH_O, cmath_isinf__doc__},
844
845 static PyObject *
846 cmath_isinf_impl(PyObject *module, Py_complex z);
847
848 static PyObject *
cmath_isinf(PyObject * module,PyObject * arg)849 cmath_isinf(PyObject *module, PyObject *arg)
850 {
851 PyObject *return_value = NULL;
852 Py_complex z;
853
854 z = PyComplex_AsCComplex(arg);
855 if (PyErr_Occurred()) {
856 goto exit;
857 }
858 return_value = cmath_isinf_impl(module, z);
859
860 exit:
861 return return_value;
862 }
863
864 PyDoc_STRVAR(cmath_isclose__doc__,
865 "isclose($module, /, a, b, *, rel_tol=1e-09, abs_tol=0.0)\n"
866 "--\n"
867 "\n"
868 "Determine whether two complex numbers are close in value.\n"
869 "\n"
870 " rel_tol\n"
871 " maximum difference for being considered \"close\", relative to the\n"
872 " magnitude of the input values\n"
873 " abs_tol\n"
874 " maximum difference for being considered \"close\", regardless of the\n"
875 " magnitude of the input values\n"
876 "\n"
877 "Return True if a is close in value to b, and False otherwise.\n"
878 "\n"
879 "For the values to be considered close, the difference between them must be\n"
880 "smaller than at least one of the tolerances.\n"
881 "\n"
882 "-inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is\n"
883 "not close to anything, even itself. inf and -inf are only close to themselves.");
884
885 #define CMATH_ISCLOSE_METHODDEF \
886 {"isclose", (PyCFunction)(void(*)(void))cmath_isclose, METH_FASTCALL|METH_KEYWORDS, cmath_isclose__doc__},
887
888 static int
889 cmath_isclose_impl(PyObject *module, Py_complex a, Py_complex b,
890 double rel_tol, double abs_tol);
891
892 static PyObject *
cmath_isclose(PyObject * module,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)893 cmath_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
894 {
895 PyObject *return_value = NULL;
896 static const char * const _keywords[] = {"a", "b", "rel_tol", "abs_tol", NULL};
897 static _PyArg_Parser _parser = {NULL, _keywords, "isclose", 0};
898 PyObject *argsbuf[4];
899 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
900 Py_complex a;
901 Py_complex b;
902 double rel_tol = 1e-09;
903 double abs_tol = 0.0;
904 int _return_value;
905
906 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
907 if (!args) {
908 goto exit;
909 }
910 a = PyComplex_AsCComplex(args[0]);
911 if (PyErr_Occurred()) {
912 goto exit;
913 }
914 b = PyComplex_AsCComplex(args[1]);
915 if (PyErr_Occurred()) {
916 goto exit;
917 }
918 if (!noptargs) {
919 goto skip_optional_kwonly;
920 }
921 if (args[2]) {
922 if (PyFloat_CheckExact(args[2])) {
923 rel_tol = PyFloat_AS_DOUBLE(args[2]);
924 }
925 else
926 {
927 rel_tol = PyFloat_AsDouble(args[2]);
928 if (rel_tol == -1.0 && PyErr_Occurred()) {
929 goto exit;
930 }
931 }
932 if (!--noptargs) {
933 goto skip_optional_kwonly;
934 }
935 }
936 if (PyFloat_CheckExact(args[3])) {
937 abs_tol = PyFloat_AS_DOUBLE(args[3]);
938 }
939 else
940 {
941 abs_tol = PyFloat_AsDouble(args[3]);
942 if (abs_tol == -1.0 && PyErr_Occurred()) {
943 goto exit;
944 }
945 }
946 skip_optional_kwonly:
947 _return_value = cmath_isclose_impl(module, a, b, rel_tol, abs_tol);
948 if ((_return_value == -1) && PyErr_Occurred()) {
949 goto exit;
950 }
951 return_value = PyBool_FromLong((long)_return_value);
952
953 exit:
954 return return_value;
955 }
956 /*[clinic end generated code: output=353347db2e808e0d input=a9049054013a1b77]*/
957