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
);
841 PyDoc_STRVAR(complex__format__doc
,
842 "complex.__format__() -> str\n"
844 "Converts to a string according to format_spec.");
847 complex__format__(PyObject
* self
, PyObject
* args
)
849 PyObject
*format_spec
;
851 if (!PyArg_ParseTuple(args
, "O:__format__", &format_spec
))
853 if (PyBytes_Check(format_spec
))
854 return _PyComplex_FormatAdvanced(self
,
855 PyBytes_AS_STRING(format_spec
),
856 PyBytes_GET_SIZE(format_spec
));
857 if (PyUnicode_Check(format_spec
)) {
858 /* Convert format_spec to a str */
860 PyObject
*str_spec
= PyObject_Str(format_spec
);
862 if (str_spec
== NULL
)
865 result
= _PyComplex_FormatAdvanced(self
,
866 PyBytes_AS_STRING(str_spec
),
867 PyBytes_GET_SIZE(str_spec
));
872 PyErr_SetString(PyExc_TypeError
, "__format__ requires str or unicode");
878 complex_is_finite(PyObject
*self
)
881 c
= ((PyComplexObject
*)self
)->cval
;
882 return PyBool_FromLong((long)(Py_IS_FINITE(c
.real
) &&
883 Py_IS_FINITE(c
.imag
)));
886 PyDoc_STRVAR(complex_is_finite_doc
,
887 "complex.is_finite() -> bool\n"
889 "Returns True if the real and the imaginary part is finite.");
892 static PyMethodDef complex_methods
[] = {
893 {"conjugate", (PyCFunction
)complex_conjugate
, METH_NOARGS
,
894 complex_conjugate_doc
},
896 {"is_finite", (PyCFunction
)complex_is_finite
, METH_NOARGS
,
897 complex_is_finite_doc
},
899 {"__getnewargs__", (PyCFunction
)complex_getnewargs
, METH_NOARGS
},
900 {"__format__", (PyCFunction
)complex__format__
,
901 METH_VARARGS
, complex__format__doc
},
902 {NULL
, NULL
} /* sentinel */
905 static PyMemberDef complex_members
[] = {
906 {"real", T_DOUBLE
, offsetof(PyComplexObject
, cval
.real
), READONLY
,
907 "the real part of a complex number"},
908 {"imag", T_DOUBLE
, offsetof(PyComplexObject
, cval
.imag
), READONLY
,
909 "the imaginary part of a complex number"},
914 complex_subtype_from_string(PyTypeObject
*type
, PyObject
*v
)
916 const char *s
, *start
;
918 double x
=0.0, y
=0.0, z
;
920 #ifdef Py_USING_UNICODE
925 if (PyString_Check(v
)) {
926 s
= PyString_AS_STRING(v
);
927 len
= PyString_GET_SIZE(v
);
929 #ifdef Py_USING_UNICODE
930 else if (PyUnicode_Check(v
)) {
931 if (PyUnicode_GET_SIZE(v
) >= (Py_ssize_t
)sizeof(s_buffer
)) {
932 PyErr_SetString(PyExc_ValueError
,
933 "complex() literal too large to convert");
936 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v
),
937 PyUnicode_GET_SIZE(v
),
945 else if (PyObject_AsCharBuffer(v
, &s
, &len
)) {
946 PyErr_SetString(PyExc_TypeError
,
947 "complex() arg is not a string");
951 /* position on first nonblank */
953 while (*s
&& isspace(Py_CHARMASK(*s
)))
956 /* Skip over possible bracket from repr(). */
959 while (*s
&& isspace(Py_CHARMASK(*s
)))
963 /* a valid complex string usually takes one of the three forms:
965 <float> - real part only
966 <float>j - imaginary part only
967 <float><signed-float>j - real and imaginary parts
969 where <float> represents any numeric string that's accepted by the
970 float constructor (including 'nan', 'inf', 'infinity', etc.), and
971 <signed-float> is any string of the form <float> whose first
972 character is '+' or '-'.
974 For backwards compatibility, the extra forms
980 are also accepted, though support for these forms may be removed from
981 a future version of Python.
984 /* first look for forms starting with <float> */
986 z
= PyOS_ascii_strtod(s
, &end
);
987 if (end
== s
&& errno
== ENOMEM
)
988 return PyErr_NoMemory();
989 if (errno
== ERANGE
&& fabs(z
) >= 1.0)
993 /* all 4 forms starting with <float> land here */
995 if (*s
== '+' || *s
== '-') {
996 /* <float><signed-float>j | <float><sign>j */
999 y
= PyOS_ascii_strtod(s
, &end
);
1000 if (end
== s
&& errno
== ENOMEM
)
1001 return PyErr_NoMemory();
1002 if (errno
== ERANGE
&& fabs(y
) >= 1.0)
1005 /* <float><signed-float>j */
1008 /* <float><sign>j */
1009 y
= *s
== '+' ? 1.0 : -1.0;
1012 if (!(*s
== 'j' || *s
== 'J'))
1016 else if (*s
== 'j' || *s
== 'J') {
1026 /* not starting with <float>; must be <sign>j or j */
1027 if (*s
== '+' || *s
== '-') {
1029 y
= *s
== '+' ? 1.0 : -1.0;
1035 if (!(*s
== 'j' || *s
== 'J'))
1040 /* trailing whitespace and closing bracket */
1041 while (*s
&& isspace(Py_CHARMASK(*s
)))
1044 /* if there was an opening parenthesis, then the corresponding
1045 closing parenthesis should be right here */
1049 while (*s
&& isspace(Py_CHARMASK(*s
)))
1053 /* we should now be at the end of the string */
1057 return complex_subtype_from_doubles(type
, x
, y
);
1060 PyErr_SetString(PyExc_ValueError
,
1061 "complex() arg is a malformed string");
1065 PyErr_SetString(PyExc_OverflowError
,
1066 "complex() arg overflow");
1071 complex_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1073 PyObject
*r
, *i
, *tmp
, *f
;
1074 PyNumberMethods
*nbr
, *nbi
= NULL
;
1077 int cr_is_complex
= 0;
1078 int ci_is_complex
= 0;
1079 static PyObject
*complexstr
;
1080 static char *kwlist
[] = {"real", "imag", 0};
1084 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "|OO:complex", kwlist
,
1088 /* Special-case for a single argument when type(arg) is complex. */
1089 if (PyComplex_CheckExact(r
) && i
== NULL
&&
1090 type
== &PyComplex_Type
) {
1091 /* Note that we can't know whether it's safe to return
1092 a complex *subclass* instance as-is, hence the restriction
1093 to exact complexes here. If either the input or the
1094 output is a complex subclass, it will be handled below
1095 as a non-orthogonal vector. */
1099 if (PyString_Check(r
) || PyUnicode_Check(r
)) {
1101 PyErr_SetString(PyExc_TypeError
,
1102 "complex() can't take second arg"
1103 " if first is a string");
1106 return complex_subtype_from_string(type
, r
);
1108 if (i
!= NULL
&& (PyString_Check(i
) || PyUnicode_Check(i
))) {
1109 PyErr_SetString(PyExc_TypeError
,
1110 "complex() second arg can't be a string");
1114 /* XXX Hack to support classes with __complex__ method */
1115 if (complexstr
== NULL
) {
1116 complexstr
= PyString_InternFromString("__complex__");
1117 if (complexstr
== NULL
)
1120 f
= PyObject_GetAttr(r
, complexstr
);
1124 PyObject
*args
= PyTuple_New(0);
1127 r
= PyEval_CallObject(f
, args
);
1134 nbr
= r
->ob_type
->tp_as_number
;
1136 nbi
= i
->ob_type
->tp_as_number
;
1137 if (nbr
== NULL
|| nbr
->nb_float
== NULL
||
1138 ((i
!= NULL
) && (nbi
== NULL
|| nbi
->nb_float
== NULL
))) {
1139 PyErr_SetString(PyExc_TypeError
,
1140 "complex() argument must be a string or a number");
1147 /* If we get this far, then the "real" and "imag" parts should
1148 both be treated as numbers, and the constructor should return a
1149 complex number equal to (real + imag*1j).
1151 Note that we do NOT assume the input to already be in canonical
1152 form; the "real" and "imag" parts might themselves be complex
1153 numbers, which slightly complicates the code below. */
1154 if (PyComplex_Check(r
)) {
1155 /* Note that if r is of a complex subtype, we're only
1156 retaining its real & imag parts here, and the return
1157 value is (properly) of the builtin complex type. */
1158 cr
= ((PyComplexObject
*)r
)->cval
;
1165 /* The "real" part really is entirely real, and contributes
1166 nothing in the imaginary direction.
1167 Just treat it as a double. */
1168 tmp
= PyNumber_Float(r
);
1170 /* r was a newly created complex number, rather
1171 than the original "real" argument. */
1176 if (!PyFloat_Check(tmp
)) {
1177 PyErr_SetString(PyExc_TypeError
,
1178 "float(r) didn't return a float");
1182 cr
.real
= PyFloat_AsDouble(tmp
);
1183 cr
.imag
= 0.0; /* Shut up compiler warning */
1189 else if (PyComplex_Check(i
)) {
1190 ci
= ((PyComplexObject
*)i
)->cval
;
1193 /* The "imag" part really is entirely imaginary, and
1194 contributes nothing in the real direction.
1195 Just treat it as a double. */
1196 tmp
= (*nbi
->nb_float
)(i
);
1199 ci
.real
= PyFloat_AsDouble(tmp
);
1202 /* If the input was in canonical form, then the "real" and "imag"
1203 parts are real numbers, so that ci.imag and cr.imag are zero.
1204 We need this correction in case they were not real numbers. */
1206 if (ci_is_complex
) {
1209 if (cr_is_complex
) {
1212 return complex_subtype_from_doubles(type
, cr
.real
, ci
.real
);
1215 PyDoc_STRVAR(complex_doc
,
1216 "complex(real[, imag]) -> complex number\n"
1218 "Create a complex number from a real part and an optional imaginary part.\n"
1219 "This is equivalent to (real + imag*1j) where imag defaults to 0.");
1221 static PyNumberMethods complex_as_number
= {
1222 (binaryfunc
)complex_add
, /* nb_add */
1223 (binaryfunc
)complex_sub
, /* nb_subtract */
1224 (binaryfunc
)complex_mul
, /* nb_multiply */
1225 (binaryfunc
)complex_classic_div
, /* nb_divide */
1226 (binaryfunc
)complex_remainder
, /* nb_remainder */
1227 (binaryfunc
)complex_divmod
, /* nb_divmod */
1228 (ternaryfunc
)complex_pow
, /* nb_power */
1229 (unaryfunc
)complex_neg
, /* nb_negative */
1230 (unaryfunc
)complex_pos
, /* nb_positive */
1231 (unaryfunc
)complex_abs
, /* nb_absolute */
1232 (inquiry
)complex_nonzero
, /* nb_nonzero */
1239 complex_coerce
, /* nb_coerce */
1240 complex_int
, /* nb_int */
1241 complex_long
, /* nb_long */
1242 complex_float
, /* nb_float */
1245 0, /* nb_inplace_add */
1246 0, /* nb_inplace_subtract */
1247 0, /* nb_inplace_multiply*/
1248 0, /* nb_inplace_divide */
1249 0, /* nb_inplace_remainder */
1250 0, /* nb_inplace_power */
1251 0, /* nb_inplace_lshift */
1252 0, /* nb_inplace_rshift */
1253 0, /* nb_inplace_and */
1254 0, /* nb_inplace_xor */
1255 0, /* nb_inplace_or */
1256 (binaryfunc
)complex_int_div
, /* nb_floor_divide */
1257 (binaryfunc
)complex_div
, /* nb_true_divide */
1258 0, /* nb_inplace_floor_divide */
1259 0, /* nb_inplace_true_divide */
1262 PyTypeObject PyComplex_Type
= {
1263 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
1265 sizeof(PyComplexObject
),
1267 complex_dealloc
, /* tp_dealloc */
1268 (printfunc
)complex_print
, /* tp_print */
1272 (reprfunc
)complex_repr
, /* tp_repr */
1273 &complex_as_number
, /* tp_as_number */
1274 0, /* tp_as_sequence */
1275 0, /* tp_as_mapping */
1276 (hashfunc
)complex_hash
, /* tp_hash */
1278 (reprfunc
)complex_str
, /* tp_str */
1279 PyObject_GenericGetAttr
, /* tp_getattro */
1280 0, /* tp_setattro */
1281 0, /* tp_as_buffer */
1282 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
1283 complex_doc
, /* tp_doc */
1284 0, /* tp_traverse */
1286 complex_richcompare
, /* tp_richcompare */
1287 0, /* tp_weaklistoffset */
1289 0, /* tp_iternext */
1290 complex_methods
, /* tp_methods */
1291 complex_members
, /* tp_members */
1295 0, /* tp_descr_get */
1296 0, /* tp_descr_set */
1297 0, /* tp_dictoffset */
1299 PyType_GenericAlloc
, /* tp_alloc */
1300 complex_new
, /* tp_new */
1301 PyObject_Del
, /* tp_free */