2 /* Complex object implementation */
4 /* Borrows heavily from floatobject.c */
6 /* Submitted by Jim Hugunin */
9 #include "structmember.h"
15 #ifndef WITHOUT_COMPLEX
17 /* Precisions used by repr() and str(), respectively.
19 The repr() precision (17 significant decimal digits) is the minimal number
20 that is guaranteed to have enough precision so that if the number is read
21 back in the exact same binary value is recreated. This is true for IEEE
22 floating point by design, and also happens to work for all other modern
25 The str() precision is chosen so that in most cases, the rounding noise
26 created by various operations is suppressed, while giving plenty of
27 precision for practical use.
33 /* elementary operations on complex numbers */
35 static Py_complex c_1
= {1., 0.};
38 c_sum(Py_complex a
, Py_complex b
)
41 r
.real
= a
.real
+ b
.real
;
42 r
.imag
= a
.imag
+ b
.imag
;
47 c_diff(Py_complex a
, Py_complex b
)
50 r
.real
= a
.real
- b
.real
;
51 r
.imag
= a
.imag
- b
.imag
;
65 c_prod(Py_complex a
, Py_complex b
)
68 r
.real
= a
.real
*b
.real
- a
.imag
*b
.imag
;
69 r
.imag
= a
.real
*b
.imag
+ a
.imag
*b
.real
;
74 c_quot(Py_complex a
, Py_complex b
)
76 /******************************************************************
77 This was the original algorithm. It's grossly prone to spurious
78 overflow and underflow errors. It also merrily divides by 0 despite
79 checking for that(!). The code still serves a doc purpose here, as
80 the algorithm following is a simple by-cases transformation of this
84 double d = b.real*b.real + b.imag*b.imag;
87 r.real = (a.real*b.real + a.imag*b.imag)/d;
88 r.imag = (a.imag*b.real - a.real*b.imag)/d;
90 ******************************************************************/
92 /* This algorithm is better, and is pretty obvious: first divide the
93 * numerators and denominator by whichever of {b.real, b.imag} has
94 * larger magnitude. The earliest reference I found was to CACM
95 * Algorithm 116 (Complex Division, Robert L. Smith, Stanford
96 * University). As usual, though, we're still ignoring all IEEE
99 Py_complex r
; /* the result */
100 const double abs_breal
= b
.real
< 0 ? -b
.real
: b
.real
;
101 const double abs_bimag
= b
.imag
< 0 ? -b
.imag
: b
.imag
;
103 if (abs_breal
>= abs_bimag
) {
104 /* divide tops and bottom by b.real */
105 if (abs_breal
== 0.0) {
107 r
.real
= r
.imag
= 0.0;
110 const double ratio
= b
.imag
/ b
.real
;
111 const double denom
= b
.real
+ b
.imag
* ratio
;
112 r
.real
= (a
.real
+ a
.imag
* ratio
) / denom
;
113 r
.imag
= (a
.imag
- a
.real
* ratio
) / denom
;
117 /* divide tops and bottom by b.imag */
118 const double ratio
= b
.real
/ b
.imag
;
119 const double denom
= b
.real
* ratio
+ b
.imag
;
120 assert(b
.imag
!= 0.0);
121 r
.real
= (a
.real
* ratio
+ a
.imag
) / denom
;
122 r
.imag
= (a
.imag
* ratio
- a
.real
) / denom
;
128 c_pow(Py_complex a
, Py_complex b
)
131 double vabs
,len
,at
,phase
;
132 if (b
.real
== 0. && b
.imag
== 0.) {
136 else if (a
.real
== 0. && a
.imag
== 0.) {
137 if (b
.imag
!= 0. || b
.real
< 0.)
143 vabs
= hypot(a
.real
,a
.imag
);
144 len
= pow(vabs
,b
.real
);
145 at
= atan2(a
.imag
, a
.real
);
148 len
/= exp(at
*b
.imag
);
149 phase
+= b
.imag
*log(vabs
);
151 r
.real
= len
*cos(phase
);
152 r
.imag
= len
*sin(phase
);
158 c_powu(Py_complex x
, long n
)
164 while (mask
> 0 && n
>= mask
) {
174 c_powi(Py_complex x
, long n
)
178 if (n
> 100 || n
< -100) {
179 cn
.real
= (double) n
;
186 return c_quot(c_1
,c_powu(x
,-n
));
193 /* sets errno = ERANGE on overflow; otherwise errno = 0 */
196 if (!Py_IS_FINITE(z
.real
) || !Py_IS_FINITE(z
.imag
)) {
197 /* C99 rules: if either the real or the imaginary part is an
198 infinity, return infinity, even if the other part is a
200 if (Py_IS_INFINITY(z
.real
)) {
201 result
= fabs(z
.real
);
205 if (Py_IS_INFINITY(z
.imag
)) {
206 result
= fabs(z
.imag
);
210 /* either the real or imaginary part is a NaN,
211 and neither is infinite. Result should be NaN. */
214 result
= hypot(z
.real
, z
.imag
);
215 if (!Py_IS_FINITE(result
))
223 complex_subtype_from_c_complex(PyTypeObject
*type
, Py_complex cval
)
227 op
= type
->tp_alloc(type
, 0);
229 ((PyComplexObject
*)op
)->cval
= cval
;
234 PyComplex_FromCComplex(Py_complex cval
)
236 register PyComplexObject
*op
;
238 /* Inline PyObject_New */
239 op
= (PyComplexObject
*) PyObject_MALLOC(sizeof(PyComplexObject
));
241 return PyErr_NoMemory();
242 PyObject_INIT(op
, &PyComplex_Type
);
244 return (PyObject
*) op
;
248 complex_subtype_from_doubles(PyTypeObject
*type
, double real
, double imag
)
253 return complex_subtype_from_c_complex(type
, c
);
257 PyComplex_FromDoubles(double real
, double imag
)
262 return PyComplex_FromCComplex(c
);
266 PyComplex_RealAsDouble(PyObject
*op
)
268 if (PyComplex_Check(op
)) {
269 return ((PyComplexObject
*)op
)->cval
.real
;
272 return PyFloat_AsDouble(op
);
277 PyComplex_ImagAsDouble(PyObject
*op
)
279 if (PyComplex_Check(op
)) {
280 return ((PyComplexObject
*)op
)->cval
.imag
;
288 PyComplex_AsCComplex(PyObject
*op
)
291 PyObject
*newop
= NULL
;
292 static PyObject
*complex_str
= NULL
;
295 /* If op is already of type PyComplex_Type, return its value */
296 if (PyComplex_Check(op
)) {
297 return ((PyComplexObject
*)op
)->cval
;
299 /* If not, use op's __complex__ method, if it exists */
301 /* return -1 on failure */
305 if (complex_str
== NULL
) {
306 if (!(complex_str
= PyString_InternFromString("__complex__")))
310 if (PyInstance_Check(op
)) {
311 /* this can go away in python 3000 */
312 if (PyObject_HasAttr(op
, complex_str
)) {
313 newop
= PyObject_CallMethod(op
, "__complex__", NULL
);
317 /* else try __float__ */
319 PyObject
*complexfunc
;
320 complexfunc
= _PyType_Lookup(op
->ob_type
, complex_str
);
321 /* complexfunc is a borrowed reference */
323 newop
= PyObject_CallFunctionObjArgs(complexfunc
, op
, NULL
);
330 if (!PyComplex_Check(newop
)) {
331 PyErr_SetString(PyExc_TypeError
,
332 "__complex__ should return a complex object");
336 cv
= ((PyComplexObject
*)newop
)->cval
;
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. */
343 /* PyFloat_AsDouble will return -1 on failure */
344 cv
.real
= PyFloat_AsDouble(op
);
350 complex_dealloc(PyObject
*op
)
352 op
->ob_type
->tp_free(op
);
357 complex_format(PyComplexObject
*v
, char format_code
)
359 PyObject
*result
= NULL
;
362 /* If these are non-NULL, they'll need to be freed. */
367 /* These do not need to be freed. re is either an alias
368 for pre or a pointer to a constant. lead and tail
369 are pointers to constants. */
374 if (v
->cval
.real
== 0. && copysign(1.0, v
->cval
.real
)==1.0) {
376 im
= PyOS_double_to_string(v
->cval
.imag
, format_code
,
383 /* Format imaginary part with sign, real part without */
384 pre
= PyOS_double_to_string(v
->cval
.real
, format_code
,
392 im
= PyOS_double_to_string(v
->cval
.imag
, format_code
,
393 0, Py_DTSF_SIGN
, NULL
);
401 /* Alloc the final buffer. Add one for the "j" in the format string,
402 and one for the trailing zero. */
403 len
= strlen(lead
) + strlen(re
) + strlen(im
) + strlen(tail
) + 2;
404 buf
= PyMem_Malloc(len
);
409 PyOS_snprintf(buf
, len
, "%s%s%sj%s", lead
, re
, im
, tail
);
410 result
= PyString_FromString(buf
);
420 complex_print(PyComplexObject
*v
, FILE *fp
, int flags
)
424 formatv
= complex_format(v
, (flags
& Py_PRINT_RAW
) ? 's' : 'r');
427 buf
= PyString_AS_STRING(formatv
);
428 Py_BEGIN_ALLOW_THREADS
436 complex_repr(PyComplexObject
*v
)
438 return complex_format(v
, 'r');
442 complex_str(PyComplexObject
*v
)
444 return complex_format(v
, 's');
448 complex_hash(PyComplexObject
*v
)
450 long hashreal
, hashimag
, combined
;
451 hashreal
= _Py_HashDouble(v
->cval
.real
);
454 hashimag
= _Py_HashDouble(v
->cval
.imag
);
457 /* Note: if the imaginary part is 0, hashimag is 0 now,
458 * so the following returns hashreal unchanged. This is
459 * important because numbers of different types that
460 * compare equal must have the same hash value, so that
461 * hash(x + 0*j) must equal hash(x).
463 combined
= hashreal
+ 1000003 * hashimag
;
469 /* This macro may return! */
470 #define TO_COMPLEX(obj, c) \
471 if (PyComplex_Check(obj)) \
472 c = ((PyComplexObject *)(obj))->cval; \
473 else if (to_complex(&(obj), &(c)) < 0) \
477 to_complex(PyObject
**pobj
, Py_complex
*pc
)
479 PyObject
*obj
= *pobj
;
481 pc
->real
= pc
->imag
= 0.0;
482 if (PyInt_Check(obj
)) {
483 pc
->real
= PyInt_AS_LONG(obj
);
486 if (PyLong_Check(obj
)) {
487 pc
->real
= PyLong_AsDouble(obj
);
488 if (pc
->real
== -1.0 && PyErr_Occurred()) {
494 if (PyFloat_Check(obj
)) {
495 pc
->real
= PyFloat_AsDouble(obj
);
498 Py_INCREF(Py_NotImplemented
);
499 *pobj
= Py_NotImplemented
;
505 complex_add(PyComplexObject
*v
, PyComplexObject
*w
)
508 PyFPE_START_PROTECT("complex_add", return 0)
509 result
= c_sum(v
->cval
,w
->cval
);
510 PyFPE_END_PROTECT(result
)
511 return PyComplex_FromCComplex(result
);
515 complex_sub(PyComplexObject
*v
, PyComplexObject
*w
)
518 PyFPE_START_PROTECT("complex_sub", return 0)
519 result
= c_diff(v
->cval
,w
->cval
);
520 PyFPE_END_PROTECT(result
)
521 return PyComplex_FromCComplex(result
);
525 complex_mul(PyComplexObject
*v
, PyComplexObject
*w
)
528 PyFPE_START_PROTECT("complex_mul", return 0)
529 result
= c_prod(v
->cval
,w
->cval
);
530 PyFPE_END_PROTECT(result
)
531 return PyComplex_FromCComplex(result
);
535 complex_div(PyComplexObject
*v
, PyComplexObject
*w
)
539 PyFPE_START_PROTECT("complex_div", return 0)
541 quot
= c_quot(v
->cval
,w
->cval
);
542 PyFPE_END_PROTECT(quot
)
544 PyErr_SetString(PyExc_ZeroDivisionError
, "complex division");
547 return PyComplex_FromCComplex(quot
);
551 complex_classic_div(PyComplexObject
*v
, PyComplexObject
*w
)
555 if (Py_DivisionWarningFlag
>= 2 &&
556 PyErr_Warn(PyExc_DeprecationWarning
,
557 "classic complex division") < 0)
560 PyFPE_START_PROTECT("complex_classic_div", return 0)
562 quot
= c_quot(v
->cval
,w
->cval
);
563 PyFPE_END_PROTECT(quot
)
565 PyErr_SetString(PyExc_ZeroDivisionError
, "complex division");
568 return PyComplex_FromCComplex(quot
);
572 complex_remainder(PyComplexObject
*v
, PyComplexObject
*w
)
576 if (PyErr_Warn(PyExc_DeprecationWarning
,
577 "complex divmod(), // and % are deprecated") < 0)
581 div
= c_quot(v
->cval
,w
->cval
); /* The raw divisor value. */
583 PyErr_SetString(PyExc_ZeroDivisionError
, "complex remainder");
586 div
.real
= floor(div
.real
); /* Use the floor of the real part. */
588 mod
= c_diff(v
->cval
, c_prod(w
->cval
, div
));
590 return PyComplex_FromCComplex(mod
);
595 complex_divmod(PyComplexObject
*v
, PyComplexObject
*w
)
600 if (PyErr_Warn(PyExc_DeprecationWarning
,
601 "complex divmod(), // and % are deprecated") < 0)
605 div
= c_quot(v
->cval
,w
->cval
); /* The raw divisor value. */
607 PyErr_SetString(PyExc_ZeroDivisionError
, "complex divmod()");
610 div
.real
= floor(div
.real
); /* Use the floor of the real part. */
612 mod
= c_diff(v
->cval
, c_prod(w
->cval
, div
));
613 d
= PyComplex_FromCComplex(div
);
614 m
= PyComplex_FromCComplex(mod
);
615 z
= PyTuple_Pack(2, d
, m
);
622 complex_pow(PyObject
*v
, PyObject
*w
, PyObject
*z
)
632 PyErr_SetString(PyExc_ValueError
, "complex modulo");
635 PyFPE_START_PROTECT("complex_pow", return 0)
638 int_exponent
= (long)exponent
.real
;
639 if (exponent
.imag
== 0. && exponent
.real
== int_exponent
)
640 p
= c_powi(a
,int_exponent
);
642 p
= c_pow(a
,exponent
);
645 Py_ADJUST_ERANGE2(p
.real
, p
.imag
);
647 PyErr_SetString(PyExc_ZeroDivisionError
,
648 "0.0 to a negative or complex power");
651 else if (errno
== ERANGE
) {
652 PyErr_SetString(PyExc_OverflowError
,
653 "complex exponentiation");
656 return PyComplex_FromCComplex(p
);
660 complex_int_div(PyComplexObject
*v
, PyComplexObject
*w
)
664 if (PyErr_Warn(PyExc_DeprecationWarning
,
665 "complex divmod(), // and % are deprecated") < 0)
668 t
= complex_divmod(v
, w
);
670 r
= PyTuple_GET_ITEM(t
, 0);
679 complex_neg(PyComplexObject
*v
)
682 neg
.real
= -v
->cval
.real
;
683 neg
.imag
= -v
->cval
.imag
;
684 return PyComplex_FromCComplex(neg
);
688 complex_pos(PyComplexObject
*v
)
690 if (PyComplex_CheckExact(v
)) {
692 return (PyObject
*)v
;
695 return PyComplex_FromCComplex(v
->cval
);
699 complex_abs(PyComplexObject
*v
)
703 PyFPE_START_PROTECT("complex_abs", return 0)
704 result
= c_abs(v
->cval
);
705 PyFPE_END_PROTECT(result
)
707 if (errno
== ERANGE
) {
708 PyErr_SetString(PyExc_OverflowError
,
709 "absolute value too large");
712 return PyFloat_FromDouble(result
);
716 complex_nonzero(PyComplexObject
*v
)
718 return v
->cval
.real
!= 0.0 || v
->cval
.imag
!= 0.0;
722 complex_coerce(PyObject
**pv
, PyObject
**pw
)
726 if (PyInt_Check(*pw
)) {
727 cval
.real
= (double)PyInt_AsLong(*pw
);
728 *pw
= PyComplex_FromCComplex(cval
);
732 else if (PyLong_Check(*pw
)) {
733 cval
.real
= PyLong_AsDouble(*pw
);
734 if (cval
.real
== -1.0 && PyErr_Occurred())
736 *pw
= PyComplex_FromCComplex(cval
);
740 else if (PyFloat_Check(*pw
)) {
741 cval
.real
= PyFloat_AsDouble(*pw
);
742 *pw
= PyComplex_FromCComplex(cval
);
746 else if (PyComplex_Check(*pw
)) {
751 return 1; /* Can't do it */
755 complex_richcompare(PyObject
*v
, PyObject
*w
, int op
)
761 c
= PyNumber_CoerceEx(&v
, &w
);
765 Py_INCREF(Py_NotImplemented
);
766 return Py_NotImplemented
;
768 /* Make sure both arguments are complex. */
769 if (!(PyComplex_Check(v
) && PyComplex_Check(w
))) {
772 Py_INCREF(Py_NotImplemented
);
773 return Py_NotImplemented
;
776 i
= ((PyComplexObject
*)v
)->cval
;
777 j
= ((PyComplexObject
*)w
)->cval
;
781 if (op
!= Py_EQ
&& op
!= Py_NE
) {
782 PyErr_SetString(PyExc_TypeError
,
783 "no ordering relation is defined for complex numbers");
787 if ((i
.real
== j
.real
&& i
.imag
== j
.imag
) == (op
== Py_EQ
))
797 complex_int(PyObject
*v
)
799 PyErr_SetString(PyExc_TypeError
,
800 "can't convert complex to int; use int(abs(z))");
805 complex_long(PyObject
*v
)
807 PyErr_SetString(PyExc_TypeError
,
808 "can't convert complex to long; use long(abs(z))");
813 complex_float(PyObject
*v
)
815 PyErr_SetString(PyExc_TypeError
,
816 "can't convert complex to float; use abs(z)");
821 complex_conjugate(PyObject
*self
)
824 c
= ((PyComplexObject
*)self
)->cval
;
826 return PyComplex_FromCComplex(c
);
829 PyDoc_STRVAR(complex_conjugate_doc
,
830 "complex.conjugate() -> complex\n"
832 "Returns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");
835 complex_getnewargs(PyComplexObject
*v
)
837 Py_complex c
= v
->cval
;
838 return Py_BuildValue("(dd)", c
.real
, c
.imag
);
843 complex_is_finite(PyObject
*self
)
846 c
= ((PyComplexObject
*)self
)->cval
;
847 return PyBool_FromLong((long)(Py_IS_FINITE(c
.real
) &&
848 Py_IS_FINITE(c
.imag
)));
851 PyDoc_STRVAR(complex_is_finite_doc
,
852 "complex.is_finite() -> bool\n"
854 "Returns True if the real and the imaginary part is finite.");
857 static PyMethodDef complex_methods
[] = {
858 {"conjugate", (PyCFunction
)complex_conjugate
, METH_NOARGS
,
859 complex_conjugate_doc
},
861 {"is_finite", (PyCFunction
)complex_is_finite
, METH_NOARGS
,
862 complex_is_finite_doc
},
864 {"__getnewargs__", (PyCFunction
)complex_getnewargs
, METH_NOARGS
},
865 {NULL
, NULL
} /* sentinel */
868 static PyMemberDef complex_members
[] = {
869 {"real", T_DOUBLE
, offsetof(PyComplexObject
, cval
.real
), READONLY
,
870 "the real part of a complex number"},
871 {"imag", T_DOUBLE
, offsetof(PyComplexObject
, cval
.imag
), READONLY
,
872 "the imaginary part of a complex number"},
877 complex_subtype_from_string(PyTypeObject
*type
, PyObject
*v
)
879 const char *s
, *start
;
881 double x
=0.0, y
=0.0, z
;
883 #ifdef Py_USING_UNICODE
888 if (PyString_Check(v
)) {
889 s
= PyString_AS_STRING(v
);
890 len
= PyString_GET_SIZE(v
);
892 #ifdef Py_USING_UNICODE
893 else if (PyUnicode_Check(v
)) {
894 if (PyUnicode_GET_SIZE(v
) >= (Py_ssize_t
)sizeof(s_buffer
)) {
895 PyErr_SetString(PyExc_ValueError
,
896 "complex() literal too large to convert");
899 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v
),
900 PyUnicode_GET_SIZE(v
),
908 else if (PyObject_AsCharBuffer(v
, &s
, &len
)) {
909 PyErr_SetString(PyExc_TypeError
,
910 "complex() arg is not a string");
916 /* position on first nonblank */
918 while (*s
&& isspace(Py_CHARMASK(*s
)))
921 /* Skip over possible bracket from repr(). */
924 while (*s
&& isspace(Py_CHARMASK(*s
)))
928 /* a valid complex string usually takes one of the three forms:
930 <float> - real part only
931 <float>j - imaginary part only
932 <float><signed-float>j - real and imaginary parts
934 where <float> represents any numeric string that's accepted by the
935 float constructor (including 'nan', 'inf', 'infinity', etc.), and
936 <signed-float> is any string of the form <float> whose first
937 character is '+' or '-'.
939 For backwards compatibility, the extra forms
945 are also accepted, though support for these forms may be removed from
946 a future version of Python.
949 /* first look for forms starting with <float> */
950 z
= PyOS_ascii_strtod(s
, &end
);
951 if (end
== s
&& errno
== ENOMEM
)
952 return PyErr_NoMemory();
953 if (errno
== ERANGE
&& fabs(z
) >= 1.0)
957 /* all 4 forms starting with <float> land here */
959 if (*s
== '+' || *s
== '-') {
960 /* <float><signed-float>j | <float><sign>j */
962 y
= PyOS_ascii_strtod(s
, &end
);
963 if (end
== s
&& errno
== ENOMEM
)
964 return PyErr_NoMemory();
965 if (errno
== ERANGE
&& fabs(z
) >= 1.0)
968 /* <float><signed-float>j */
972 y
= *s
== '+' ? 1.0 : -1.0;
975 if (!(*s
== 'j' || *s
== 'J'))
979 else if (*s
== 'j' || *s
== 'J') {
989 /* not starting with <float>; must be <sign>j or j */
990 if (*s
== '+' || *s
== '-') {
992 y
= *s
== '+' ? 1.0 : -1.0;
998 if (!(*s
== 'j' || *s
== 'J'))
1003 /* trailing whitespace and closing bracket */
1004 while (*s
&& isspace(Py_CHARMASK(*s
)))
1007 /* if there was an opening parenthesis, then the corresponding
1008 closing parenthesis should be right here */
1012 while (*s
&& isspace(Py_CHARMASK(*s
)))
1016 /* we should now be at the end of the string */
1020 return complex_subtype_from_doubles(type
, x
, y
);
1023 PyErr_SetString(PyExc_ValueError
,
1024 "complex() arg is a malformed string");
1028 PyErr_SetString(PyExc_OverflowError
,
1029 "complex() arg overflow");
1034 complex_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1036 PyObject
*r
, *i
, *tmp
, *f
;
1037 PyNumberMethods
*nbr
, *nbi
= NULL
;
1040 int cr_is_complex
= 0;
1041 int ci_is_complex
= 0;
1042 static PyObject
*complexstr
;
1043 static char *kwlist
[] = {"real", "imag", 0};
1047 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "|OO:complex", kwlist
,
1051 /* Special-case for a single argument when type(arg) is complex. */
1052 if (PyComplex_CheckExact(r
) && i
== NULL
&&
1053 type
== &PyComplex_Type
) {
1054 /* Note that we can't know whether it's safe to return
1055 a complex *subclass* instance as-is, hence the restriction
1056 to exact complexes here. If either the input or the
1057 output is a complex subclass, it will be handled below
1058 as a non-orthogonal vector. */
1062 if (PyString_Check(r
) || PyUnicode_Check(r
)) {
1064 PyErr_SetString(PyExc_TypeError
,
1065 "complex() can't take second arg"
1066 " if first is a string");
1069 return complex_subtype_from_string(type
, r
);
1071 if (i
!= NULL
&& (PyString_Check(i
) || PyUnicode_Check(i
))) {
1072 PyErr_SetString(PyExc_TypeError
,
1073 "complex() second arg can't be a string");
1077 /* XXX Hack to support classes with __complex__ method */
1078 if (complexstr
== NULL
) {
1079 complexstr
= PyString_InternFromString("__complex__");
1080 if (complexstr
== NULL
)
1083 f
= PyObject_GetAttr(r
, complexstr
);
1087 PyObject
*args
= PyTuple_New(0);
1090 r
= PyEval_CallObject(f
, args
);
1097 nbr
= r
->ob_type
->tp_as_number
;
1099 nbi
= i
->ob_type
->tp_as_number
;
1100 if (nbr
== NULL
|| nbr
->nb_float
== NULL
||
1101 ((i
!= NULL
) && (nbi
== NULL
|| nbi
->nb_float
== NULL
))) {
1102 PyErr_SetString(PyExc_TypeError
,
1103 "complex() argument must be a string or a number");
1110 /* If we get this far, then the "real" and "imag" parts should
1111 both be treated as numbers, and the constructor should return a
1112 complex number equal to (real + imag*1j).
1114 Note that we do NOT assume the input to already be in canonical
1115 form; the "real" and "imag" parts might themselves be complex
1116 numbers, which slightly complicates the code below. */
1117 if (PyComplex_Check(r
)) {
1118 /* Note that if r is of a complex subtype, we're only
1119 retaining its real & imag parts here, and the return
1120 value is (properly) of the builtin complex type. */
1121 cr
= ((PyComplexObject
*)r
)->cval
;
1128 /* The "real" part really is entirely real, and contributes
1129 nothing in the imaginary direction.
1130 Just treat it as a double. */
1131 tmp
= PyNumber_Float(r
);
1133 /* r was a newly created complex number, rather
1134 than the original "real" argument. */
1139 if (!PyFloat_Check(tmp
)) {
1140 PyErr_SetString(PyExc_TypeError
,
1141 "float(r) didn't return a float");
1145 cr
.real
= PyFloat_AsDouble(tmp
);
1146 cr
.imag
= 0.0; /* Shut up compiler warning */
1152 else if (PyComplex_Check(i
)) {
1153 ci
= ((PyComplexObject
*)i
)->cval
;
1156 /* The "imag" part really is entirely imaginary, and
1157 contributes nothing in the real direction.
1158 Just treat it as a double. */
1159 tmp
= (*nbi
->nb_float
)(i
);
1162 ci
.real
= PyFloat_AsDouble(tmp
);
1165 /* If the input was in canonical form, then the "real" and "imag"
1166 parts are real numbers, so that ci.imag and cr.imag are zero.
1167 We need this correction in case they were not real numbers. */
1169 if (ci_is_complex
) {
1172 if (cr_is_complex
) {
1175 return complex_subtype_from_doubles(type
, cr
.real
, ci
.real
);
1178 PyDoc_STRVAR(complex_doc
,
1179 "complex(real[, imag]) -> complex number\n"
1181 "Create a complex number from a real part and an optional imaginary part.\n"
1182 "This is equivalent to (real + imag*1j) where imag defaults to 0.");
1184 static PyNumberMethods complex_as_number
= {
1185 (binaryfunc
)complex_add
, /* nb_add */
1186 (binaryfunc
)complex_sub
, /* nb_subtract */
1187 (binaryfunc
)complex_mul
, /* nb_multiply */
1188 (binaryfunc
)complex_classic_div
, /* nb_divide */
1189 (binaryfunc
)complex_remainder
, /* nb_remainder */
1190 (binaryfunc
)complex_divmod
, /* nb_divmod */
1191 (ternaryfunc
)complex_pow
, /* nb_power */
1192 (unaryfunc
)complex_neg
, /* nb_negative */
1193 (unaryfunc
)complex_pos
, /* nb_positive */
1194 (unaryfunc
)complex_abs
, /* nb_absolute */
1195 (inquiry
)complex_nonzero
, /* nb_nonzero */
1202 complex_coerce
, /* nb_coerce */
1203 complex_int
, /* nb_int */
1204 complex_long
, /* nb_long */
1205 complex_float
, /* nb_float */
1208 0, /* nb_inplace_add */
1209 0, /* nb_inplace_subtract */
1210 0, /* nb_inplace_multiply*/
1211 0, /* nb_inplace_divide */
1212 0, /* nb_inplace_remainder */
1213 0, /* nb_inplace_power */
1214 0, /* nb_inplace_lshift */
1215 0, /* nb_inplace_rshift */
1216 0, /* nb_inplace_and */
1217 0, /* nb_inplace_xor */
1218 0, /* nb_inplace_or */
1219 (binaryfunc
)complex_int_div
, /* nb_floor_divide */
1220 (binaryfunc
)complex_div
, /* nb_true_divide */
1221 0, /* nb_inplace_floor_divide */
1222 0, /* nb_inplace_true_divide */
1225 PyTypeObject PyComplex_Type
= {
1226 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
1228 sizeof(PyComplexObject
),
1230 complex_dealloc
, /* tp_dealloc */
1231 (printfunc
)complex_print
, /* tp_print */
1235 (reprfunc
)complex_repr
, /* tp_repr */
1236 &complex_as_number
, /* tp_as_number */
1237 0, /* tp_as_sequence */
1238 0, /* tp_as_mapping */
1239 (hashfunc
)complex_hash
, /* tp_hash */
1241 (reprfunc
)complex_str
, /* tp_str */
1242 PyObject_GenericGetAttr
, /* tp_getattro */
1243 0, /* tp_setattro */
1244 0, /* tp_as_buffer */
1245 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
1246 complex_doc
, /* tp_doc */
1247 0, /* tp_traverse */
1249 complex_richcompare
, /* tp_richcompare */
1250 0, /* tp_weaklistoffset */
1252 0, /* tp_iternext */
1253 complex_methods
, /* tp_methods */
1254 complex_members
, /* tp_members */
1258 0, /* tp_descr_get */
1259 0, /* tp_descr_set */
1260 0, /* tp_dictoffset */
1262 PyType_GenericAlloc
, /* tp_alloc */
1263 complex_new
, /* tp_new */
1264 PyObject_Del
, /* tp_free */