Branch data Line data Source code
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 *
18 : 210 : cmath_acos(PyObject *module, PyObject *arg)
19 : : {
20 : 210 : PyObject *return_value = NULL;
21 : : Py_complex z;
22 : : Py_complex _return_value;
23 : :
24 : 210 : z = PyComplex_AsCComplex(arg);
25 [ + + ]: 210 : if (PyErr_Occurred()) {
26 : 24 : goto exit;
27 : : }
28 : : /* modifications for z */
29 : 186 : errno = 0;
30 : 186 : _return_value = cmath_acos_impl(module, z);
31 [ - + ]: 186 : if (errno == EDOM) {
32 : 0 : PyErr_SetString(PyExc_ValueError, "math domain error");
33 : 0 : goto exit;
34 : : }
35 [ - + ]: 186 : else if (errno == ERANGE) {
36 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
37 : 0 : goto exit;
38 : : }
39 : : else {
40 : 186 : return_value = PyComplex_FromCComplex(_return_value);
41 : : }
42 : :
43 : 210 : exit:
44 : 210 : 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 *
60 : 195 : cmath_acosh(PyObject *module, PyObject *arg)
61 : : {
62 : 195 : PyObject *return_value = NULL;
63 : : Py_complex z;
64 : : Py_complex _return_value;
65 : :
66 : 195 : z = PyComplex_AsCComplex(arg);
67 [ + + ]: 195 : if (PyErr_Occurred()) {
68 : 24 : goto exit;
69 : : }
70 : : /* modifications for z */
71 : 171 : errno = 0;
72 : 171 : _return_value = cmath_acosh_impl(module, z);
73 [ - + ]: 171 : if (errno == EDOM) {
74 : 0 : PyErr_SetString(PyExc_ValueError, "math domain error");
75 : 0 : goto exit;
76 : : }
77 [ - + ]: 171 : else if (errno == ERANGE) {
78 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
79 : 0 : goto exit;
80 : : }
81 : : else {
82 : 171 : return_value = PyComplex_FromCComplex(_return_value);
83 : : }
84 : :
85 : 195 : exit:
86 : 195 : 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 *
102 : 198 : cmath_asin(PyObject *module, PyObject *arg)
103 : : {
104 : 198 : PyObject *return_value = NULL;
105 : : Py_complex z;
106 : : Py_complex _return_value;
107 : :
108 : 198 : z = PyComplex_AsCComplex(arg);
109 [ + + ]: 198 : if (PyErr_Occurred()) {
110 : 24 : goto exit;
111 : : }
112 : : /* modifications for z */
113 : 174 : errno = 0;
114 : 174 : _return_value = cmath_asin_impl(module, z);
115 [ - + ]: 174 : if (errno == EDOM) {
116 : 0 : PyErr_SetString(PyExc_ValueError, "math domain error");
117 : 0 : goto exit;
118 : : }
119 [ - + ]: 174 : else if (errno == ERANGE) {
120 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
121 : 0 : goto exit;
122 : : }
123 : : else {
124 : 174 : return_value = PyComplex_FromCComplex(_return_value);
125 : : }
126 : :
127 : 198 : exit:
128 : 198 : 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 *
144 : 195 : cmath_asinh(PyObject *module, PyObject *arg)
145 : : {
146 : 195 : PyObject *return_value = NULL;
147 : : Py_complex z;
148 : : Py_complex _return_value;
149 : :
150 : 195 : z = PyComplex_AsCComplex(arg);
151 [ + + ]: 195 : if (PyErr_Occurred()) {
152 : 24 : goto exit;
153 : : }
154 : : /* modifications for z */
155 : 171 : errno = 0;
156 : 171 : _return_value = cmath_asinh_impl(module, z);
157 [ - + ]: 171 : if (errno == EDOM) {
158 : 0 : PyErr_SetString(PyExc_ValueError, "math domain error");
159 : 0 : goto exit;
160 : : }
161 [ - + ]: 171 : else if (errno == ERANGE) {
162 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
163 : 0 : goto exit;
164 : : }
165 : : else {
166 : 171 : return_value = PyComplex_FromCComplex(_return_value);
167 : : }
168 : :
169 : 195 : exit:
170 : 195 : 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 *
186 : 225 : cmath_atan(PyObject *module, PyObject *arg)
187 : : {
188 : 225 : PyObject *return_value = NULL;
189 : : Py_complex z;
190 : : Py_complex _return_value;
191 : :
192 : 225 : z = PyComplex_AsCComplex(arg);
193 [ + + ]: 225 : if (PyErr_Occurred()) {
194 : 24 : goto exit;
195 : : }
196 : : /* modifications for z */
197 : 201 : errno = 0;
198 : 201 : _return_value = cmath_atan_impl(module, z);
199 [ + + ]: 201 : if (errno == EDOM) {
200 : 4 : PyErr_SetString(PyExc_ValueError, "math domain error");
201 : 4 : goto exit;
202 : : }
203 [ - + ]: 197 : else if (errno == ERANGE) {
204 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
205 : 0 : goto exit;
206 : : }
207 : : else {
208 : 197 : return_value = PyComplex_FromCComplex(_return_value);
209 : : }
210 : :
211 : 225 : exit:
212 : 225 : 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 *
228 : 200 : cmath_atanh(PyObject *module, PyObject *arg)
229 : : {
230 : 200 : PyObject *return_value = NULL;
231 : : Py_complex z;
232 : : Py_complex _return_value;
233 : :
234 : 200 : z = PyComplex_AsCComplex(arg);
235 [ + + ]: 200 : if (PyErr_Occurred()) {
236 : 24 : goto exit;
237 : : }
238 : : /* modifications for z */
239 : 176 : errno = 0;
240 : 176 : _return_value = cmath_atanh_impl(module, z);
241 [ + + ]: 176 : if (errno == EDOM) {
242 : 4 : PyErr_SetString(PyExc_ValueError, "math domain error");
243 : 4 : goto exit;
244 : : }
245 [ - + ]: 172 : else if (errno == ERANGE) {
246 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
247 : 0 : goto exit;
248 : : }
249 : : else {
250 : 172 : return_value = PyComplex_FromCComplex(_return_value);
251 : : }
252 : :
253 : 200 : exit:
254 : 200 : 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 *
270 : 160 : cmath_cos(PyObject *module, PyObject *arg)
271 : : {
272 : 160 : PyObject *return_value = NULL;
273 : : Py_complex z;
274 : : Py_complex _return_value;
275 : :
276 : 160 : z = PyComplex_AsCComplex(arg);
277 [ + + ]: 160 : if (PyErr_Occurred()) {
278 : 24 : goto exit;
279 : : }
280 : : /* modifications for z */
281 : 136 : errno = 0;
282 : 136 : _return_value = cmath_cos_impl(module, z);
283 [ + + ]: 136 : if (errno == EDOM) {
284 : 12 : PyErr_SetString(PyExc_ValueError, "math domain error");
285 : 12 : goto exit;
286 : : }
287 [ - + ]: 124 : else if (errno == ERANGE) {
288 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
289 : 0 : goto exit;
290 : : }
291 : : else {
292 : 124 : return_value = PyComplex_FromCComplex(_return_value);
293 : : }
294 : :
295 : 160 : exit:
296 : 160 : 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 *
312 : 163 : cmath_cosh(PyObject *module, PyObject *arg)
313 : : {
314 : 163 : PyObject *return_value = NULL;
315 : : Py_complex z;
316 : : Py_complex _return_value;
317 : :
318 : 163 : z = PyComplex_AsCComplex(arg);
319 [ + + ]: 163 : if (PyErr_Occurred()) {
320 : 24 : goto exit;
321 : : }
322 : : /* modifications for z */
323 : 139 : errno = 0;
324 : 139 : _return_value = cmath_cosh_impl(module, z);
325 [ + + ]: 139 : if (errno == EDOM) {
326 : 12 : PyErr_SetString(PyExc_ValueError, "math domain error");
327 : 12 : goto exit;
328 : : }
329 [ - + ]: 127 : else if (errno == ERANGE) {
330 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
331 : 0 : goto exit;
332 : : }
333 : : else {
334 : 127 : return_value = PyComplex_FromCComplex(_return_value);
335 : : }
336 : :
337 : 163 : exit:
338 : 163 : 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 *
354 : 172 : cmath_exp(PyObject *module, PyObject *arg)
355 : : {
356 : 172 : PyObject *return_value = NULL;
357 : : Py_complex z;
358 : : Py_complex _return_value;
359 : :
360 : 172 : z = PyComplex_AsCComplex(arg);
361 [ + + ]: 172 : if (PyErr_Occurred()) {
362 : 24 : goto exit;
363 : : }
364 : : /* modifications for z */
365 : 148 : errno = 0;
366 : 148 : _return_value = cmath_exp_impl(module, z);
367 [ + + ]: 148 : if (errno == EDOM) {
368 : 10 : PyErr_SetString(PyExc_ValueError, "math domain error");
369 : 10 : goto exit;
370 : : }
371 [ + + ]: 138 : else if (errno == ERANGE) {
372 : 5 : PyErr_SetString(PyExc_OverflowError, "math range error");
373 : 5 : goto exit;
374 : : }
375 : : else {
376 : 133 : return_value = PyComplex_FromCComplex(_return_value);
377 : : }
378 : :
379 : 172 : exit:
380 : 172 : 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 *
396 : 206 : cmath_log10(PyObject *module, PyObject *arg)
397 : : {
398 : 206 : PyObject *return_value = NULL;
399 : : Py_complex z;
400 : : Py_complex _return_value;
401 : :
402 : 206 : z = PyComplex_AsCComplex(arg);
403 [ + + ]: 206 : if (PyErr_Occurred()) {
404 : 24 : goto exit;
405 : : }
406 : : /* modifications for z */
407 : 182 : errno = 0;
408 : 182 : _return_value = cmath_log10_impl(module, z);
409 [ + + ]: 182 : if (errno == EDOM) {
410 : 4 : PyErr_SetString(PyExc_ValueError, "math domain error");
411 : 4 : goto exit;
412 : : }
413 [ - + ]: 178 : else if (errno == ERANGE) {
414 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
415 : 0 : goto exit;
416 : : }
417 : : else {
418 : 178 : return_value = PyComplex_FromCComplex(_return_value);
419 : : }
420 : :
421 : 206 : exit:
422 : 206 : 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 *
438 : 160 : cmath_sin(PyObject *module, PyObject *arg)
439 : : {
440 : 160 : PyObject *return_value = NULL;
441 : : Py_complex z;
442 : : Py_complex _return_value;
443 : :
444 : 160 : z = PyComplex_AsCComplex(arg);
445 [ + + ]: 160 : if (PyErr_Occurred()) {
446 : 24 : goto exit;
447 : : }
448 : : /* modifications for z */
449 : 136 : errno = 0;
450 : 136 : _return_value = cmath_sin_impl(module, z);
451 [ + + ]: 136 : if (errno == EDOM) {
452 : 12 : PyErr_SetString(PyExc_ValueError, "math domain error");
453 : 12 : goto exit;
454 : : }
455 [ - + ]: 124 : else if (errno == ERANGE) {
456 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
457 : 0 : goto exit;
458 : : }
459 : : else {
460 : 124 : return_value = PyComplex_FromCComplex(_return_value);
461 : : }
462 : :
463 : 160 : exit:
464 : 160 : 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 *
480 : 164 : cmath_sinh(PyObject *module, PyObject *arg)
481 : : {
482 : 164 : PyObject *return_value = NULL;
483 : : Py_complex z;
484 : : Py_complex _return_value;
485 : :
486 : 164 : z = PyComplex_AsCComplex(arg);
487 [ + + ]: 164 : if (PyErr_Occurred()) {
488 : 24 : goto exit;
489 : : }
490 : : /* modifications for z */
491 : 140 : errno = 0;
492 : 140 : _return_value = cmath_sinh_impl(module, z);
493 [ + + ]: 140 : if (errno == EDOM) {
494 : 12 : PyErr_SetString(PyExc_ValueError, "math domain error");
495 : 12 : goto exit;
496 : : }
497 [ - + ]: 128 : else if (errno == ERANGE) {
498 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
499 : 0 : goto exit;
500 : : }
501 : : else {
502 : 128 : return_value = PyComplex_FromCComplex(_return_value);
503 : : }
504 : :
505 : 164 : exit:
506 : 164 : 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 *
522 : 190 : cmath_sqrt(PyObject *module, PyObject *arg)
523 : : {
524 : 190 : PyObject *return_value = NULL;
525 : : Py_complex z;
526 : : Py_complex _return_value;
527 : :
528 : 190 : z = PyComplex_AsCComplex(arg);
529 [ + + ]: 190 : if (PyErr_Occurred()) {
530 : 24 : goto exit;
531 : : }
532 : : /* modifications for z */
533 : 166 : errno = 0;
534 : 166 : _return_value = cmath_sqrt_impl(module, z);
535 [ - + ]: 166 : if (errno == EDOM) {
536 : 0 : PyErr_SetString(PyExc_ValueError, "math domain error");
537 : 0 : goto exit;
538 : : }
539 [ - + ]: 166 : else if (errno == ERANGE) {
540 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
541 : 0 : goto exit;
542 : : }
543 : : else {
544 : 166 : return_value = PyComplex_FromCComplex(_return_value);
545 : : }
546 : :
547 : 190 : exit:
548 : 190 : 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 *
564 : 163 : cmath_tan(PyObject *module, PyObject *arg)
565 : : {
566 : 163 : PyObject *return_value = NULL;
567 : : Py_complex z;
568 : : Py_complex _return_value;
569 : :
570 : 163 : z = PyComplex_AsCComplex(arg);
571 [ + + ]: 163 : if (PyErr_Occurred()) {
572 : 24 : goto exit;
573 : : }
574 : : /* modifications for z */
575 : 139 : errno = 0;
576 : 139 : _return_value = cmath_tan_impl(module, z);
577 [ + + ]: 139 : if (errno == EDOM) {
578 : 8 : PyErr_SetString(PyExc_ValueError, "math domain error");
579 : 8 : goto exit;
580 : : }
581 [ - + ]: 131 : else if (errno == ERANGE) {
582 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
583 : 0 : goto exit;
584 : : }
585 : : else {
586 : 131 : return_value = PyComplex_FromCComplex(_return_value);
587 : : }
588 : :
589 : 163 : exit:
590 : 163 : 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 *
606 : 166 : cmath_tanh(PyObject *module, PyObject *arg)
607 : : {
608 : 166 : PyObject *return_value = NULL;
609 : : Py_complex z;
610 : : Py_complex _return_value;
611 : :
612 : 166 : z = PyComplex_AsCComplex(arg);
613 [ + + ]: 166 : if (PyErr_Occurred()) {
614 : 24 : goto exit;
615 : : }
616 : : /* modifications for z */
617 : 142 : errno = 0;
618 : 142 : _return_value = cmath_tanh_impl(module, z);
619 [ + + ]: 142 : if (errno == EDOM) {
620 : 8 : PyErr_SetString(PyExc_ValueError, "math domain error");
621 : 8 : goto exit;
622 : : }
623 [ - + ]: 134 : else if (errno == ERANGE) {
624 : 0 : PyErr_SetString(PyExc_OverflowError, "math range error");
625 : 0 : goto exit;
626 : : }
627 : : else {
628 : 134 : return_value = PyComplex_FromCComplex(_return_value);
629 : : }
630 : :
631 : 166 : exit:
632 : 166 : 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_CAST(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 *
650 : 329 : cmath_log(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
651 : : {
652 : 329 : PyObject *return_value = NULL;
653 : : Py_complex x;
654 : 329 : PyObject *y_obj = NULL;
655 : :
656 [ + - - + : 329 : if (!_PyArg_CheckPositional("log", nargs, 1, 2)) {
- - ]
657 : 0 : goto exit;
658 : : }
659 : 329 : x = PyComplex_AsCComplex(args[0]);
660 [ + + ]: 329 : if (PyErr_Occurred()) {
661 : 48 : goto exit;
662 : : }
663 [ + + ]: 281 : if (nargs < 2) {
664 : 182 : goto skip_optional;
665 : : }
666 : 99 : y_obj = args[1];
667 : 281 : skip_optional:
668 : 281 : return_value = cmath_log_impl(module, x, y_obj);
669 : :
670 : 329 : exit:
671 : 329 : 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 *
687 : 43 : cmath_phase(PyObject *module, PyObject *arg)
688 : : {
689 : 43 : PyObject *return_value = NULL;
690 : : Py_complex z;
691 : :
692 : 43 : z = PyComplex_AsCComplex(arg);
693 [ - + ]: 43 : if (PyErr_Occurred()) {
694 : 0 : goto exit;
695 : : }
696 : 43 : return_value = cmath_phase_impl(module, z);
697 : :
698 : 43 : exit:
699 : 43 : 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 *
717 : 78 : cmath_polar(PyObject *module, PyObject *arg)
718 : : {
719 : 78 : PyObject *return_value = NULL;
720 : : Py_complex z;
721 : :
722 : 78 : z = PyComplex_AsCComplex(arg);
723 [ - + ]: 78 : if (PyErr_Occurred()) {
724 : 0 : goto exit;
725 : : }
726 : 78 : return_value = cmath_polar_impl(module, z);
727 : :
728 : 78 : exit:
729 : 78 : 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_CAST(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 *
745 : 58 : cmath_rect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
746 : : {
747 : 58 : PyObject *return_value = NULL;
748 : : double r;
749 : : double phi;
750 : :
751 [ + - - + : 58 : if (!_PyArg_CheckPositional("rect", nargs, 2, 2)) {
- - ]
752 : 0 : goto exit;
753 : : }
754 [ + + ]: 58 : if (PyFloat_CheckExact(args[0])) {
755 : 53 : r = PyFloat_AS_DOUBLE(args[0]);
756 : : }
757 : : else
758 : : {
759 : 5 : r = PyFloat_AsDouble(args[0]);
760 [ - + - - ]: 5 : if (r == -1.0 && PyErr_Occurred()) {
761 : 0 : goto exit;
762 : : }
763 : : }
764 [ + + ]: 58 : if (PyFloat_CheckExact(args[1])) {
765 : 56 : phi = PyFloat_AS_DOUBLE(args[1]);
766 : : }
767 : : else
768 : : {
769 : 2 : phi = PyFloat_AsDouble(args[1]);
770 [ - + - - ]: 2 : if (phi == -1.0 && PyErr_Occurred()) {
771 : 0 : goto exit;
772 : : }
773 : : }
774 : 58 : return_value = cmath_rect_impl(module, r, phi);
775 : :
776 : 58 : exit:
777 : 58 : 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 *
793 : 49 : cmath_isfinite(PyObject *module, PyObject *arg)
794 : : {
795 : 49 : PyObject *return_value = NULL;
796 : : Py_complex z;
797 : :
798 : 49 : z = PyComplex_AsCComplex(arg);
799 [ - + ]: 49 : if (PyErr_Occurred()) {
800 : 0 : goto exit;
801 : : }
802 : 49 : return_value = cmath_isfinite_impl(module, z);
803 : :
804 : 49 : exit:
805 : 49 : 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 *
821 : 9 : cmath_isnan(PyObject *module, PyObject *arg)
822 : : {
823 : 9 : PyObject *return_value = NULL;
824 : : Py_complex z;
825 : :
826 : 9 : z = PyComplex_AsCComplex(arg);
827 [ - + ]: 9 : if (PyErr_Occurred()) {
828 : 0 : goto exit;
829 : : }
830 : 9 : return_value = cmath_isnan_impl(module, z);
831 : :
832 : 9 : exit:
833 : 9 : 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 *
849 : 9 : cmath_isinf(PyObject *module, PyObject *arg)
850 : : {
851 : 9 : PyObject *return_value = NULL;
852 : : Py_complex z;
853 : :
854 : 9 : z = PyComplex_AsCComplex(arg);
855 [ - + ]: 9 : if (PyErr_Occurred()) {
856 : 0 : goto exit;
857 : : }
858 : 9 : return_value = cmath_isinf_impl(module, z);
859 : :
860 : 9 : exit:
861 : 9 : 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_CAST(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 *
893 : 85 : cmath_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
894 : : {
895 : 85 : 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 [ + + ]: 85 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
900 : : Py_complex a;
901 : : Py_complex b;
902 : 85 : double rel_tol = 1e-09;
903 : 85 : double abs_tol = 0.0;
904 : : int _return_value;
905 : :
906 [ + + + - : 85 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ - - + ]
907 [ - + ]: 85 : if (!args) {
908 : 0 : goto exit;
909 : : }
910 : 85 : a = PyComplex_AsCComplex(args[0]);
911 [ - + ]: 85 : if (PyErr_Occurred()) {
912 : 0 : goto exit;
913 : : }
914 : 85 : b = PyComplex_AsCComplex(args[1]);
915 [ - + ]: 85 : if (PyErr_Occurred()) {
916 : 0 : goto exit;
917 : : }
918 [ + + ]: 85 : if (!noptargs) {
919 : 2 : goto skip_optional_kwonly;
920 : : }
921 [ + + ]: 83 : if (args[2]) {
922 [ + + ]: 53 : if (PyFloat_CheckExact(args[2])) {
923 : 51 : rel_tol = PyFloat_AS_DOUBLE(args[2]);
924 : : }
925 : : else
926 : : {
927 : 2 : rel_tol = PyFloat_AsDouble(args[2]);
928 [ + - + - ]: 2 : if (rel_tol == -1.0 && PyErr_Occurred()) {
929 : 2 : goto exit;
930 : : }
931 : : }
932 [ + + ]: 51 : if (!--noptargs) {
933 : 44 : goto skip_optional_kwonly;
934 : : }
935 : : }
936 [ + + ]: 37 : if (PyFloat_CheckExact(args[3])) {
937 : 36 : abs_tol = PyFloat_AS_DOUBLE(args[3]);
938 : : }
939 : : else
940 : : {
941 : 1 : abs_tol = PyFloat_AsDouble(args[3]);
942 [ + - - + ]: 1 : if (abs_tol == -1.0 && PyErr_Occurred()) {
943 : 1 : goto exit;
944 : : }
945 : : }
946 : 0 : skip_optional_kwonly:
947 : 82 : _return_value = cmath_isclose_impl(module, a, b, rel_tol, abs_tol);
948 [ + + + - ]: 82 : if ((_return_value == -1) && PyErr_Occurred()) {
949 : 2 : goto exit;
950 : : }
951 : 80 : return_value = PyBool_FromLong((long)_return_value);
952 : :
953 : 85 : exit:
954 : 85 : return return_value;
955 : : }
956 : : /*[clinic end generated code: output=b8e445fcd2a3da65 input=a9049054013a1b77]*/
|
