1
2 /* Complex object implementation */
3
4 /* Borrows heavily from floatobject.c */
5
6 /* Submitted by Jim Hugunin */
7
8 #include "Python.h"
9 #include "structmember.h"
10
11 /*[clinic input]
12 class complex "PyComplexObject *" "&PyComplex_Type"
13 [clinic start generated code]*/
14 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=819e057d2d10f5ec]*/
15
16 #include "clinic/complexobject.c.h"
17
18 /* elementary operations on complex numbers */
19
20 static Py_complex c_1 = {1., 0.};
21
22 Py_complex
_Py_c_sum(Py_complex a,Py_complex b)23 _Py_c_sum(Py_complex a, Py_complex b)
24 {
25 Py_complex r;
26 r.real = a.real + b.real;
27 r.imag = a.imag + b.imag;
28 return r;
29 }
30
31 Py_complex
_Py_c_diff(Py_complex a,Py_complex b)32 _Py_c_diff(Py_complex a, Py_complex b)
33 {
34 Py_complex r;
35 r.real = a.real - b.real;
36 r.imag = a.imag - b.imag;
37 return r;
38 }
39
40 Py_complex
_Py_c_neg(Py_complex a)41 _Py_c_neg(Py_complex a)
42 {
43 Py_complex r;
44 r.real = -a.real;
45 r.imag = -a.imag;
46 return r;
47 }
48
49 Py_complex
_Py_c_prod(Py_complex a,Py_complex b)50 _Py_c_prod(Py_complex a, Py_complex b)
51 {
52 Py_complex r;
53 r.real = a.real*b.real - a.imag*b.imag;
54 r.imag = a.real*b.imag + a.imag*b.real;
55 return r;
56 }
57
58 /* Avoid bad optimization on Windows ARM64 until the compiler is fixed */
59 #ifdef _M_ARM64
60 #pragma optimize("", off)
61 #endif
62 Py_complex
_Py_c_quot(Py_complex a,Py_complex b)63 _Py_c_quot(Py_complex a, Py_complex b)
64 {
65 /******************************************************************
66 This was the original algorithm. It's grossly prone to spurious
67 overflow and underflow errors. It also merrily divides by 0 despite
68 checking for that(!). The code still serves a doc purpose here, as
69 the algorithm following is a simple by-cases transformation of this
70 one:
71
72 Py_complex r;
73 double d = b.real*b.real + b.imag*b.imag;
74 if (d == 0.)
75 errno = EDOM;
76 r.real = (a.real*b.real + a.imag*b.imag)/d;
77 r.imag = (a.imag*b.real - a.real*b.imag)/d;
78 return r;
79 ******************************************************************/
80
81 /* This algorithm is better, and is pretty obvious: first divide the
82 * numerators and denominator by whichever of {b.real, b.imag} has
83 * larger magnitude. The earliest reference I found was to CACM
84 * Algorithm 116 (Complex Division, Robert L. Smith, Stanford
85 * University). As usual, though, we're still ignoring all IEEE
86 * endcases.
87 */
88 Py_complex r; /* the result */
89 const double abs_breal = b.real < 0 ? -b.real : b.real;
90 const double abs_bimag = b.imag < 0 ? -b.imag : b.imag;
91
92 if (abs_breal >= abs_bimag) {
93 /* divide tops and bottom by b.real */
94 if (abs_breal == 0.0) {
95 errno = EDOM;
96 r.real = r.imag = 0.0;
97 }
98 else {
99 const double ratio = b.imag / b.real;
100 const double denom = b.real + b.imag * ratio;
101 r.real = (a.real + a.imag * ratio) / denom;
102 r.imag = (a.imag - a.real * ratio) / denom;
103 }
104 }
105 else if (abs_bimag >= abs_breal) {
106 /* divide tops and bottom by b.imag */
107 const double ratio = b.real / b.imag;
108 const double denom = b.real * ratio + b.imag;
109 assert(b.imag != 0.0);
110 r.real = (a.real * ratio + a.imag) / denom;
111 r.imag = (a.imag * ratio - a.real) / denom;
112 }
113 else {
114 /* At least one of b.real or b.imag is a NaN */
115 r.real = r.imag = Py_NAN;
116 }
117 return r;
118 }
119 #ifdef _M_ARM64
120 #pragma optimize("", on)
121 #endif
122
123 Py_complex
_Py_c_pow(Py_complex a,Py_complex b)124 _Py_c_pow(Py_complex a, Py_complex b)
125 {
126 Py_complex r;
127 double vabs,len,at,phase;
128 if (b.real == 0. && b.imag == 0.) {
129 r.real = 1.;
130 r.imag = 0.;
131 }
132 else if (a.real == 0. && a.imag == 0.) {
133 if (b.imag != 0. || b.real < 0.)
134 errno = EDOM;
135 r.real = 0.;
136 r.imag = 0.;
137 }
138 else {
139 vabs = hypot(a.real,a.imag);
140 len = pow(vabs,b.real);
141 at = atan2(a.imag, a.real);
142 phase = at*b.real;
143 if (b.imag != 0.0) {
144 len /= exp(at*b.imag);
145 phase += b.imag*log(vabs);
146 }
147 r.real = len*cos(phase);
148 r.imag = len*sin(phase);
149 }
150 return r;
151 }
152
153 static Py_complex
c_powu(Py_complex x,long n)154 c_powu(Py_complex x, long n)
155 {
156 Py_complex r, p;
157 long mask = 1;
158 r = c_1;
159 p = x;
160 while (mask > 0 && n >= mask) {
161 if (n & mask)
162 r = _Py_c_prod(r,p);
163 mask <<= 1;
164 p = _Py_c_prod(p,p);
165 }
166 return r;
167 }
168
169 static Py_complex
c_powi(Py_complex x,long n)170 c_powi(Py_complex x, long n)
171 {
172 Py_complex cn;
173
174 if (n > 100 || n < -100) {
175 cn.real = (double) n;
176 cn.imag = 0.;
177 return _Py_c_pow(x,cn);
178 }
179 else if (n > 0)
180 return c_powu(x,n);
181 else
182 return _Py_c_quot(c_1, c_powu(x,-n));
183
184 }
185
186 double
_Py_c_abs(Py_complex z)187 _Py_c_abs(Py_complex z)
188 {
189 /* sets errno = ERANGE on overflow; otherwise errno = 0 */
190 double result;
191
192 if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
193 /* C99 rules: if either the real or the imaginary part is an
194 infinity, return infinity, even if the other part is a
195 NaN. */
196 if (Py_IS_INFINITY(z.real)) {
197 result = fabs(z.real);
198 errno = 0;
199 return result;
200 }
201 if (Py_IS_INFINITY(z.imag)) {
202 result = fabs(z.imag);
203 errno = 0;
204 return result;
205 }
206 /* either the real or imaginary part is a NaN,
207 and neither is infinite. Result should be NaN. */
208 return Py_NAN;
209 }
210 result = hypot(z.real, z.imag);
211 if (!Py_IS_FINITE(result))
212 errno = ERANGE;
213 else
214 errno = 0;
215 return result;
216 }
217
218 static PyObject *
complex_subtype_from_c_complex(PyTypeObject * type,Py_complex cval)219 complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)
220 {
221 PyObject *op;
222
223 op = type->tp_alloc(type, 0);
224 if (op != NULL)
225 ((PyComplexObject *)op)->cval = cval;
226 return op;
227 }
228
229 PyObject *
PyComplex_FromCComplex(Py_complex cval)230 PyComplex_FromCComplex(Py_complex cval)
231 {
232 PyComplexObject *op;
233
234 /* Inline PyObject_New */
235 op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
236 if (op == NULL)
237 return PyErr_NoMemory();
238 (void)PyObject_INIT(op, &PyComplex_Type);
239 op->cval = cval;
240 return (PyObject *) op;
241 }
242
243 static PyObject *
complex_subtype_from_doubles(PyTypeObject * type,double real,double imag)244 complex_subtype_from_doubles(PyTypeObject *type, double real, double imag)
245 {
246 Py_complex c;
247 c.real = real;
248 c.imag = imag;
249 return complex_subtype_from_c_complex(type, c);
250 }
251
252 PyObject *
PyComplex_FromDoubles(double real,double imag)253 PyComplex_FromDoubles(double real, double imag)
254 {
255 Py_complex c;
256 c.real = real;
257 c.imag = imag;
258 return PyComplex_FromCComplex(c);
259 }
260
261 double
PyComplex_RealAsDouble(PyObject * op)262 PyComplex_RealAsDouble(PyObject *op)
263 {
264 if (PyComplex_Check(op)) {
265 return ((PyComplexObject *)op)->cval.real;
266 }
267 else {
268 return PyFloat_AsDouble(op);
269 }
270 }
271
272 double
PyComplex_ImagAsDouble(PyObject * op)273 PyComplex_ImagAsDouble(PyObject *op)
274 {
275 if (PyComplex_Check(op)) {
276 return ((PyComplexObject *)op)->cval.imag;
277 }
278 else {
279 return 0.0;
280 }
281 }
282
283 static PyObject *
try_complex_special_method(PyObject * op)284 try_complex_special_method(PyObject *op)
285 {
286 PyObject *f;
287 _Py_IDENTIFIER(__complex__);
288
289 f = _PyObject_LookupSpecial(op, &PyId___complex__);
290 if (f) {
291 PyObject *res = _PyObject_CallNoArg(f);
292 Py_DECREF(f);
293 if (!res || PyComplex_CheckExact(res)) {
294 return res;
295 }
296 if (!PyComplex_Check(res)) {
297 PyErr_Format(PyExc_TypeError,
298 "__complex__ returned non-complex (type %.200s)",
299 res->ob_type->tp_name);
300 Py_DECREF(res);
301 return NULL;
302 }
303 /* Issue #29894: warn if 'res' not of exact type complex. */
304 if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
305 "__complex__ returned non-complex (type %.200s). "
306 "The ability to return an instance of a strict subclass of complex "
307 "is deprecated, and may be removed in a future version of Python.",
308 res->ob_type->tp_name)) {
309 Py_DECREF(res);
310 return NULL;
311 }
312 return res;
313 }
314 return NULL;
315 }
316
317 Py_complex
PyComplex_AsCComplex(PyObject * op)318 PyComplex_AsCComplex(PyObject *op)
319 {
320 Py_complex cv;
321 PyObject *newop = NULL;
322
323 assert(op);
324 /* If op is already of type PyComplex_Type, return its value */
325 if (PyComplex_Check(op)) {
326 return ((PyComplexObject *)op)->cval;
327 }
328 /* If not, use op's __complex__ method, if it exists */
329
330 /* return -1 on failure */
331 cv.real = -1.;
332 cv.imag = 0.;
333
334 newop = try_complex_special_method(op);
335
336 if (newop) {
337 cv = ((PyComplexObject *)newop)->cval;
338 Py_DECREF(newop);
339 return cv;
340 }
341 else if (PyErr_Occurred()) {
342 return cv;
343 }
344 /* If neither of the above works, interpret op as a float giving the
345 real part of the result, and fill in the imaginary part as 0. */
346 else {
347 /* PyFloat_AsDouble will return -1 on failure */
348 cv.real = PyFloat_AsDouble(op);
349 return cv;
350 }
351 }
352
353 static PyObject *
complex_repr(PyComplexObject * v)354 complex_repr(PyComplexObject *v)
355 {
356 int precision = 0;
357 char format_code = 'r';
358 PyObject *result = NULL;
359
360 /* If these are non-NULL, they'll need to be freed. */
361 char *pre = NULL;
362 char *im = NULL;
363
364 /* These do not need to be freed. re is either an alias
365 for pre or a pointer to a constant. lead and tail
366 are pointers to constants. */
367 const char *re = NULL;
368 const char *lead = "";
369 const char *tail = "";
370
371 if (v->cval.real == 0. && copysign(1.0, v->cval.real)==1.0) {
372 /* Real part is +0: just output the imaginary part and do not
373 include parens. */
374 re = "";
375 im = PyOS_double_to_string(v->cval.imag, format_code,
376 precision, 0, NULL);
377 if (!im) {
378 PyErr_NoMemory();
379 goto done;
380 }
381 } else {
382 /* Format imaginary part with sign, real part without. Include
383 parens in the result. */
384 pre = PyOS_double_to_string(v->cval.real, format_code,
385 precision, 0, NULL);
386 if (!pre) {
387 PyErr_NoMemory();
388 goto done;
389 }
390 re = pre;
391
392 im = PyOS_double_to_string(v->cval.imag, format_code,
393 precision, Py_DTSF_SIGN, NULL);
394 if (!im) {
395 PyErr_NoMemory();
396 goto done;
397 }
398 lead = "(";
399 tail = ")";
400 }
401 result = PyUnicode_FromFormat("%s%s%sj%s", lead, re, im, tail);
402 done:
403 PyMem_Free(im);
404 PyMem_Free(pre);
405
406 return result;
407 }
408
409 static Py_hash_t
complex_hash(PyComplexObject * v)410 complex_hash(PyComplexObject *v)
411 {
412 Py_uhash_t hashreal, hashimag, combined;
413 hashreal = (Py_uhash_t)_Py_HashDouble(v->cval.real);
414 if (hashreal == (Py_uhash_t)-1)
415 return -1;
416 hashimag = (Py_uhash_t)_Py_HashDouble(v->cval.imag);
417 if (hashimag == (Py_uhash_t)-1)
418 return -1;
419 /* Note: if the imaginary part is 0, hashimag is 0 now,
420 * so the following returns hashreal unchanged. This is
421 * important because numbers of different types that
422 * compare equal must have the same hash value, so that
423 * hash(x + 0*j) must equal hash(x).
424 */
425 combined = hashreal + _PyHASH_IMAG * hashimag;
426 if (combined == (Py_uhash_t)-1)
427 combined = (Py_uhash_t)-2;
428 return (Py_hash_t)combined;
429 }
430
431 /* This macro may return! */
432 #define TO_COMPLEX(obj, c) \
433 if (PyComplex_Check(obj)) \
434 c = ((PyComplexObject *)(obj))->cval; \
435 else if (to_complex(&(obj), &(c)) < 0) \
436 return (obj)
437
438 static int
to_complex(PyObject ** pobj,Py_complex * pc)439 to_complex(PyObject **pobj, Py_complex *pc)
440 {
441 PyObject *obj = *pobj;
442
443 pc->real = pc->imag = 0.0;
444 if (PyLong_Check(obj)) {
445 pc->real = PyLong_AsDouble(obj);
446 if (pc->real == -1.0 && PyErr_Occurred()) {
447 *pobj = NULL;
448 return -1;
449 }
450 return 0;
451 }
452 if (PyFloat_Check(obj)) {
453 pc->real = PyFloat_AsDouble(obj);
454 return 0;
455 }
456 Py_INCREF(Py_NotImplemented);
457 *pobj = Py_NotImplemented;
458 return -1;
459 }
460
461
462 static PyObject *
complex_add(PyObject * v,PyObject * w)463 complex_add(PyObject *v, PyObject *w)
464 {
465 Py_complex result;
466 Py_complex a, b;
467 TO_COMPLEX(v, a);
468 TO_COMPLEX(w, b);
469 PyFPE_START_PROTECT("complex_add", return 0)
470 result = _Py_c_sum(a, b);
471 PyFPE_END_PROTECT(result)
472 return PyComplex_FromCComplex(result);
473 }
474
475 static PyObject *
complex_sub(PyObject * v,PyObject * w)476 complex_sub(PyObject *v, PyObject *w)
477 {
478 Py_complex result;
479 Py_complex a, b;
480 TO_COMPLEX(v, a);
481 TO_COMPLEX(w, b);
482 PyFPE_START_PROTECT("complex_sub", return 0)
483 result = _Py_c_diff(a, b);
484 PyFPE_END_PROTECT(result)
485 return PyComplex_FromCComplex(result);
486 }
487
488 static PyObject *
complex_mul(PyObject * v,PyObject * w)489 complex_mul(PyObject *v, PyObject *w)
490 {
491 Py_complex result;
492 Py_complex a, b;
493 TO_COMPLEX(v, a);
494 TO_COMPLEX(w, b);
495 PyFPE_START_PROTECT("complex_mul", return 0)
496 result = _Py_c_prod(a, b);
497 PyFPE_END_PROTECT(result)
498 return PyComplex_FromCComplex(result);
499 }
500
501 static PyObject *
complex_div(PyObject * v,PyObject * w)502 complex_div(PyObject *v, PyObject *w)
503 {
504 Py_complex quot;
505 Py_complex a, b;
506 TO_COMPLEX(v, a);
507 TO_COMPLEX(w, b);
508 PyFPE_START_PROTECT("complex_div", return 0)
509 errno = 0;
510 quot = _Py_c_quot(a, b);
511 PyFPE_END_PROTECT(quot)
512 if (errno == EDOM) {
513 PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero");
514 return NULL;
515 }
516 return PyComplex_FromCComplex(quot);
517 }
518
519 static PyObject *
complex_remainder(PyObject * v,PyObject * w)520 complex_remainder(PyObject *v, PyObject *w)
521 {
522 PyErr_SetString(PyExc_TypeError,
523 "can't mod complex numbers.");
524 return NULL;
525 }
526
527
528 static PyObject *
complex_divmod(PyObject * v,PyObject * w)529 complex_divmod(PyObject *v, PyObject *w)
530 {
531 PyErr_SetString(PyExc_TypeError,
532 "can't take floor or mod of complex number.");
533 return NULL;
534 }
535
536 static PyObject *
complex_pow(PyObject * v,PyObject * w,PyObject * z)537 complex_pow(PyObject *v, PyObject *w, PyObject *z)
538 {
539 Py_complex p;
540 Py_complex exponent;
541 long int_exponent;
542 Py_complex a, b;
543 TO_COMPLEX(v, a);
544 TO_COMPLEX(w, b);
545
546 if (z != Py_None) {
547 PyErr_SetString(PyExc_ValueError, "complex modulo");
548 return NULL;
549 }
550 PyFPE_START_PROTECT("complex_pow", return 0)
551 errno = 0;
552 exponent = b;
553 int_exponent = (long)exponent.real;
554 if (exponent.imag == 0. && exponent.real == int_exponent)
555 p = c_powi(a, int_exponent);
556 else
557 p = _Py_c_pow(a, exponent);
558
559 PyFPE_END_PROTECT(p)
560 Py_ADJUST_ERANGE2(p.real, p.imag);
561 if (errno == EDOM) {
562 PyErr_SetString(PyExc_ZeroDivisionError,
563 "0.0 to a negative or complex power");
564 return NULL;
565 }
566 else if (errno == ERANGE) {
567 PyErr_SetString(PyExc_OverflowError,
568 "complex exponentiation");
569 return NULL;
570 }
571 return PyComplex_FromCComplex(p);
572 }
573
574 static PyObject *
complex_int_div(PyObject * v,PyObject * w)575 complex_int_div(PyObject *v, PyObject *w)
576 {
577 PyErr_SetString(PyExc_TypeError,
578 "can't take floor of complex number.");
579 return NULL;
580 }
581
582 static PyObject *
complex_neg(PyComplexObject * v)583 complex_neg(PyComplexObject *v)
584 {
585 Py_complex neg;
586 neg.real = -v->cval.real;
587 neg.imag = -v->cval.imag;
588 return PyComplex_FromCComplex(neg);
589 }
590
591 static PyObject *
complex_pos(PyComplexObject * v)592 complex_pos(PyComplexObject *v)
593 {
594 if (PyComplex_CheckExact(v)) {
595 Py_INCREF(v);
596 return (PyObject *)v;
597 }
598 else
599 return PyComplex_FromCComplex(v->cval);
600 }
601
602 static PyObject *
complex_abs(PyComplexObject * v)603 complex_abs(PyComplexObject *v)
604 {
605 double result;
606
607 PyFPE_START_PROTECT("complex_abs", return 0)
608 result = _Py_c_abs(v->cval);
609 PyFPE_END_PROTECT(result)
610
611 if (errno == ERANGE) {
612 PyErr_SetString(PyExc_OverflowError,
613 "absolute value too large");
614 return NULL;
615 }
616 return PyFloat_FromDouble(result);
617 }
618
619 static int
complex_bool(PyComplexObject * v)620 complex_bool(PyComplexObject *v)
621 {
622 return v->cval.real != 0.0 || v->cval.imag != 0.0;
623 }
624
625 static PyObject *
complex_richcompare(PyObject * v,PyObject * w,int op)626 complex_richcompare(PyObject *v, PyObject *w, int op)
627 {
628 PyObject *res;
629 Py_complex i;
630 int equal;
631
632 if (op != Py_EQ && op != Py_NE) {
633 goto Unimplemented;
634 }
635
636 assert(PyComplex_Check(v));
637 TO_COMPLEX(v, i);
638
639 if (PyLong_Check(w)) {
640 /* Check for 0.0 imaginary part first to avoid the rich
641 * comparison when possible.
642 */
643 if (i.imag == 0.0) {
644 PyObject *j, *sub_res;
645 j = PyFloat_FromDouble(i.real);
646 if (j == NULL)
647 return NULL;
648
649 sub_res = PyObject_RichCompare(j, w, op);
650 Py_DECREF(j);
651 return sub_res;
652 }
653 else {
654 equal = 0;
655 }
656 }
657 else if (PyFloat_Check(w)) {
658 equal = (i.real == PyFloat_AsDouble(w) && i.imag == 0.0);
659 }
660 else if (PyComplex_Check(w)) {
661 Py_complex j;
662
663 TO_COMPLEX(w, j);
664 equal = (i.real == j.real && i.imag == j.imag);
665 }
666 else {
667 goto Unimplemented;
668 }
669
670 if (equal == (op == Py_EQ))
671 res = Py_True;
672 else
673 res = Py_False;
674
675 Py_INCREF(res);
676 return res;
677
678 Unimplemented:
679 Py_RETURN_NOTIMPLEMENTED;
680 }
681
682 static PyObject *
complex_int(PyObject * v)683 complex_int(PyObject *v)
684 {
685 PyErr_SetString(PyExc_TypeError,
686 "can't convert complex to int");
687 return NULL;
688 }
689
690 static PyObject *
complex_float(PyObject * v)691 complex_float(PyObject *v)
692 {
693 PyErr_SetString(PyExc_TypeError,
694 "can't convert complex to float");
695 return NULL;
696 }
697
698 static PyObject *
complex_conjugate(PyObject * self,PyObject * Py_UNUSED (ignored))699 complex_conjugate(PyObject *self, PyObject *Py_UNUSED(ignored))
700 {
701 Py_complex c;
702 c = ((PyComplexObject *)self)->cval;
703 c.imag = -c.imag;
704 return PyComplex_FromCComplex(c);
705 }
706
707 PyDoc_STRVAR(complex_conjugate_doc,
708 "complex.conjugate() -> complex\n"
709 "\n"
710 "Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");
711
712 static PyObject *
complex_getnewargs(PyComplexObject * v,PyObject * Py_UNUSED (ignored))713 complex_getnewargs(PyComplexObject *v, PyObject *Py_UNUSED(ignored))
714 {
715 Py_complex c = v->cval;
716 return Py_BuildValue("(dd)", c.real, c.imag);
717 }
718
719 PyDoc_STRVAR(complex__format__doc,
720 "complex.__format__() -> str\n"
721 "\n"
722 "Convert to a string according to format_spec.");
723
724 static PyObject *
complex__format__(PyObject * self,PyObject * args)725 complex__format__(PyObject* self, PyObject* args)
726 {
727 PyObject *format_spec;
728 _PyUnicodeWriter writer;
729 int ret;
730
731 if (!PyArg_ParseTuple(args, "U:__format__", &format_spec))
732 return NULL;
733
734 _PyUnicodeWriter_Init(&writer);
735 ret = _PyComplex_FormatAdvancedWriter(
736 &writer,
737 self,
738 format_spec, 0, PyUnicode_GET_LENGTH(format_spec));
739 if (ret == -1) {
740 _PyUnicodeWriter_Dealloc(&writer);
741 return NULL;
742 }
743 return _PyUnicodeWriter_Finish(&writer);
744 }
745
746 static PyMethodDef complex_methods[] = {
747 {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS,
748 complex_conjugate_doc},
749 {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS},
750 {"__format__", (PyCFunction)complex__format__,
751 METH_VARARGS, complex__format__doc},
752 {NULL, NULL} /* sentinel */
753 };
754
755 static PyMemberDef complex_members[] = {
756 {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY,
757 "the real part of a complex number"},
758 {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY,
759 "the imaginary part of a complex number"},
760 {0},
761 };
762
763 static PyObject *
complex_from_string_inner(const char * s,Py_ssize_t len,void * type)764 complex_from_string_inner(const char *s, Py_ssize_t len, void *type)
765 {
766 double x=0.0, y=0.0, z;
767 int got_bracket=0;
768 const char *start;
769 char *end;
770
771 /* position on first nonblank */
772 start = s;
773 while (Py_ISSPACE(*s))
774 s++;
775 if (*s == '(') {
776 /* Skip over possible bracket from repr(). */
777 got_bracket = 1;
778 s++;
779 while (Py_ISSPACE(*s))
780 s++;
781 }
782
783 /* a valid complex string usually takes one of the three forms:
784
785 <float> - real part only
786 <float>j - imaginary part only
787 <float><signed-float>j - real and imaginary parts
788
789 where <float> represents any numeric string that's accepted by the
790 float constructor (including 'nan', 'inf', 'infinity', etc.), and
791 <signed-float> is any string of the form <float> whose first
792 character is '+' or '-'.
793
794 For backwards compatibility, the extra forms
795
796 <float><sign>j
797 <sign>j
798 j
799
800 are also accepted, though support for these forms may be removed from
801 a future version of Python.
802 */
803
804 /* first look for forms starting with <float> */
805 z = PyOS_string_to_double(s, &end, NULL);
806 if (z == -1.0 && PyErr_Occurred()) {
807 if (PyErr_ExceptionMatches(PyExc_ValueError))
808 PyErr_Clear();
809 else
810 return NULL;
811 }
812 if (end != s) {
813 /* all 4 forms starting with <float> land here */
814 s = end;
815 if (*s == '+' || *s == '-') {
816 /* <float><signed-float>j | <float><sign>j */
817 x = z;
818 y = PyOS_string_to_double(s, &end, NULL);
819 if (y == -1.0 && PyErr_Occurred()) {
820 if (PyErr_ExceptionMatches(PyExc_ValueError))
821 PyErr_Clear();
822 else
823 return NULL;
824 }
825 if (end != s)
826 /* <float><signed-float>j */
827 s = end;
828 else {
829 /* <float><sign>j */
830 y = *s == '+' ? 1.0 : -1.0;
831 s++;
832 }
833 if (!(*s == 'j' || *s == 'J'))
834 goto parse_error;
835 s++;
836 }
837 else if (*s == 'j' || *s == 'J') {
838 /* <float>j */
839 s++;
840 y = z;
841 }
842 else
843 /* <float> */
844 x = z;
845 }
846 else {
847 /* not starting with <float>; must be <sign>j or j */
848 if (*s == '+' || *s == '-') {
849 /* <sign>j */
850 y = *s == '+' ? 1.0 : -1.0;
851 s++;
852 }
853 else
854 /* j */
855 y = 1.0;
856 if (!(*s == 'j' || *s == 'J'))
857 goto parse_error;
858 s++;
859 }
860
861 /* trailing whitespace and closing bracket */
862 while (Py_ISSPACE(*s))
863 s++;
864 if (got_bracket) {
865 /* if there was an opening parenthesis, then the corresponding
866 closing parenthesis should be right here */
867 if (*s != ')')
868 goto parse_error;
869 s++;
870 while (Py_ISSPACE(*s))
871 s++;
872 }
873
874 /* we should now be at the end of the string */
875 if (s-start != len)
876 goto parse_error;
877
878 return complex_subtype_from_doubles((PyTypeObject *)type, x, y);
879
880 parse_error:
881 PyErr_SetString(PyExc_ValueError,
882 "complex() arg is a malformed string");
883 return NULL;
884 }
885
886 static PyObject *
complex_subtype_from_string(PyTypeObject * type,PyObject * v)887 complex_subtype_from_string(PyTypeObject *type, PyObject *v)
888 {
889 const char *s;
890 PyObject *s_buffer = NULL, *result = NULL;
891 Py_ssize_t len;
892
893 if (PyUnicode_Check(v)) {
894 s_buffer = _PyUnicode_TransformDecimalAndSpaceToASCII(v);
895 if (s_buffer == NULL) {
896 return NULL;
897 }
898 assert(PyUnicode_IS_ASCII(s_buffer));
899 /* Simply get a pointer to existing ASCII characters. */
900 s = PyUnicode_AsUTF8AndSize(s_buffer, &len);
901 assert(s != NULL);
902 }
903 else {
904 PyErr_Format(PyExc_TypeError,
905 "complex() argument must be a string or a number, not '%.200s'",
906 Py_TYPE(v)->tp_name);
907 return NULL;
908 }
909
910 result = _Py_string_to_number_with_underscores(s, len, "complex", v, type,
911 complex_from_string_inner);
912 Py_DECREF(s_buffer);
913 return result;
914 }
915
916 /*[clinic input]
917 @classmethod
918 complex.__new__ as complex_new
919 real as r: object(c_default="_PyLong_Zero") = 0
920 imag as i: object(c_default="NULL") = 0
921
922 Create a complex number from a real part and an optional imaginary part.
923
924 This is equivalent to (real + imag*1j) where imag defaults to 0.
925 [clinic start generated code]*/
926
927 static PyObject *
complex_new_impl(PyTypeObject * type,PyObject * r,PyObject * i)928 complex_new_impl(PyTypeObject *type, PyObject *r, PyObject *i)
929 /*[clinic end generated code: output=b6c7dd577b537dc1 input=6f6b0bedba29bcb5]*/
930 {
931 PyObject *tmp;
932 PyNumberMethods *nbr, *nbi = NULL;
933 Py_complex cr, ci;
934 int own_r = 0;
935 int cr_is_complex = 0;
936 int ci_is_complex = 0;
937
938 /* Special-case for a single argument when type(arg) is complex. */
939 if (PyComplex_CheckExact(r) && i == NULL &&
940 type == &PyComplex_Type) {
941 /* Note that we can't know whether it's safe to return
942 a complex *subclass* instance as-is, hence the restriction
943 to exact complexes here. If either the input or the
944 output is a complex subclass, it will be handled below
945 as a non-orthogonal vector. */
946 Py_INCREF(r);
947 return r;
948 }
949 if (PyUnicode_Check(r)) {
950 if (i != NULL) {
951 PyErr_SetString(PyExc_TypeError,
952 "complex() can't take second arg"
953 " if first is a string");
954 return NULL;
955 }
956 return complex_subtype_from_string(type, r);
957 }
958 if (i != NULL && PyUnicode_Check(i)) {
959 PyErr_SetString(PyExc_TypeError,
960 "complex() second arg can't be a string");
961 return NULL;
962 }
963
964 tmp = try_complex_special_method(r);
965 if (tmp) {
966 r = tmp;
967 own_r = 1;
968 }
969 else if (PyErr_Occurred()) {
970 return NULL;
971 }
972
973 nbr = r->ob_type->tp_as_number;
974 if (nbr == NULL || (nbr->nb_float == NULL && nbr->nb_index == NULL)) {
975 PyErr_Format(PyExc_TypeError,
976 "complex() first argument must be a string or a number, "
977 "not '%.200s'",
978 Py_TYPE(r)->tp_name);
979 if (own_r) {
980 Py_DECREF(r);
981 }
982 return NULL;
983 }
984 if (i != NULL) {
985 nbi = i->ob_type->tp_as_number;
986 if (nbi == NULL || (nbi->nb_float == NULL && nbi->nb_index == NULL)) {
987 PyErr_Format(PyExc_TypeError,
988 "complex() second argument must be a number, "
989 "not '%.200s'",
990 Py_TYPE(i)->tp_name);
991 if (own_r) {
992 Py_DECREF(r);
993 }
994 return NULL;
995 }
996 }
997
998 /* If we get this far, then the "real" and "imag" parts should
999 both be treated as numbers, and the constructor should return a
1000 complex number equal to (real + imag*1j).
1001
1002 Note that we do NOT assume the input to already be in canonical
1003 form; the "real" and "imag" parts might themselves be complex
1004 numbers, which slightly complicates the code below. */
1005 if (PyComplex_Check(r)) {
1006 /* Note that if r is of a complex subtype, we're only
1007 retaining its real & imag parts here, and the return
1008 value is (properly) of the builtin complex type. */
1009 cr = ((PyComplexObject*)r)->cval;
1010 cr_is_complex = 1;
1011 if (own_r) {
1012 Py_DECREF(r);
1013 }
1014 }
1015 else {
1016 /* The "real" part really is entirely real, and contributes
1017 nothing in the imaginary direction.
1018 Just treat it as a double. */
1019 tmp = PyNumber_Float(r);
1020 if (own_r) {
1021 /* r was a newly created complex number, rather
1022 than the original "real" argument. */
1023 Py_DECREF(r);
1024 }
1025 if (tmp == NULL)
1026 return NULL;
1027 assert(PyFloat_Check(tmp));
1028 cr.real = PyFloat_AsDouble(tmp);
1029 cr.imag = 0.0;
1030 Py_DECREF(tmp);
1031 }
1032 if (i == NULL) {
1033 ci.real = cr.imag;
1034 }
1035 else if (PyComplex_Check(i)) {
1036 ci = ((PyComplexObject*)i)->cval;
1037 ci_is_complex = 1;
1038 } else {
1039 /* The "imag" part really is entirely imaginary, and
1040 contributes nothing in the real direction.
1041 Just treat it as a double. */
1042 tmp = PyNumber_Float(i);
1043 if (tmp == NULL)
1044 return NULL;
1045 ci.real = PyFloat_AsDouble(tmp);
1046 Py_DECREF(tmp);
1047 }
1048 /* If the input was in canonical form, then the "real" and "imag"
1049 parts are real numbers, so that ci.imag and cr.imag are zero.
1050 We need this correction in case they were not real numbers. */
1051
1052 if (ci_is_complex) {
1053 cr.real -= ci.imag;
1054 }
1055 if (cr_is_complex && i != NULL) {
1056 ci.real += cr.imag;
1057 }
1058 return complex_subtype_from_doubles(type, cr.real, ci.real);
1059 }
1060
1061 static PyNumberMethods complex_as_number = {
1062 (binaryfunc)complex_add, /* nb_add */
1063 (binaryfunc)complex_sub, /* nb_subtract */
1064 (binaryfunc)complex_mul, /* nb_multiply */
1065 (binaryfunc)complex_remainder, /* nb_remainder */
1066 (binaryfunc)complex_divmod, /* nb_divmod */
1067 (ternaryfunc)complex_pow, /* nb_power */
1068 (unaryfunc)complex_neg, /* nb_negative */
1069 (unaryfunc)complex_pos, /* nb_positive */
1070 (unaryfunc)complex_abs, /* nb_absolute */
1071 (inquiry)complex_bool, /* nb_bool */
1072 0, /* nb_invert */
1073 0, /* nb_lshift */
1074 0, /* nb_rshift */
1075 0, /* nb_and */
1076 0, /* nb_xor */
1077 0, /* nb_or */
1078 complex_int, /* nb_int */
1079 0, /* nb_reserved */
1080 complex_float, /* nb_float */
1081 0, /* nb_inplace_add */
1082 0, /* nb_inplace_subtract */
1083 0, /* nb_inplace_multiply*/
1084 0, /* nb_inplace_remainder */
1085 0, /* nb_inplace_power */
1086 0, /* nb_inplace_lshift */
1087 0, /* nb_inplace_rshift */
1088 0, /* nb_inplace_and */
1089 0, /* nb_inplace_xor */
1090 0, /* nb_inplace_or */
1091 (binaryfunc)complex_int_div, /* nb_floor_divide */
1092 (binaryfunc)complex_div, /* nb_true_divide */
1093 0, /* nb_inplace_floor_divide */
1094 0, /* nb_inplace_true_divide */
1095 };
1096
1097 PyTypeObject PyComplex_Type = {
1098 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1099 "complex",
1100 sizeof(PyComplexObject),
1101 0,
1102 0, /* tp_dealloc */
1103 0, /* tp_vectorcall_offset */
1104 0, /* tp_getattr */
1105 0, /* tp_setattr */
1106 0, /* tp_as_async */
1107 (reprfunc)complex_repr, /* tp_repr */
1108 &complex_as_number, /* tp_as_number */
1109 0, /* tp_as_sequence */
1110 0, /* tp_as_mapping */
1111 (hashfunc)complex_hash, /* tp_hash */
1112 0, /* tp_call */
1113 0, /* tp_str */
1114 PyObject_GenericGetAttr, /* tp_getattro */
1115 0, /* tp_setattro */
1116 0, /* tp_as_buffer */
1117 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
1118 complex_new__doc__, /* tp_doc */
1119 0, /* tp_traverse */
1120 0, /* tp_clear */
1121 complex_richcompare, /* tp_richcompare */
1122 0, /* tp_weaklistoffset */
1123 0, /* tp_iter */
1124 0, /* tp_iternext */
1125 complex_methods, /* tp_methods */
1126 complex_members, /* tp_members */
1127 0, /* tp_getset */
1128 0, /* tp_base */
1129 0, /* tp_dict */
1130 0, /* tp_descr_get */
1131 0, /* tp_descr_set */
1132 0, /* tp_dictoffset */
1133 0, /* tp_init */
1134 PyType_GenericAlloc, /* tp_alloc */
1135 complex_new, /* tp_new */
1136 PyObject_Del, /* tp_free */
1137 };
1138