blob: a49da4018411e70b1b8ac4d13c7bcfa78675b9f8 [file] [log] [blame]
Guido van Rossum96783941997-05-20 18:21:34 +00001
Guido van Rossumf9fca921996-01-12 00:47:05 +00002/* Complex object implementation */
3
4/* Borrows heavily from floatobject.c */
5
Guido van Rossum96783941997-05-20 18:21:34 +00006/* Submitted by Jim Hugunin */
7
Guido van Rossumc0b618a1997-05-02 03:12:38 +00008#include "Python.h"
Tim Peters6d6c1a32001-08-02 04:15:00 +00009#include "structmember.h"
Guido van Rossumf9fca921996-01-12 00:47:05 +000010
Serhiy Storchaka18b250f2017-03-19 08:51:07 +020011/*[clinic input]
12class 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
Guido van Rossumf9fca921996-01-12 00:47:05 +000018/* elementary operations on complex numbers */
19
Guido van Rossum9e720e31996-07-21 02:31:35 +000020static Py_complex c_1 = {1., 0.};
Guido van Rossumf9fca921996-01-12 00:47:05 +000021
Tim Peters0f336042001-03-18 08:21:57 +000022Py_complex
Antoine Pitrou1eee8e52014-07-07 18:49:30 -040023_Py_c_sum(Py_complex a, Py_complex b)
Guido van Rossumf9fca921996-01-12 00:47:05 +000024{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000025 Py_complex r;
26 r.real = a.real + b.real;
27 r.imag = a.imag + b.imag;
28 return r;
Guido van Rossumf9fca921996-01-12 00:47:05 +000029}
30
Tim Peters0f336042001-03-18 08:21:57 +000031Py_complex
Antoine Pitrou1eee8e52014-07-07 18:49:30 -040032_Py_c_diff(Py_complex a, Py_complex b)
Guido van Rossumf9fca921996-01-12 00:47:05 +000033{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000034 Py_complex r;
35 r.real = a.real - b.real;
36 r.imag = a.imag - b.imag;
37 return r;
Guido van Rossumf9fca921996-01-12 00:47:05 +000038}
39
Tim Peters0f336042001-03-18 08:21:57 +000040Py_complex
Antoine Pitrou1eee8e52014-07-07 18:49:30 -040041_Py_c_neg(Py_complex a)
Guido van Rossumf9fca921996-01-12 00:47:05 +000042{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000043 Py_complex r;
44 r.real = -a.real;
45 r.imag = -a.imag;
46 return r;
Guido van Rossumf9fca921996-01-12 00:47:05 +000047}
48
Tim Peters0f336042001-03-18 08:21:57 +000049Py_complex
Antoine Pitrou1eee8e52014-07-07 18:49:30 -040050_Py_c_prod(Py_complex a, Py_complex b)
Guido van Rossumf9fca921996-01-12 00:47:05 +000051{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000052 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;
Guido van Rossumf9fca921996-01-12 00:47:05 +000056}
57
Miss Islington (bot)f72886a2019-06-12 11:27:15 -070058/* Avoid bad optimization on Windows ARM64 until the compiler is fixed */
59#ifdef _M_ARM64
60#pragma optimize("", off)
61#endif
Tim Peters0f336042001-03-18 08:21:57 +000062Py_complex
Antoine Pitrou1eee8e52014-07-07 18:49:30 -040063_Py_c_quot(Py_complex a, Py_complex b)
Guido van Rossumf9fca921996-01-12 00:47:05 +000064{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000065 /******************************************************************
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:
Tim Peters0f336042001-03-18 08:21:57 +000071
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000072 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 ******************************************************************/
Tim Peters0f336042001-03-18 08:21:57 +000080
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000081 /* 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;
Tim Peters0f336042001-03-18 08:21:57 +000091
Antoine Pitrou9086f922014-10-10 23:49:32 +020092 if (abs_breal >= abs_bimag) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000093 /* 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 }
Antoine Pitrou9086f922014-10-10 23:49:32 +0200105 else if (abs_bimag >= abs_breal) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000106 /* 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 }
Antoine Pitrou9086f922014-10-10 23:49:32 +0200113 else {
114 /* At least one of b.real or b.imag is a NaN */
115 r.real = r.imag = Py_NAN;
116 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000117 return r;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000118}
Miss Islington (bot)f72886a2019-06-12 11:27:15 -0700119#ifdef _M_ARM64
120#pragma optimize("", on)
121#endif
Guido van Rossumf9fca921996-01-12 00:47:05 +0000122
Tim Peters0f336042001-03-18 08:21:57 +0000123Py_complex
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400124_Py_c_pow(Py_complex a, Py_complex b)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000125{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000126 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;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000151}
152
Tim Peters0f336042001-03-18 08:21:57 +0000153static Py_complex
154c_powu(Py_complex x, long n)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000155{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000156 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)
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400162 r = _Py_c_prod(r,p);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000163 mask <<= 1;
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400164 p = _Py_c_prod(p,p);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000165 }
166 return r;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000167}
168
Tim Peters0f336042001-03-18 08:21:57 +0000169static Py_complex
170c_powi(Py_complex x, long n)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000171{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000172 Py_complex cn;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000173
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000174 if (n > 100 || n < -100) {
175 cn.real = (double) n;
176 cn.imag = 0.;
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400177 return _Py_c_pow(x,cn);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000178 }
179 else if (n > 0)
180 return c_powu(x,n);
181 else
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400182 return _Py_c_quot(c_1, c_powu(x,-n));
Guido van Rossumf9fca921996-01-12 00:47:05 +0000183
184}
185
Christian Heimes53876d92008-04-19 00:31:39 +0000186double
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400187_Py_c_abs(Py_complex z)
Christian Heimes53876d92008-04-19 00:31:39 +0000188{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000189 /* sets errno = ERANGE on overflow; otherwise errno = 0 */
190 double result;
Christian Heimes53876d92008-04-19 00:31:39 +0000191
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000192 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;
Christian Heimes53876d92008-04-19 00:31:39 +0000216}
217
Tim Peters6d6c1a32001-08-02 04:15:00 +0000218static PyObject *
219complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)
220{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000221 PyObject *op;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000222
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000223 op = type->tp_alloc(type, 0);
224 if (op != NULL)
225 ((PyComplexObject *)op)->cval = cval;
226 return op;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000227}
228
Guido van Rossumf9fca921996-01-12 00:47:05 +0000229PyObject *
Fred Drake4288c802000-07-09 04:36:04 +0000230PyComplex_FromCComplex(Py_complex cval)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000231{
Antoine Pitrou9ed5f272013-08-13 20:18:52 +0200232 PyComplexObject *op;
Guido van Rossumb18618d2000-05-03 23:44:39 +0000233
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000234 /* Inline PyObject_New */
235 op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
236 if (op == NULL)
237 return PyErr_NoMemory();
Victor Stinnerb509d522018-11-23 14:27:38 +0100238 (void)PyObject_INIT(op, &PyComplex_Type);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000239 op->cval = cval;
240 return (PyObject *) op;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000241}
242
Tim Peters6d6c1a32001-08-02 04:15:00 +0000243static PyObject *
244complex_subtype_from_doubles(PyTypeObject *type, double real, double imag)
245{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000246 Py_complex c;
247 c.real = real;
248 c.imag = imag;
249 return complex_subtype_from_c_complex(type, c);
Tim Peters6d6c1a32001-08-02 04:15:00 +0000250}
251
Guido van Rossumf9fca921996-01-12 00:47:05 +0000252PyObject *
Fred Drake4288c802000-07-09 04:36:04 +0000253PyComplex_FromDoubles(double real, double imag)
Guido van Rossum926518b1996-08-19 19:30:45 +0000254{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000255 Py_complex c;
256 c.real = real;
257 c.imag = imag;
258 return PyComplex_FromCComplex(c);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000259}
260
261double
Fred Drake4288c802000-07-09 04:36:04 +0000262PyComplex_RealAsDouble(PyObject *op)
Guido van Rossum926518b1996-08-19 19:30:45 +0000263{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000264 if (PyComplex_Check(op)) {
265 return ((PyComplexObject *)op)->cval.real;
266 }
267 else {
268 return PyFloat_AsDouble(op);
269 }
Guido van Rossumf9fca921996-01-12 00:47:05 +0000270}
271
272double
Fred Drake4288c802000-07-09 04:36:04 +0000273PyComplex_ImagAsDouble(PyObject *op)
Guido van Rossum926518b1996-08-19 19:30:45 +0000274{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000275 if (PyComplex_Check(op)) {
276 return ((PyComplexObject *)op)->cval.imag;
277 }
278 else {
279 return 0.0;
280 }
Guido van Rossumf9fca921996-01-12 00:47:05 +0000281}
282
Benjamin Petersonaea44282010-01-04 01:10:28 +0000283static PyObject *
Serhiy Storchaka671079e2017-03-24 21:28:43 +0200284try_complex_special_method(PyObject *op)
285{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000286 PyObject *f;
Benjamin Petersonce798522012-01-22 11:24:29 -0500287 _Py_IDENTIFIER(__complex__);
Benjamin Petersonaea44282010-01-04 01:10:28 +0000288
Benjamin Petersonce798522012-01-22 11:24:29 -0500289 f = _PyObject_LookupSpecial(op, &PyId___complex__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000290 if (f) {
Victor Stinnerf17c3de2016-12-06 18:46:19 +0100291 PyObject *res = _PyObject_CallNoArg(f);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000292 Py_DECREF(f);
Serhiy Storchaka671079e2017-03-24 21:28:43 +0200293 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)) {
Mark Dickinsond20fb822012-11-14 17:08:31 +0000309 Py_DECREF(res);
310 return NULL;
311 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000312 return res;
313 }
314 return NULL;
Benjamin Petersonaea44282010-01-04 01:10:28 +0000315}
316
Guido van Rossum9e720e31996-07-21 02:31:35 +0000317Py_complex
Fred Drake4288c802000-07-09 04:36:04 +0000318PyComplex_AsCComplex(PyObject *op)
Guido van Rossum926518b1996-08-19 19:30:45 +0000319{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000320 Py_complex cv;
321 PyObject *newop = NULL;
Guido van Rossumd8faa362007-04-27 19:54:29 +0000322
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000323 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 */
Guido van Rossumd8faa362007-04-27 19:54:29 +0000329
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000330 /* return -1 on failure */
331 cv.real = -1.;
332 cv.imag = 0.;
333
334 newop = try_complex_special_method(op);
335
336 if (newop) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000337 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 }
Guido van Rossumcf3d1081996-01-12 01:21:14 +0000351}
352
Eric Smith0923d1d2009-04-16 20:16:10 +0000353static PyObject *
Eric Smith70099a12010-12-04 13:27:34 +0000354complex_repr(PyComplexObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000355{
Eric Smith70099a12010-12-04 13:27:34 +0000356 int precision = 0;
357 char format_code = 'r';
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000358 PyObject *result = NULL;
Eric Smith0923d1d2009-04-16 20:16:10 +0000359
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000360 /* If these are non-NULL, they'll need to be freed. */
361 char *pre = NULL;
362 char *im = NULL;
Eric Smith0923d1d2009-04-16 20:16:10 +0000363
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000364 /* 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. */
Serhiy Storchakae2f92de2017-11-11 13:06:26 +0200367 const char *re = NULL;
368 const char *lead = "";
369 const char *tail = "";
Eric Smith0923d1d2009-04-16 20:16:10 +0000370
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000371 if (v->cval.real == 0. && copysign(1.0, v->cval.real)==1.0) {
Eric Smith70099a12010-12-04 13:27:34 +0000372 /* Real part is +0: just output the imaginary part and do not
373 include parens. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000374 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 {
Eric Smith70099a12010-12-04 13:27:34 +0000382 /* Format imaginary part with sign, real part without. Include
383 parens in the result. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000384 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;
Eric Smith0923d1d2009-04-16 20:16:10 +0000391
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000392 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 }
Victor Stinner6ced7c42011-03-21 18:15:42 +0100401 result = PyUnicode_FromFormat("%s%s%sj%s", lead, re, im, tail);
Mark Dickinsonad476da2009-04-23 19:14:16 +0000402 done:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000403 PyMem_Free(im);
404 PyMem_Free(pre);
Eric Smith0923d1d2009-04-16 20:16:10 +0000405
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000406 return result;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000407}
408
Benjamin Peterson8f67d082010-10-17 20:54:53 +0000409static Py_hash_t
Fred Drake4288c802000-07-09 04:36:04 +0000410complex_hash(PyComplexObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000411{
Benjamin Peterson8035bc52010-10-23 16:20:50 +0000412 Py_uhash_t hashreal, hashimag, combined;
413 hashreal = (Py_uhash_t)_Py_HashDouble(v->cval.real);
414 if (hashreal == (Py_uhash_t)-1)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000415 return -1;
Benjamin Peterson8035bc52010-10-23 16:20:50 +0000416 hashimag = (Py_uhash_t)_Py_HashDouble(v->cval.imag);
417 if (hashimag == (Py_uhash_t)-1)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000418 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 */
Mark Dickinsondc787d22010-05-23 13:33:13 +0000425 combined = hashreal + _PyHASH_IMAG * hashimag;
Benjamin Peterson8035bc52010-10-23 16:20:50 +0000426 if (combined == (Py_uhash_t)-1)
427 combined = (Py_uhash_t)-2;
Benjamin Peterson8f67d082010-10-17 20:54:53 +0000428 return (Py_hash_t)combined;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000429}
430
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000431/* This macro may return! */
432#define TO_COMPLEX(obj, c) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000433 if (PyComplex_Check(obj)) \
434 c = ((PyComplexObject *)(obj))->cval; \
435 else if (to_complex(&(obj), &(c)) < 0) \
436 return (obj)
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000437
438static int
439to_complex(PyObject **pobj, Py_complex *pc)
440{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000441 PyObject *obj = *pobj;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000442
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000443 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;
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000459}
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000460
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000461
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000462static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000463complex_add(PyObject *v, PyObject *w)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000464{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000465 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)
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400470 result = _Py_c_sum(a, b);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000471 PyFPE_END_PROTECT(result)
472 return PyComplex_FromCComplex(result);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000473}
474
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000475static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000476complex_sub(PyObject *v, PyObject *w)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000477{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000478 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)
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400483 result = _Py_c_diff(a, b);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000484 PyFPE_END_PROTECT(result)
485 return PyComplex_FromCComplex(result);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000486}
487
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000488static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000489complex_mul(PyObject *v, PyObject *w)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000490{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000491 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)
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400496 result = _Py_c_prod(a, b);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000497 PyFPE_END_PROTECT(result)
498 return PyComplex_FromCComplex(result);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000499}
500
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000501static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000502complex_div(PyObject *v, PyObject *w)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000503{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000504 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;
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400510 quot = _Py_c_quot(a, b);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000511 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);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000517}
518
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000519static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000520complex_remainder(PyObject *v, PyObject *w)
Guido van Rossumee09fc11996-09-11 13:55:55 +0000521{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000522 PyErr_SetString(PyExc_TypeError,
523 "can't mod complex numbers.");
524 return NULL;
Guido van Rossumee09fc11996-09-11 13:55:55 +0000525}
526
Guido van Rossumee09fc11996-09-11 13:55:55 +0000527
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000528static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000529complex_divmod(PyObject *v, PyObject *w)
Guido van Rossum3be12e91996-09-12 20:56:18 +0000530{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000531 PyErr_SetString(PyExc_TypeError,
532 "can't take floor or mod of complex number.");
533 return NULL;
Guido van Rossum3be12e91996-09-12 20:56:18 +0000534}
Guido van Rossumf9fca921996-01-12 00:47:05 +0000535
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000536static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000537complex_pow(PyObject *v, PyObject *w, PyObject *z)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000538{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000539 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);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000545
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000546 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
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400557 p = _Py_c_pow(a, exponent);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000558
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000559 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);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000572}
573
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000574static PyObject *
Guido van Rossum3cf5b1e2006-07-27 21:53:35 +0000575complex_int_div(PyObject *v, PyObject *w)
Guido van Rossum4668b002001-08-08 05:00:18 +0000576{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000577 PyErr_SetString(PyExc_TypeError,
578 "can't take floor of complex number.");
579 return NULL;
Guido van Rossum4668b002001-08-08 05:00:18 +0000580}
581
582static PyObject *
Fred Drake4288c802000-07-09 04:36:04 +0000583complex_neg(PyComplexObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000584{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000585 Py_complex neg;
586 neg.real = -v->cval.real;
587 neg.imag = -v->cval.imag;
588 return PyComplex_FromCComplex(neg);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000589}
590
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000591static PyObject *
Fred Drake4288c802000-07-09 04:36:04 +0000592complex_pos(PyComplexObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000593{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000594 if (PyComplex_CheckExact(v)) {
595 Py_INCREF(v);
596 return (PyObject *)v;
597 }
598 else
599 return PyComplex_FromCComplex(v->cval);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000600}
601
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000602static PyObject *
Fred Drake4288c802000-07-09 04:36:04 +0000603complex_abs(PyComplexObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000604{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000605 double result;
Christian Heimes53876d92008-04-19 00:31:39 +0000606
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000607 PyFPE_START_PROTECT("complex_abs", return 0)
Antoine Pitrou1eee8e52014-07-07 18:49:30 -0400608 result = _Py_c_abs(v->cval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000609 PyFPE_END_PROTECT(result)
Christian Heimes53876d92008-04-19 00:31:39 +0000610
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000611 if (errno == ERANGE) {
612 PyErr_SetString(PyExc_OverflowError,
613 "absolute value too large");
614 return NULL;
615 }
616 return PyFloat_FromDouble(result);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000617}
618
619static int
Jack Diederich4dafcc42006-11-28 19:15:13 +0000620complex_bool(PyComplexObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000621{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000622 return v->cval.real != 0.0 || v->cval.imag != 0.0;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000623}
624
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000625static PyObject *
Guido van Rossumbe4cbb12001-01-18 01:12:39 +0000626complex_richcompare(PyObject *v, PyObject *w, int op)
627{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000628 PyObject *res;
Mark Dickinsoncc6a9822010-05-21 14:55:26 +0000629 Py_complex i;
630 int equal;
Guido van Rossumbe4cbb12001-01-18 01:12:39 +0000631
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000632 if (op != Py_EQ && op != Py_NE) {
Mark Dickinsoncc6a9822010-05-21 14:55:26 +0000633 goto Unimplemented;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000634 }
Guido van Rossum22056422001-09-24 17:52:04 +0000635
Mark Dickinsoncc6a9822010-05-21 14:55:26 +0000636 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;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000672 else
Mark Dickinsoncc6a9822010-05-21 14:55:26 +0000673 res = Py_False;
Guido van Rossumbe4cbb12001-01-18 01:12:39 +0000674
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000675 Py_INCREF(res);
676 return res;
Mark Dickinsoncc6a9822010-05-21 14:55:26 +0000677
678Unimplemented:
Brian Curtindfc80e32011-08-10 20:28:54 -0500679 Py_RETURN_NOTIMPLEMENTED;
Guido van Rossumbe4cbb12001-01-18 01:12:39 +0000680}
681
682static PyObject *
Fred Drake4288c802000-07-09 04:36:04 +0000683complex_int(PyObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000684{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000685 PyErr_SetString(PyExc_TypeError,
686 "can't convert complex to int");
687 return NULL;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000688}
689
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000690static PyObject *
Fred Drake4288c802000-07-09 04:36:04 +0000691complex_float(PyObject *v)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000692{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000693 PyErr_SetString(PyExc_TypeError,
694 "can't convert complex to float");
695 return NULL;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000696}
697
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000698static PyObject *
Siddhesh Poyarekar55edd0c2018-04-30 00:29:33 +0530699complex_conjugate(PyObject *self, PyObject *Py_UNUSED(ignored))
Guido van Rossumf9fca921996-01-12 00:47:05 +0000700{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000701 Py_complex c;
702 c = ((PyComplexObject *)self)->cval;
703 c.imag = -c.imag;
704 return PyComplex_FromCComplex(c);
Guido van Rossumf9fca921996-01-12 00:47:05 +0000705}
706
Guido van Rossum46334cd2007-08-01 17:43:15 +0000707PyDoc_STRVAR(complex_conjugate_doc,
708"complex.conjugate() -> complex\n"
709"\n"
Ezio Melotti488d2442013-10-06 00:39:18 +0300710"Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");
Guido van Rossum46334cd2007-08-01 17:43:15 +0000711
Guido van Rossum5d9113d2003-01-29 17:58:45 +0000712static PyObject *
Siddhesh Poyarekar55edd0c2018-04-30 00:29:33 +0530713complex_getnewargs(PyComplexObject *v, PyObject *Py_UNUSED(ignored))
Guido van Rossum5d9113d2003-01-29 17:58:45 +0000714{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000715 Py_complex c = v->cval;
716 return Py_BuildValue("(dd)", c.real, c.imag);
Guido van Rossum5d9113d2003-01-29 17:58:45 +0000717}
718
Eric Smith58a42242009-04-30 01:00:33 +0000719PyDoc_STRVAR(complex__format__doc,
720"complex.__format__() -> str\n"
721"\n"
Ezio Melotti488d2442013-10-06 00:39:18 +0300722"Convert to a string according to format_spec.");
Eric Smith58a42242009-04-30 01:00:33 +0000723
724static PyObject *
725complex__format__(PyObject* self, PyObject* args)
726{
727 PyObject *format_spec;
Victor Stinnerd3f08822012-05-29 12:57:52 +0200728 _PyUnicodeWriter writer;
729 int ret;
Eric Smith58a42242009-04-30 01:00:33 +0000730
731 if (!PyArg_ParseTuple(args, "U:__format__", &format_spec))
Victor Stinnerd3f08822012-05-29 12:57:52 +0200732 return NULL;
733
Victor Stinner8f674cc2013-04-17 23:02:17 +0200734 _PyUnicodeWriter_Init(&writer);
Victor Stinnerd3f08822012-05-29 12:57:52 +0200735 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);
Eric Smith58a42242009-04-30 01:00:33 +0000744}
745
Christian Heimes53876d92008-04-19 00:31:39 +0000746#if 0
747static PyObject *
748complex_is_finite(PyObject *self)
749{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000750 Py_complex c;
751 c = ((PyComplexObject *)self)->cval;
752 return PyBool_FromLong((long)(Py_IS_FINITE(c.real) &&
753 Py_IS_FINITE(c.imag)));
Christian Heimes53876d92008-04-19 00:31:39 +0000754}
755
756PyDoc_STRVAR(complex_is_finite_doc,
757"complex.is_finite() -> bool\n"
758"\n"
759"Returns True if the real and the imaginary part is finite.");
760#endif
761
Guido van Rossumf9fca921996-01-12 00:47:05 +0000762static PyMethodDef complex_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000763 {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS,
764 complex_conjugate_doc},
Christian Heimes53876d92008-04-19 00:31:39 +0000765#if 0
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000766 {"is_finite", (PyCFunction)complex_is_finite, METH_NOARGS,
767 complex_is_finite_doc},
Christian Heimes53876d92008-04-19 00:31:39 +0000768#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000769 {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS},
770 {"__format__", (PyCFunction)complex__format__,
771 METH_VARARGS, complex__format__doc},
772 {NULL, NULL} /* sentinel */
Guido van Rossumf9fca921996-01-12 00:47:05 +0000773};
774
Guido van Rossum6f799372001-09-20 20:46:19 +0000775static PyMemberDef complex_members[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000776 {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY,
777 "the real part of a complex number"},
778 {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY,
779 "the imaginary part of a complex number"},
780 {0},
Tim Peters6d6c1a32001-08-02 04:15:00 +0000781};
Guido van Rossumf9fca921996-01-12 00:47:05 +0000782
Guido van Rossumc0b618a1997-05-02 03:12:38 +0000783static PyObject *
Brett Cannona721aba2016-09-09 14:57:09 -0700784complex_from_string_inner(const char *s, Py_ssize_t len, void *type)
Guido van Rossumf9fca921996-01-12 00:47:05 +0000785{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000786 double x=0.0, y=0.0, z;
787 int got_bracket=0;
Brett Cannona721aba2016-09-09 14:57:09 -0700788 const char *start;
789 char *end;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000790
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000791 /* position on first nonblank */
792 start = s;
793 while (Py_ISSPACE(*s))
794 s++;
795 if (*s == '(') {
796 /* Skip over possible bracket from repr(). */
797 got_bracket = 1;
798 s++;
799 while (Py_ISSPACE(*s))
800 s++;
801 }
Tim Peters6d6c1a32001-08-02 04:15:00 +0000802
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000803 /* a valid complex string usually takes one of the three forms:
Mark Dickinson6649fa42009-04-24 13:25:20 +0000804
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000805 <float> - real part only
806 <float>j - imaginary part only
807 <float><signed-float>j - real and imaginary parts
Mark Dickinson6649fa42009-04-24 13:25:20 +0000808
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000809 where <float> represents any numeric string that's accepted by the
810 float constructor (including 'nan', 'inf', 'infinity', etc.), and
811 <signed-float> is any string of the form <float> whose first
812 character is '+' or '-'.
Mark Dickinson6649fa42009-04-24 13:25:20 +0000813
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000814 For backwards compatibility, the extra forms
Mark Dickinson6649fa42009-04-24 13:25:20 +0000815
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000816 <float><sign>j
817 <sign>j
818 j
Mark Dickinson6649fa42009-04-24 13:25:20 +0000819
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000820 are also accepted, though support for these forms may be removed from
821 a future version of Python.
822 */
Mark Dickinson6649fa42009-04-24 13:25:20 +0000823
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000824 /* first look for forms starting with <float> */
825 z = PyOS_string_to_double(s, &end, NULL);
826 if (z == -1.0 && PyErr_Occurred()) {
827 if (PyErr_ExceptionMatches(PyExc_ValueError))
828 PyErr_Clear();
829 else
Brett Cannona721aba2016-09-09 14:57:09 -0700830 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000831 }
832 if (end != s) {
833 /* all 4 forms starting with <float> land here */
834 s = end;
835 if (*s == '+' || *s == '-') {
836 /* <float><signed-float>j | <float><sign>j */
837 x = z;
838 y = PyOS_string_to_double(s, &end, NULL);
839 if (y == -1.0 && PyErr_Occurred()) {
840 if (PyErr_ExceptionMatches(PyExc_ValueError))
841 PyErr_Clear();
842 else
Brett Cannona721aba2016-09-09 14:57:09 -0700843 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000844 }
845 if (end != s)
846 /* <float><signed-float>j */
847 s = end;
848 else {
849 /* <float><sign>j */
850 y = *s == '+' ? 1.0 : -1.0;
851 s++;
852 }
853 if (!(*s == 'j' || *s == 'J'))
854 goto parse_error;
855 s++;
856 }
857 else if (*s == 'j' || *s == 'J') {
858 /* <float>j */
859 s++;
860 y = z;
861 }
862 else
863 /* <float> */
864 x = z;
865 }
866 else {
867 /* not starting with <float>; must be <sign>j or j */
868 if (*s == '+' || *s == '-') {
869 /* <sign>j */
870 y = *s == '+' ? 1.0 : -1.0;
871 s++;
872 }
873 else
874 /* j */
875 y = 1.0;
876 if (!(*s == 'j' || *s == 'J'))
877 goto parse_error;
878 s++;
879 }
Mark Dickinsonad476da2009-04-23 19:14:16 +0000880
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000881 /* trailing whitespace and closing bracket */
882 while (Py_ISSPACE(*s))
883 s++;
884 if (got_bracket) {
885 /* if there was an opening parenthesis, then the corresponding
886 closing parenthesis should be right here */
887 if (*s != ')')
888 goto parse_error;
889 s++;
890 while (Py_ISSPACE(*s))
891 s++;
892 }
Mark Dickinson6649fa42009-04-24 13:25:20 +0000893
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000894 /* we should now be at the end of the string */
895 if (s-start != len)
896 goto parse_error;
Tim Peters6d6c1a32001-08-02 04:15:00 +0000897
Brett Cannona721aba2016-09-09 14:57:09 -0700898 return complex_subtype_from_doubles((PyTypeObject *)type, x, y);
Mark Dickinsonad476da2009-04-23 19:14:16 +0000899
Mark Dickinson6649fa42009-04-24 13:25:20 +0000900 parse_error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000901 PyErr_SetString(PyExc_ValueError,
902 "complex() arg is a malformed string");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000903 return NULL;
Guido van Rossumf9fca921996-01-12 00:47:05 +0000904}
905
Tim Peters6d6c1a32001-08-02 04:15:00 +0000906static PyObject *
Brett Cannona721aba2016-09-09 14:57:09 -0700907complex_subtype_from_string(PyTypeObject *type, PyObject *v)
908{
909 const char *s;
910 PyObject *s_buffer = NULL, *result = NULL;
911 Py_ssize_t len;
912
913 if (PyUnicode_Check(v)) {
914 s_buffer = _PyUnicode_TransformDecimalAndSpaceToASCII(v);
915 if (s_buffer == NULL) {
916 return NULL;
917 }
Serhiy Storchaka9b6c60c2017-11-13 21:23:48 +0200918 assert(PyUnicode_IS_ASCII(s_buffer));
919 /* Simply get a pointer to existing ASCII characters. */
Brett Cannona721aba2016-09-09 14:57:09 -0700920 s = PyUnicode_AsUTF8AndSize(s_buffer, &len);
Serhiy Storchaka9b6c60c2017-11-13 21:23:48 +0200921 assert(s != NULL);
Brett Cannona721aba2016-09-09 14:57:09 -0700922 }
923 else {
924 PyErr_Format(PyExc_TypeError,
925 "complex() argument must be a string or a number, not '%.200s'",
926 Py_TYPE(v)->tp_name);
927 return NULL;
928 }
929
930 result = _Py_string_to_number_with_underscores(s, len, "complex", v, type,
931 complex_from_string_inner);
Brett Cannona721aba2016-09-09 14:57:09 -0700932 Py_DECREF(s_buffer);
933 return result;
934}
935
Serhiy Storchaka18b250f2017-03-19 08:51:07 +0200936/*[clinic input]
937@classmethod
938complex.__new__ as complex_new
Serhiy Storchakaba85d692017-03-30 09:09:41 +0300939 real as r: object(c_default="_PyLong_Zero") = 0
Serhiy Storchaka18b250f2017-03-19 08:51:07 +0200940 imag as i: object(c_default="NULL") = 0
941
942Create a complex number from a real part and an optional imaginary part.
943
944This is equivalent to (real + imag*1j) where imag defaults to 0.
945[clinic start generated code]*/
946
Brett Cannona721aba2016-09-09 14:57:09 -0700947static PyObject *
Serhiy Storchaka18b250f2017-03-19 08:51:07 +0200948complex_new_impl(PyTypeObject *type, PyObject *r, PyObject *i)
Serhiy Storchakabae68812017-04-05 12:00:42 +0300949/*[clinic end generated code: output=b6c7dd577b537dc1 input=6f6b0bedba29bcb5]*/
Tim Peters6d6c1a32001-08-02 04:15:00 +0000950{
Serhiy Storchaka18b250f2017-03-19 08:51:07 +0200951 PyObject *tmp;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000952 PyNumberMethods *nbr, *nbi = NULL;
953 Py_complex cr, ci;
954 int own_r = 0;
955 int cr_is_complex = 0;
956 int ci_is_complex = 0;
Raymond Hettinger604cd6a2002-08-29 14:22:51 +0000957
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000958 /* Special-case for a single argument when type(arg) is complex. */
959 if (PyComplex_CheckExact(r) && i == NULL &&
960 type == &PyComplex_Type) {
961 /* Note that we can't know whether it's safe to return
962 a complex *subclass* instance as-is, hence the restriction
963 to exact complexes here. If either the input or the
964 output is a complex subclass, it will be handled below
965 as a non-orthogonal vector. */
966 Py_INCREF(r);
967 return r;
968 }
969 if (PyUnicode_Check(r)) {
970 if (i != NULL) {
971 PyErr_SetString(PyExc_TypeError,
972 "complex() can't take second arg"
973 " if first is a string");
974 return NULL;
975 }
976 return complex_subtype_from_string(type, r);
977 }
978 if (i != NULL && PyUnicode_Check(i)) {
979 PyErr_SetString(PyExc_TypeError,
980 "complex() second arg can't be a string");
981 return NULL;
982 }
Tim Peters2400fa42001-09-12 19:12:49 +0000983
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000984 tmp = try_complex_special_method(r);
985 if (tmp) {
986 r = tmp;
987 own_r = 1;
988 }
989 else if (PyErr_Occurred()) {
990 return NULL;
991 }
Benjamin Petersonaea44282010-01-04 01:10:28 +0000992
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000993 nbr = r->ob_type->tp_as_number;
Serhiy Storchakabdbad712019-06-02 00:05:48 +0300994 if (nbr == NULL || (nbr->nb_float == NULL && nbr->nb_index == NULL)) {
Ezio Melottia5b95992013-11-07 19:18:34 +0200995 PyErr_Format(PyExc_TypeError,
Mark Dickinson613f8e52016-09-24 15:26:36 +0100996 "complex() first argument must be a string or a number, "
997 "not '%.200s'",
998 Py_TYPE(r)->tp_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000999 if (own_r) {
1000 Py_DECREF(r);
1001 }
1002 return NULL;
1003 }
Mark Dickinson613f8e52016-09-24 15:26:36 +01001004 if (i != NULL) {
1005 nbi = i->ob_type->tp_as_number;
Serhiy Storchakabdbad712019-06-02 00:05:48 +03001006 if (nbi == NULL || (nbi->nb_float == NULL && nbi->nb_index == NULL)) {
Mark Dickinson613f8e52016-09-24 15:26:36 +01001007 PyErr_Format(PyExc_TypeError,
1008 "complex() second argument must be a number, "
1009 "not '%.200s'",
1010 Py_TYPE(i)->tp_name);
1011 if (own_r) {
1012 Py_DECREF(r);
1013 }
1014 return NULL;
1015 }
1016 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00001017
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001018 /* If we get this far, then the "real" and "imag" parts should
1019 both be treated as numbers, and the constructor should return a
1020 complex number equal to (real + imag*1j).
Guido van Rossumd8faa362007-04-27 19:54:29 +00001021
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001022 Note that we do NOT assume the input to already be in canonical
1023 form; the "real" and "imag" parts might themselves be complex
1024 numbers, which slightly complicates the code below. */
1025 if (PyComplex_Check(r)) {
1026 /* Note that if r is of a complex subtype, we're only
1027 retaining its real & imag parts here, and the return
1028 value is (properly) of the builtin complex type. */
1029 cr = ((PyComplexObject*)r)->cval;
1030 cr_is_complex = 1;
1031 if (own_r) {
1032 Py_DECREF(r);
1033 }
1034 }
1035 else {
1036 /* The "real" part really is entirely real, and contributes
1037 nothing in the imaginary direction.
1038 Just treat it as a double. */
1039 tmp = PyNumber_Float(r);
1040 if (own_r) {
1041 /* r was a newly created complex number, rather
1042 than the original "real" argument. */
1043 Py_DECREF(r);
1044 }
1045 if (tmp == NULL)
1046 return NULL;
Serhiy Storchaka671079e2017-03-24 21:28:43 +02001047 assert(PyFloat_Check(tmp));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001048 cr.real = PyFloat_AsDouble(tmp);
Mark Dickinson112ec382017-02-20 20:28:15 +00001049 cr.imag = 0.0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001050 Py_DECREF(tmp);
1051 }
1052 if (i == NULL) {
Mark Dickinson112ec382017-02-20 20:28:15 +00001053 ci.real = cr.imag;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001054 }
1055 else if (PyComplex_Check(i)) {
1056 ci = ((PyComplexObject*)i)->cval;
1057 ci_is_complex = 1;
1058 } else {
1059 /* The "imag" part really is entirely imaginary, and
1060 contributes nothing in the real direction.
1061 Just treat it as a double. */
Serhiy Storchakabdbad712019-06-02 00:05:48 +03001062 tmp = PyNumber_Float(i);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001063 if (tmp == NULL)
1064 return NULL;
1065 ci.real = PyFloat_AsDouble(tmp);
1066 Py_DECREF(tmp);
1067 }
1068 /* If the input was in canonical form, then the "real" and "imag"
1069 parts are real numbers, so that ci.imag and cr.imag are zero.
1070 We need this correction in case they were not real numbers. */
Christian Heimes69a79632007-11-28 10:04:30 +00001071
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001072 if (ci_is_complex) {
1073 cr.real -= ci.imag;
1074 }
Mark Dickinson112ec382017-02-20 20:28:15 +00001075 if (cr_is_complex && i != NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001076 ci.real += cr.imag;
1077 }
1078 return complex_subtype_from_doubles(type, cr.real, ci.real);
Tim Peters6d6c1a32001-08-02 04:15:00 +00001079}
1080
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001081static PyNumberMethods complex_as_number = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001082 (binaryfunc)complex_add, /* nb_add */
1083 (binaryfunc)complex_sub, /* nb_subtract */
1084 (binaryfunc)complex_mul, /* nb_multiply */
1085 (binaryfunc)complex_remainder, /* nb_remainder */
1086 (binaryfunc)complex_divmod, /* nb_divmod */
1087 (ternaryfunc)complex_pow, /* nb_power */
1088 (unaryfunc)complex_neg, /* nb_negative */
1089 (unaryfunc)complex_pos, /* nb_positive */
1090 (unaryfunc)complex_abs, /* nb_absolute */
1091 (inquiry)complex_bool, /* nb_bool */
1092 0, /* nb_invert */
1093 0, /* nb_lshift */
1094 0, /* nb_rshift */
1095 0, /* nb_and */
1096 0, /* nb_xor */
1097 0, /* nb_or */
1098 complex_int, /* nb_int */
1099 0, /* nb_reserved */
1100 complex_float, /* nb_float */
1101 0, /* nb_inplace_add */
1102 0, /* nb_inplace_subtract */
1103 0, /* nb_inplace_multiply*/
1104 0, /* nb_inplace_remainder */
1105 0, /* nb_inplace_power */
1106 0, /* nb_inplace_lshift */
1107 0, /* nb_inplace_rshift */
1108 0, /* nb_inplace_and */
1109 0, /* nb_inplace_xor */
1110 0, /* nb_inplace_or */
1111 (binaryfunc)complex_int_div, /* nb_floor_divide */
1112 (binaryfunc)complex_div, /* nb_true_divide */
1113 0, /* nb_inplace_floor_divide */
1114 0, /* nb_inplace_true_divide */
Guido van Rossumf9fca921996-01-12 00:47:05 +00001115};
1116
Guido van Rossumc0b618a1997-05-02 03:12:38 +00001117PyTypeObject PyComplex_Type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001118 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1119 "complex",
1120 sizeof(PyComplexObject),
1121 0,
Inada Naoki7d408692019-05-29 17:23:27 +09001122 0, /* tp_dealloc */
Jeroen Demeyer530f5062019-05-31 04:13:39 +02001123 0, /* tp_vectorcall_offset */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001124 0, /* tp_getattr */
1125 0, /* tp_setattr */
Jeroen Demeyer530f5062019-05-31 04:13:39 +02001126 0, /* tp_as_async */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001127 (reprfunc)complex_repr, /* tp_repr */
1128 &complex_as_number, /* tp_as_number */
1129 0, /* tp_as_sequence */
1130 0, /* tp_as_mapping */
1131 (hashfunc)complex_hash, /* tp_hash */
1132 0, /* tp_call */
Serhiy Storchaka96aeaec2019-05-06 22:29:40 +03001133 0, /* tp_str */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001134 PyObject_GenericGetAttr, /* tp_getattro */
1135 0, /* tp_setattro */
1136 0, /* tp_as_buffer */
Serhiy Storchaka18b250f2017-03-19 08:51:07 +02001137 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
1138 complex_new__doc__, /* tp_doc */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001139 0, /* tp_traverse */
1140 0, /* tp_clear */
1141 complex_richcompare, /* tp_richcompare */
1142 0, /* tp_weaklistoffset */
1143 0, /* tp_iter */
1144 0, /* tp_iternext */
1145 complex_methods, /* tp_methods */
1146 complex_members, /* tp_members */
1147 0, /* tp_getset */
1148 0, /* tp_base */
1149 0, /* tp_dict */
1150 0, /* tp_descr_get */
1151 0, /* tp_descr_set */
1152 0, /* tp_dictoffset */
1153 0, /* tp_init */
1154 PyType_GenericAlloc, /* tp_alloc */
1155 complex_new, /* tp_new */
1156 PyObject_Del, /* tp_free */
Guido van Rossumf9fca921996-01-12 00:47:05 +00001157};