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