source: python/vendor/current/Objects/complexobject.c

Last change on this file was 388, checked in by dmik, 11 years ago

python: Update vendor to 2.7.6.
  • Property svn:eol-style set to native
File size: 37.4 KB
Line 
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#ifndef WITHOUT_COMPLEX
12
13/* Precisions used by repr() and str(), respectively.
14
15 The repr() precision (17 significant decimal digits) is the minimal number
16 that is guaranteed to have enough precision so that if the number is read
17 back in the exact same binary value is recreated. This is true for IEEE
18 floating point by design, and also happens to work for all other modern
19 hardware.
20
21 The str() precision is chosen so that in most cases, the rounding noise
22 created by various operations is suppressed, while giving plenty of
23 precision for practical use.
24*/
25
26#define PREC_REPR 17
27#define PREC_STR 12
28
29/* elementary operations on complex numbers */
30
31static Py_complex c_1 = {1., 0.};
32
33Py_complex
34c_sum(Py_complex a, Py_complex b)
35{
36 Py_complex r;
37 r.real = a.real + b.real;
38 r.imag = a.imag + b.imag;
39 return r;
40}
41
42Py_complex
43c_diff(Py_complex a, Py_complex b)
44{
45 Py_complex r;
46 r.real = a.real - b.real;
47 r.imag = a.imag - b.imag;
48 return r;
49}
50
51Py_complex
52c_neg(Py_complex a)
53{
54 Py_complex r;
55 r.real = -a.real;
56 r.imag = -a.imag;
57 return r;
58}
59
60Py_complex
61c_prod(Py_complex a, Py_complex b)
62{
63 Py_complex r;
64 r.real = a.real*b.real - a.imag*b.imag;
65 r.imag = a.real*b.imag + a.imag*b.real;
66 return r;
67}
68
69Py_complex
70c_quot(Py_complex a, Py_complex b)
71{
72 /******************************************************************
73 This was the original algorithm. It's grossly prone to spurious
74 overflow and underflow errors. It also merrily divides by 0 despite
75 checking for that(!). The code still serves a doc purpose here, as
76 the algorithm following is a simple by-cases transformation of this
77 one:
78
79 Py_complex r;
80 double d = b.real*b.real + b.imag*b.imag;
81 if (d == 0.)
82 errno = EDOM;
83 r.real = (a.real*b.real + a.imag*b.imag)/d;
84 r.imag = (a.imag*b.real - a.real*b.imag)/d;
85 return r;
86 ******************************************************************/
87
88 /* This algorithm is better, and is pretty obvious: first divide the
89 * numerators and denominator by whichever of {b.real, b.imag} has
90 * larger magnitude. The earliest reference I found was to CACM
91 * Algorithm 116 (Complex Division, Robert L. Smith, Stanford
92 * University). As usual, though, we're still ignoring all IEEE
93 * endcases.
94 */
95 Py_complex r; /* the result */
96 const double abs_breal = b.real < 0 ? -b.real : b.real;
97 const double abs_bimag = b.imag < 0 ? -b.imag : b.imag;
98
99 if (abs_breal >= abs_bimag) {
100 /* divide tops and bottom by b.real */
101 if (abs_breal == 0.0) {
102 errno = EDOM;
103 r.real = r.imag = 0.0;
104 }
105 else {
106 const double ratio = b.imag / b.real;
107 const double denom = b.real + b.imag * ratio;
108 r.real = (a.real + a.imag * ratio) / denom;
109 r.imag = (a.imag - a.real * ratio) / denom;
110 }
111 }
112 else {
113 /* divide tops and bottom by b.imag */
114 const double ratio = b.real / b.imag;
115 const double denom = b.real * ratio + b.imag;
116 assert(b.imag != 0.0);
117 r.real = (a.real * ratio + a.imag) / denom;
118 r.imag = (a.imag * ratio - a.real) / denom;
119 }
120 return r;
121}
122
123Py_complex
124c_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
153static Py_complex
154c_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 = c_prod(r,p);
163 mask <<= 1;
164 p = c_prod(p,p);
165 }
166 return r;
167}
168
169static Py_complex
170c_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 c_pow(x,cn);
178 }
179 else if (n > 0)
180 return c_powu(x,n);
181 else
182 return c_quot(c_1,c_powu(x,-n));
183
184}
185
186double
187c_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
218static PyObject *
219complex_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
229PyObject *
230PyComplex_FromCComplex(Py_complex cval)
231{
232 register PyComplexObject *op;
233
234 /* Inline PyObject_New */
235 op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
236 if (op == NULL)
237 return PyErr_NoMemory();
238 PyObject_INIT(op, &PyComplex_Type);
239 op->cval = cval;
240 return (PyObject *) op;
241}
242
243static PyObject *
244complex_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
252PyObject *
253PyComplex_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
261double
262PyComplex_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
272double
273PyComplex_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
283static PyObject *
284try_complex_special_method(PyObject *op) {
285 PyObject *f;
286 static PyObject *complexstr;
287
288 if (complexstr == NULL) {
289 complexstr = PyString_InternFromString("__complex__");
290 if (complexstr == NULL)
291 return NULL;
292 }
293 if (PyInstance_Check(op)) {
294 f = PyObject_GetAttr(op, complexstr);
295 if (f == NULL) {
296 if (PyErr_ExceptionMatches(PyExc_AttributeError))
297 PyErr_Clear();
298 else
299 return NULL;
300 }
301 }
302 else {
303 f = _PyObject_LookupSpecial(op, "__complex__", &complexstr);
304 if (f == NULL && PyErr_Occurred())
305 return NULL;
306 }
307 if (f != NULL) {
308 PyObject *res = PyObject_CallFunctionObjArgs(f, NULL);
309 Py_DECREF(f);
310 return res;
311 }
312 return NULL;
313}
314
315Py_complex
316PyComplex_AsCComplex(PyObject *op)
317{
318 Py_complex cv;
319 PyObject *newop = NULL;
320
321 assert(op);
322 /* If op is already of type PyComplex_Type, return its value */
323 if (PyComplex_Check(op)) {
324 return ((PyComplexObject *)op)->cval;
325 }
326 /* If not, use op's __complex__ method, if it exists */
327
328 /* return -1 on failure */
329 cv.real = -1.;
330 cv.imag = 0.;
331
332 newop = try_complex_special_method(op);
333
334 if (newop) {
335 if (!PyComplex_Check(newop)) {
336 PyErr_SetString(PyExc_TypeError,
337 "__complex__ should return a complex object");
338 Py_DECREF(newop);
339 return cv;
340 }
341 cv = ((PyComplexObject *)newop)->cval;
342 Py_DECREF(newop);
343 return cv;
344 }
345 else if (PyErr_Occurred()) {
346 return cv;
347 }
348 /* If neither of the above works, interpret op as a float giving the
349 real part of the result, and fill in the imaginary part as 0. */
350 else {
351 /* PyFloat_AsDouble will return -1 on failure */
352 cv.real = PyFloat_AsDouble(op);
353 return cv;
354 }
355}
356
357static void
358complex_dealloc(PyObject *op)
359{
360 op->ob_type->tp_free(op);
361}
362
363
364static PyObject *
365complex_format(PyComplexObject *v, int precision, char format_code)
366{
367 PyObject *result = NULL;
368 Py_ssize_t len;
369
370 /* If these are non-NULL, they'll need to be freed. */
371 char *pre = NULL;
372 char *im = NULL;
373 char *buf = NULL;
374
375 /* These do not need to be freed. re is either an alias
376 for pre or a pointer to a constant. lead and tail
377 are pointers to constants. */
378 char *re = NULL;
379 char *lead = "";
380 char *tail = "";
381
382 if (v->cval.real == 0. && copysign(1.0, v->cval.real)==1.0) {
383 re = "";
384 im = PyOS_double_to_string(v->cval.imag, format_code,
385 precision, 0, NULL);
386 if (!im) {
387 PyErr_NoMemory();
388 goto done;
389 }
390 } else {
391 /* Format imaginary part with sign, real part without */
392 pre = PyOS_double_to_string(v->cval.real, format_code,
393 precision, 0, NULL);
394 if (!pre) {
395 PyErr_NoMemory();
396 goto done;
397 }
398 re = pre;
399
400 im = PyOS_double_to_string(v->cval.imag, format_code,
401 precision, Py_DTSF_SIGN, NULL);
402 if (!im) {
403 PyErr_NoMemory();
404 goto done;
405 }
406 lead = "(";
407 tail = ")";
408 }
409 /* Alloc the final buffer. Add one for the "j" in the format string,
410 and one for the trailing zero. */
411 len = strlen(lead) + strlen(re) + strlen(im) + strlen(tail) + 2;
412 buf = PyMem_Malloc(len);
413 if (!buf) {
414 PyErr_NoMemory();
415 goto done;
416 }
417 PyOS_snprintf(buf, len, "%s%s%sj%s", lead, re, im, tail);
418 result = PyString_FromString(buf);
419 done:
420 PyMem_Free(im);
421 PyMem_Free(pre);
422 PyMem_Free(buf);
423
424 return result;
425}
426
427static int
428complex_print(PyComplexObject *v, FILE *fp, int flags)
429{
430 PyObject *formatv;
431 char *buf;
432 if (flags & Py_PRINT_RAW)
433 formatv = complex_format(v, PyFloat_STR_PRECISION, 'g');
434 else
435 formatv = complex_format(v, 0, 'r');
436 if (formatv == NULL)
437 return -1;
438 buf = PyString_AS_STRING(formatv);
439 Py_BEGIN_ALLOW_THREADS
440 fputs(buf, fp);
441 Py_END_ALLOW_THREADS
442 Py_DECREF(formatv);
443 return 0;
444}
445
446static PyObject *
447complex_repr(PyComplexObject *v)
448{
449 return complex_format(v, 0, 'r');
450}
451
452static PyObject *
453complex_str(PyComplexObject *v)
454{
455 return complex_format(v, PyFloat_STR_PRECISION, 'g');
456}
457
458static long
459complex_hash(PyComplexObject *v)
460{
461 long hashreal, hashimag, combined;
462 hashreal = _Py_HashDouble(v->cval.real);
463 if (hashreal == -1)
464 return -1;
465 hashimag = _Py_HashDouble(v->cval.imag);
466 if (hashimag == -1)
467 return -1;
468 /* Note: if the imaginary part is 0, hashimag is 0 now,
469 * so the following returns hashreal unchanged. This is
470 * important because numbers of different types that
471 * compare equal must have the same hash value, so that
472 * hash(x + 0*j) must equal hash(x).
473 */
474 combined = hashreal + 1000003 * hashimag;
475 if (combined == -1)
476 combined = -2;
477 return combined;
478}
479
480/* This macro may return! */
481#define TO_COMPLEX(obj, c) \
482 if (PyComplex_Check(obj)) \
483 c = ((PyComplexObject *)(obj))->cval; \
484 else if (to_complex(&(obj), &(c)) < 0) \
485 return (obj)
486
487static int
488to_complex(PyObject **pobj, Py_complex *pc)
489{
490 PyObject *obj = *pobj;
491
492 pc->real = pc->imag = 0.0;
493 if (PyInt_Check(obj)) {
494 pc->real = PyInt_AS_LONG(obj);
495 return 0;
496 }
497 if (PyLong_Check(obj)) {
498 pc->real = PyLong_AsDouble(obj);
499 if (pc->real == -1.0 && PyErr_Occurred()) {
500 *pobj = NULL;
501 return -1;
502 }
503 return 0;
504 }
505 if (PyFloat_Check(obj)) {
506 pc->real = PyFloat_AsDouble(obj);
507 return 0;
508 }
509 Py_INCREF(Py_NotImplemented);
510 *pobj = Py_NotImplemented;
511 return -1;
512}
513
514
515static PyObject *
516complex_add(PyObject *v, PyObject *w)
517{
518 Py_complex result;
519 Py_complex a, b;
520 TO_COMPLEX(v, a);
521 TO_COMPLEX(w, b);
522 PyFPE_START_PROTECT("complex_add", return 0)
523 result = c_sum(a, b);
524 PyFPE_END_PROTECT(result)
525 return PyComplex_FromCComplex(result);
526}
527
528static PyObject *
529complex_sub(PyObject *v, PyObject *w)
530{
531 Py_complex result;
532 Py_complex a, b;
533 TO_COMPLEX(v, a);
534 TO_COMPLEX(w, b);;
535 PyFPE_START_PROTECT("complex_sub", return 0)
536 result = c_diff(a, b);
537 PyFPE_END_PROTECT(result)
538 return PyComplex_FromCComplex(result);
539}
540
541static PyObject *
542complex_mul(PyObject *v, PyObject *w)
543{
544 Py_complex result;
545 Py_complex a, b;
546 TO_COMPLEX(v, a);
547 TO_COMPLEX(w, b);
548 PyFPE_START_PROTECT("complex_mul", return 0)
549 result = c_prod(a, b);
550 PyFPE_END_PROTECT(result)
551 return PyComplex_FromCComplex(result);
552}
553
554static PyObject *
555complex_div(PyObject *v, PyObject *w)
556{
557 Py_complex quot;
558 Py_complex a, b;
559 TO_COMPLEX(v, a);
560 TO_COMPLEX(w, b);
561 PyFPE_START_PROTECT("complex_div", return 0)
562 errno = 0;
563 quot = c_quot(a, b);
564 PyFPE_END_PROTECT(quot)
565 if (errno == EDOM) {
566 PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero");
567 return NULL;
568 }
569 return PyComplex_FromCComplex(quot);
570}
571
572static PyObject *
573complex_classic_div(PyObject *v, PyObject *w)
574{
575 Py_complex quot;
576 Py_complex a, b;
577 TO_COMPLEX(v, a);
578 TO_COMPLEX(w, b);
579 if (Py_DivisionWarningFlag >= 2 &&
580 PyErr_Warn(PyExc_DeprecationWarning,
581 "classic complex division") < 0)
582 return NULL;
583
584 PyFPE_START_PROTECT("complex_classic_div", return 0)
585 errno = 0;
586 quot = c_quot(a, b);
587 PyFPE_END_PROTECT(quot)
588 if (errno == EDOM) {
589 PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero");
590 return NULL;
591 }
592 return PyComplex_FromCComplex(quot);
593}
594
595static PyObject *
596complex_remainder(PyObject *v, PyObject *w)
597{
598 Py_complex div, mod;
599 Py_complex a, b;
600 TO_COMPLEX(v, a);
601 TO_COMPLEX(w, b);
602 if (PyErr_Warn(PyExc_DeprecationWarning,
603 "complex divmod(), // and % are deprecated") < 0)
604 return NULL;
605
606 errno = 0;
607 div = c_quot(a, b); /* The raw divisor value. */
608 if (errno == EDOM) {
609 PyErr_SetString(PyExc_ZeroDivisionError, "complex remainder");
610 return NULL;
611 }
612 div.real = floor(div.real); /* Use the floor of the real part. */
613 div.imag = 0.0;
614 mod = c_diff(a, c_prod(b, div));
615
616 return PyComplex_FromCComplex(mod);
617}
618
619
620static PyObject *
621complex_divmod(PyObject *v, PyObject *w)
622{
623 Py_complex div, mod;
624 PyObject *d, *m, *z;
625 Py_complex a, b;
626 TO_COMPLEX(v, a);
627 TO_COMPLEX(w, b);
628 if (PyErr_Warn(PyExc_DeprecationWarning,
629 "complex divmod(), // and % are deprecated") < 0)
630 return NULL;
631
632 errno = 0;
633 div = c_quot(a, b); /* The raw divisor value. */
634 if (errno == EDOM) {
635 PyErr_SetString(PyExc_ZeroDivisionError, "complex divmod()");
636 return NULL;
637 }
638 div.real = floor(div.real); /* Use the floor of the real part. */
639 div.imag = 0.0;
640 mod = c_diff(a, c_prod(b, div));
641 d = PyComplex_FromCComplex(div);
642 m = PyComplex_FromCComplex(mod);
643 z = PyTuple_Pack(2, d, m);
644 Py_XDECREF(d);
645 Py_XDECREF(m);
646 return z;
647}
648
649static PyObject *
650complex_pow(PyObject *v, PyObject *w, PyObject *z)
651{
652 Py_complex p;
653 Py_complex exponent;
654 long int_exponent;
655 Py_complex a, b;
656 TO_COMPLEX(v, a);
657 TO_COMPLEX(w, b);
658 if (z!=Py_None) {
659 PyErr_SetString(PyExc_ValueError, "complex modulo");
660 return NULL;
661 }
662 PyFPE_START_PROTECT("complex_pow", return 0)
663 errno = 0;
664 exponent = b;
665 int_exponent = (long)exponent.real;
666 if (exponent.imag == 0. && exponent.real == int_exponent)
667 p = c_powi(a,int_exponent);
668 else
669 p = c_pow(a,exponent);
670
671 PyFPE_END_PROTECT(p)
672 Py_ADJUST_ERANGE2(p.real, p.imag);
673 if (errno == EDOM) {
674 PyErr_SetString(PyExc_ZeroDivisionError,
675 "0.0 to a negative or complex power");
676 return NULL;
677 }
678 else if (errno == ERANGE) {
679 PyErr_SetString(PyExc_OverflowError,
680 "complex exponentiation");
681 return NULL;
682 }
683 return PyComplex_FromCComplex(p);
684}
685
686static PyObject *
687complex_int_div(PyObject *v, PyObject *w)
688{
689 PyObject *t, *r;
690 Py_complex a, b;
691 TO_COMPLEX(v, a);
692 TO_COMPLEX(w, b);
693 if (PyErr_Warn(PyExc_DeprecationWarning,
694 "complex divmod(), // and % are deprecated") < 0)
695 return NULL;
696
697 t = complex_divmod(v, w);
698 if (t != NULL) {
699 r = PyTuple_GET_ITEM(t, 0);
700 Py_INCREF(r);
701 Py_DECREF(t);
702 return r;
703 }
704 return NULL;
705}
706
707static PyObject *
708complex_neg(PyComplexObject *v)
709{
710 Py_complex neg;
711 neg.real = -v->cval.real;
712 neg.imag = -v->cval.imag;
713 return PyComplex_FromCComplex(neg);
714}
715
716static PyObject *
717complex_pos(PyComplexObject *v)
718{
719 if (PyComplex_CheckExact(v)) {
720 Py_INCREF(v);
721 return (PyObject *)v;
722 }
723 else
724 return PyComplex_FromCComplex(v->cval);
725}
726
727static PyObject *
728complex_abs(PyComplexObject *v)
729{
730 double result;
731
732 PyFPE_START_PROTECT("complex_abs", return 0)
733 result = c_abs(v->cval);
734 PyFPE_END_PROTECT(result)
735
736 if (errno == ERANGE) {
737 PyErr_SetString(PyExc_OverflowError,
738 "absolute value too large");
739 return NULL;
740 }
741 return PyFloat_FromDouble(result);
742}
743
744static int
745complex_nonzero(PyComplexObject *v)
746{
747 return v->cval.real != 0.0 || v->cval.imag != 0.0;
748}
749
750static int
751complex_coerce(PyObject **pv, PyObject **pw)
752{
753 Py_complex cval;
754 cval.imag = 0.;
755 if (PyInt_Check(*pw)) {
756 cval.real = (double)PyInt_AsLong(*pw);
757 *pw = PyComplex_FromCComplex(cval);
758 Py_INCREF(*pv);
759 return 0;
760 }
761 else if (PyLong_Check(*pw)) {
762 cval.real = PyLong_AsDouble(*pw);
763 if (cval.real == -1.0 && PyErr_Occurred())
764 return -1;
765 *pw = PyComplex_FromCComplex(cval);
766 Py_INCREF(*pv);
767 return 0;
768 }
769 else if (PyFloat_Check(*pw)) {
770 cval.real = PyFloat_AsDouble(*pw);
771 *pw = PyComplex_FromCComplex(cval);
772 Py_INCREF(*pv);
773 return 0;
774 }
775 else if (PyComplex_Check(*pw)) {
776 Py_INCREF(*pv);
777 Py_INCREF(*pw);
778 return 0;
779 }
780 return 1; /* Can't do it */
781}
782
783static PyObject *
784complex_richcompare(PyObject *v, PyObject *w, int op)
785{
786 PyObject *res;
787 Py_complex i;
788 int equal;
789
790 if (op != Py_EQ && op != Py_NE) {
791 /* for backwards compatibility, comparisons with non-numbers return
792 * NotImplemented. Only comparisons with core numeric types raise
793 * TypeError.
794 */
795 if (PyInt_Check(w) || PyLong_Check(w) ||
796 PyFloat_Check(w) || PyComplex_Check(w)) {
797 PyErr_SetString(PyExc_TypeError,
798 "no ordering relation is defined "
799 "for complex numbers");
800 return NULL;
801 }
802 goto Unimplemented;
803 }
804
805 assert(PyComplex_Check(v));
806 TO_COMPLEX(v, i);
807
808 if (PyInt_Check(w) || PyLong_Check(w)) {
809 /* Check for 0.0 imaginary part first to avoid the rich
810 * comparison when possible.
811 */
812 if (i.imag == 0.0) {
813 PyObject *j, *sub_res;
814 j = PyFloat_FromDouble(i.real);
815 if (j == NULL)
816 return NULL;
817
818 sub_res = PyObject_RichCompare(j, w, op);
819 Py_DECREF(j);
820 return sub_res;
821 }
822 else {
823 equal = 0;
824 }
825 }
826 else if (PyFloat_Check(w)) {
827 equal = (i.real == PyFloat_AsDouble(w) && i.imag == 0.0);
828 }
829 else if (PyComplex_Check(w)) {
830 Py_complex j;
831
832 TO_COMPLEX(w, j);
833 equal = (i.real == j.real && i.imag == j.imag);
834 }
835 else {
836 goto Unimplemented;
837 }
838
839 if (equal == (op == Py_EQ))
840 res = Py_True;
841 else
842 res = Py_False;
843
844 Py_INCREF(res);
845 return res;
846
847 Unimplemented:
848 Py_INCREF(Py_NotImplemented);
849 return Py_NotImplemented;
850}
851
852static PyObject *
853complex_int(PyObject *v)
854{
855 PyErr_SetString(PyExc_TypeError,
856 "can't convert complex to int");
857 return NULL;
858}
859
860static PyObject *
861complex_long(PyObject *v)
862{
863 PyErr_SetString(PyExc_TypeError,
864 "can't convert complex to long");
865 return NULL;
866}
867
868static PyObject *
869complex_float(PyObject *v)
870{
871 PyErr_SetString(PyExc_TypeError,
872 "can't convert complex to float");
873 return NULL;
874}
875
876static PyObject *
877complex_conjugate(PyObject *self)
878{
879 Py_complex c;
880 c = ((PyComplexObject *)self)->cval;
881 c.imag = -c.imag;
882 return PyComplex_FromCComplex(c);
883}
884
885PyDoc_STRVAR(complex_conjugate_doc,
886"complex.conjugate() -> complex\n"
887"\n"
888"Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");
889
890static PyObject *
891complex_getnewargs(PyComplexObject *v)
892{
893 Py_complex c = v->cval;
894 return Py_BuildValue("(dd)", c.real, c.imag);
895}
896
897PyDoc_STRVAR(complex__format__doc,
898"complex.__format__() -> str\n"
899"\n"
900"Convert to a string according to format_spec.");
901
902static PyObject *
903complex__format__(PyObject* self, PyObject* args)
904{
905 PyObject *format_spec;
906
907 if (!PyArg_ParseTuple(args, "O:__format__", &format_spec))
908 return NULL;
909 if (PyBytes_Check(format_spec))
910 return _PyComplex_FormatAdvanced(self,
911 PyBytes_AS_STRING(format_spec),
912 PyBytes_GET_SIZE(format_spec));
913 if (PyUnicode_Check(format_spec)) {
914 /* Convert format_spec to a str */
915 PyObject *result;
916 PyObject *str_spec = PyObject_Str(format_spec);
917
918 if (str_spec == NULL)
919 return NULL;
920
921 result = _PyComplex_FormatAdvanced(self,
922 PyBytes_AS_STRING(str_spec),
923 PyBytes_GET_SIZE(str_spec));
924
925 Py_DECREF(str_spec);
926 return result;
927 }
928 PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode");
929 return NULL;
930}
931
932#if 0
933static PyObject *
934complex_is_finite(PyObject *self)
935{
936 Py_complex c;
937 c = ((PyComplexObject *)self)->cval;
938 return PyBool_FromLong((long)(Py_IS_FINITE(c.real) &&
939 Py_IS_FINITE(c.imag)));
940}
941
942PyDoc_STRVAR(complex_is_finite_doc,
943"complex.is_finite() -> bool\n"
944"\n"
945"Returns True if the real and the imaginary part is finite.");
946#endif
947
948static PyMethodDef complex_methods[] = {
949 {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS,
950 complex_conjugate_doc},
951#if 0
952 {"is_finite", (PyCFunction)complex_is_finite, METH_NOARGS,
953 complex_is_finite_doc},
954#endif
955 {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS},
956 {"__format__", (PyCFunction)complex__format__,
957 METH_VARARGS, complex__format__doc},
958 {NULL, NULL} /* sentinel */
959};
960
961static PyMemberDef complex_members[] = {
962 {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY,
963 "the real part of a complex number"},
964 {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY,
965 "the imaginary part of a complex number"},
966 {0},
967};
968
969static PyObject *
970complex_subtype_from_string(PyTypeObject *type, PyObject *v)
971{
972 const char *s, *start;
973 char *end;
974 double x=0.0, y=0.0, z;
975 int got_bracket=0;
976#ifdef Py_USING_UNICODE
977 char *s_buffer = NULL;
978#endif
979 Py_ssize_t len;
980
981 if (PyString_Check(v)) {
982 s = PyString_AS_STRING(v);
983 len = PyString_GET_SIZE(v);
984 }
985#ifdef Py_USING_UNICODE
986 else if (PyUnicode_Check(v)) {
987 s_buffer = (char *)PyMem_MALLOC(PyUnicode_GET_SIZE(v)+1);
988 if (s_buffer == NULL)
989 return PyErr_NoMemory();
990 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v),
991 PyUnicode_GET_SIZE(v),
992 s_buffer,
993 NULL))
994 goto error;
995 s = s_buffer;
996 len = strlen(s);
997 }
998#endif
999 else if (PyObject_AsCharBuffer(v, &s, &len)) {
1000 PyErr_SetString(PyExc_TypeError,
1001 "complex() arg is not a string");
1002 return NULL;
1003 }
1004
1005 /* position on first nonblank */
1006 start = s;
1007 while (Py_ISSPACE(*s))
1008 s++;
1009 if (*s == '(') {
1010 /* Skip over possible bracket from repr(). */
1011 got_bracket = 1;
1012 s++;
1013 while (Py_ISSPACE(*s))
1014 s++;
1015 }
1016
1017 /* a valid complex string usually takes one of the three forms:
1018
1019 <float> - real part only
1020 <float>j - imaginary part only
1021 <float><signed-float>j - real and imaginary parts
1022
1023 where <float> represents any numeric string that's accepted by the
1024 float constructor (including 'nan', 'inf', 'infinity', etc.), and
1025 <signed-float> is any string of the form <float> whose first
1026 character is '+' or '-'.
1027
1028 For backwards compatibility, the extra forms
1029
1030 <float><sign>j
1031 <sign>j
1032 j
1033
1034 are also accepted, though support for these forms may be removed from
1035 a future version of Python.
1036 */
1037
1038 /* first look for forms starting with <float> */
1039 z = PyOS_string_to_double(s, &end, NULL);
1040 if (z == -1.0 && PyErr_Occurred()) {
1041 if (PyErr_ExceptionMatches(PyExc_ValueError))
1042 PyErr_Clear();
1043 else
1044 goto error;
1045 }
1046 if (end != s) {
1047 /* all 4 forms starting with <float> land here */
1048 s = end;
1049 if (*s == '+' || *s == '-') {
1050 /* <float><signed-float>j | <float><sign>j */
1051 x = z;
1052 y = PyOS_string_to_double(s, &end, NULL);
1053 if (y == -1.0 && PyErr_Occurred()) {
1054 if (PyErr_ExceptionMatches(PyExc_ValueError))
1055 PyErr_Clear();
1056 else
1057 goto error;
1058 }
1059 if (end != s)
1060 /* <float><signed-float>j */
1061 s = end;
1062 else {
1063 /* <float><sign>j */
1064 y = *s == '+' ? 1.0 : -1.0;
1065 s++;
1066 }
1067 if (!(*s == 'j' || *s == 'J'))
1068 goto parse_error;
1069 s++;
1070 }
1071 else if (*s == 'j' || *s == 'J') {
1072 /* <float>j */
1073 s++;
1074 y = z;
1075 }
1076 else
1077 /* <float> */
1078 x = z;
1079 }
1080 else {
1081 /* not starting with <float>; must be <sign>j or j */
1082 if (*s == '+' || *s == '-') {
1083 /* <sign>j */
1084 y = *s == '+' ? 1.0 : -1.0;
1085 s++;
1086 }
1087 else
1088 /* j */
1089 y = 1.0;
1090 if (!(*s == 'j' || *s == 'J'))
1091 goto parse_error;
1092 s++;
1093 }
1094
1095 /* trailing whitespace and closing bracket */
1096 while (Py_ISSPACE(*s))
1097 s++;
1098 if (got_bracket) {
1099 /* if there was an opening parenthesis, then the corresponding
1100 closing parenthesis should be right here */
1101 if (*s != ')')
1102 goto parse_error;
1103 s++;
1104 while (Py_ISSPACE(*s))
1105 s++;
1106 }
1107
1108 /* we should now be at the end of the string */
1109 if (s-start != len)
1110 goto parse_error;
1111
1112
1113#ifdef Py_USING_UNICODE
1114 if (s_buffer)
1115 PyMem_FREE(s_buffer);
1116#endif
1117 return complex_subtype_from_doubles(type, x, y);
1118
1119 parse_error:
1120 PyErr_SetString(PyExc_ValueError,
1121 "complex() arg is a malformed string");
1122 error:
1123#ifdef Py_USING_UNICODE
1124 if (s_buffer)
1125 PyMem_FREE(s_buffer);
1126#endif
1127 return NULL;
1128}
1129
1130static PyObject *
1131complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1132{
1133 PyObject *r, *i, *tmp;
1134 PyNumberMethods *nbr, *nbi = NULL;
1135 Py_complex cr, ci;
1136 int own_r = 0;
1137 int cr_is_complex = 0;
1138 int ci_is_complex = 0;
1139 static char *kwlist[] = {"real", "imag", 0};
1140
1141 r = Py_False;
1142 i = NULL;
1143 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO:complex", kwlist,
1144 &r, &i))
1145 return NULL;
1146
1147 /* Special-case for a single argument when type(arg) is complex. */
1148 if (PyComplex_CheckExact(r) && i == NULL &&
1149 type == &PyComplex_Type) {
1150 /* Note that we can't know whether it's safe to return
1151 a complex *subclass* instance as-is, hence the restriction
1152 to exact complexes here. If either the input or the
1153 output is a complex subclass, it will be handled below
1154 as a non-orthogonal vector. */
1155 Py_INCREF(r);
1156 return r;
1157 }
1158 if (PyString_Check(r) || PyUnicode_Check(r)) {
1159 if (i != NULL) {
1160 PyErr_SetString(PyExc_TypeError,
1161 "complex() can't take second arg"
1162 " if first is a string");
1163 return NULL;
1164 }
1165 return complex_subtype_from_string(type, r);
1166 }
1167 if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) {
1168 PyErr_SetString(PyExc_TypeError,
1169 "complex() second arg can't be a string");
1170 return NULL;
1171 }
1172
1173 tmp = try_complex_special_method(r);
1174 if (tmp) {
1175 r = tmp;
1176 own_r = 1;
1177 }
1178 else if (PyErr_Occurred()) {
1179 return NULL;
1180 }
1181
1182 nbr = r->ob_type->tp_as_number;
1183 if (i != NULL)
1184 nbi = i->ob_type->tp_as_number;
1185 if (nbr == NULL || nbr->nb_float == NULL ||
1186 ((i != NULL) && (nbi == NULL || nbi->nb_float == NULL))) {
1187 PyErr_SetString(PyExc_TypeError,
1188 "complex() argument must be a string or a number");
1189 if (own_r) {
1190 Py_DECREF(r);
1191 }
1192 return NULL;
1193 }
1194
1195 /* If we get this far, then the "real" and "imag" parts should
1196 both be treated as numbers, and the constructor should return a
1197 complex number equal to (real + imag*1j).
1198
1199 Note that we do NOT assume the input to already be in canonical
1200 form; the "real" and "imag" parts might themselves be complex
1201 numbers, which slightly complicates the code below. */
1202 if (PyComplex_Check(r)) {
1203 /* Note that if r is of a complex subtype, we're only
1204 retaining its real & imag parts here, and the return
1205 value is (properly) of the builtin complex type. */
1206 cr = ((PyComplexObject*)r)->cval;
1207 cr_is_complex = 1;
1208 if (own_r) {
1209 Py_DECREF(r);
1210 }
1211 }
1212 else {
1213 /* The "real" part really is entirely real, and contributes
1214 nothing in the imaginary direction.
1215 Just treat it as a double. */
1216 tmp = PyNumber_Float(r);
1217 if (own_r) {
1218 /* r was a newly created complex number, rather
1219 than the original "real" argument. */
1220 Py_DECREF(r);
1221 }
1222 if (tmp == NULL)
1223 return NULL;
1224 if (!PyFloat_Check(tmp)) {
1225 PyErr_SetString(PyExc_TypeError,
1226 "float(r) didn't return a float");
1227 Py_DECREF(tmp);
1228 return NULL;
1229 }
1230 cr.real = PyFloat_AsDouble(tmp);
1231 cr.imag = 0.0; /* Shut up compiler warning */
1232 Py_DECREF(tmp);
1233 }
1234 if (i == NULL) {
1235 ci.real = 0.0;
1236 }
1237 else if (PyComplex_Check(i)) {
1238 ci = ((PyComplexObject*)i)->cval;
1239 ci_is_complex = 1;
1240 } else {
1241 /* The "imag" part really is entirely imaginary, and
1242 contributes nothing in the real direction.
1243 Just treat it as a double. */
1244 tmp = (*nbi->nb_float)(i);
1245 if (tmp == NULL)
1246 return NULL;
1247 ci.real = PyFloat_AsDouble(tmp);
1248 Py_DECREF(tmp);
1249 }
1250 /* If the input was in canonical form, then the "real" and "imag"
1251 parts are real numbers, so that ci.imag and cr.imag are zero.
1252 We need this correction in case they were not real numbers. */
1253
1254 if (ci_is_complex) {
1255 cr.real -= ci.imag;
1256 }
1257 if (cr_is_complex) {
1258 ci.real += cr.imag;
1259 }
1260 return complex_subtype_from_doubles(type, cr.real, ci.real);
1261}
1262
1263PyDoc_STRVAR(complex_doc,
1264"complex(real[, imag]) -> complex number\n"
1265"\n"
1266"Create a complex number from a real part and an optional imaginary part.\n"
1267"This is equivalent to (real + imag*1j) where imag defaults to 0.");
1268
1269static PyNumberMethods complex_as_number = {
1270 (binaryfunc)complex_add, /* nb_add */
1271 (binaryfunc)complex_sub, /* nb_subtract */
1272 (binaryfunc)complex_mul, /* nb_multiply */
1273 (binaryfunc)complex_classic_div, /* nb_divide */
1274 (binaryfunc)complex_remainder, /* nb_remainder */
1275 (binaryfunc)complex_divmod, /* nb_divmod */
1276 (ternaryfunc)complex_pow, /* nb_power */
1277 (unaryfunc)complex_neg, /* nb_negative */
1278 (unaryfunc)complex_pos, /* nb_positive */
1279 (unaryfunc)complex_abs, /* nb_absolute */
1280 (inquiry)complex_nonzero, /* nb_nonzero */
1281 0, /* nb_invert */
1282 0, /* nb_lshift */
1283 0, /* nb_rshift */
1284 0, /* nb_and */
1285 0, /* nb_xor */
1286 0, /* nb_or */
1287 complex_coerce, /* nb_coerce */
1288 complex_int, /* nb_int */
1289 complex_long, /* nb_long */
1290 complex_float, /* nb_float */
1291 0, /* nb_oct */
1292 0, /* nb_hex */
1293 0, /* nb_inplace_add */
1294 0, /* nb_inplace_subtract */
1295 0, /* nb_inplace_multiply*/
1296 0, /* nb_inplace_divide */
1297 0, /* nb_inplace_remainder */
1298 0, /* nb_inplace_power */
1299 0, /* nb_inplace_lshift */
1300 0, /* nb_inplace_rshift */
1301 0, /* nb_inplace_and */
1302 0, /* nb_inplace_xor */
1303 0, /* nb_inplace_or */
1304 (binaryfunc)complex_int_div, /* nb_floor_divide */
1305 (binaryfunc)complex_div, /* nb_true_divide */
1306 0, /* nb_inplace_floor_divide */
1307 0, /* nb_inplace_true_divide */
1308};
1309
1310PyTypeObject PyComplex_Type = {
1311 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1312 "complex",
1313 sizeof(PyComplexObject),
1314 0,
1315 complex_dealloc, /* tp_dealloc */
1316 (printfunc)complex_print, /* tp_print */
1317 0, /* tp_getattr */
1318 0, /* tp_setattr */
1319 0, /* tp_compare */
1320 (reprfunc)complex_repr, /* tp_repr */
1321 &complex_as_number, /* tp_as_number */
1322 0, /* tp_as_sequence */
1323 0, /* tp_as_mapping */
1324 (hashfunc)complex_hash, /* tp_hash */
1325 0, /* tp_call */
1326 (reprfunc)complex_str, /* tp_str */
1327 PyObject_GenericGetAttr, /* tp_getattro */
1328 0, /* tp_setattro */
1329 0, /* tp_as_buffer */
1330 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
1331 Py_TPFLAGS_BASETYPE, /* tp_flags */
1332 complex_doc, /* tp_doc */
1333 0, /* tp_traverse */
1334 0, /* tp_clear */
1335 complex_richcompare, /* tp_richcompare */
1336 0, /* tp_weaklistoffset */
1337 0, /* tp_iter */
1338 0, /* tp_iternext */
1339 complex_methods, /* tp_methods */
1340 complex_members, /* tp_members */
1341 0, /* tp_getset */
1342 0, /* tp_base */
1343 0, /* tp_dict */
1344 0, /* tp_descr_get */
1345 0, /* tp_descr_set */
1346 0, /* tp_dictoffset */
1347 0, /* tp_init */
1348 PyType_GenericAlloc, /* tp_alloc */
1349 complex_new, /* tp_new */
1350 PyObject_Del, /* tp_free */
1351};
1352
1353#endif
Note: See TracBrowser for help on using the repository browser.