} return NULL;} static PyObject *complex_neg(PyComplexObject *v){ Py_complex neg; neg.real = -v->cval.real; neg.imag = -v->cval.imag; return PyComplex_FromCComplex(neg);} static PyObject *complex_pos(PyComplexObject *v){ if (PyComplex_CheckExact(v)) { Py_INCREF(v); return (PyObject *)v; } else return PyComplex_FromCComplex(v->cval);} static PyObject *complex_abs(PyComplexObject *v){ double result; PyFPE_START_PROTECT("complex_abs", return 0) result = hypot(v->cval.real,v->cval.imag); PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result);} static intcomplex_nonzero(PyComplexObject *v){ return v->cval.real != 0.0 || v->cval.imag != 0.0;} static intcomplex_coerce(PyObject **pv, PyObject **pw){ Py_complex cval; cval.imag = 0.; if (PyInt_Check(*pw)) { cval.real = (double)PyInt_AsLong(*pw); *pw = PyComplex_FromCComplex(cval); Py_INCREF(*pv); return 0; } else if (PyLong_Check(*pw)) { cval.real = PyLong_AsDouble(*pw); if (cval.real == -1.0 && PyErr_Occurred()) return -1; *pw = PyComplex_FromCComplex(cval); Py_INCREF(*pv); return 0; } else if (PyFloat_Check(*pw)) { cval.real = PyFloat_AsDouble(*pw); *pw = PyComplex_FromCComplex(cval); Py_INCREF(*pv); return 0; } else if (PyComplex_Check(*pw)) { Py_INCREF(*pv); Py_INCREF(*pw); return 0; } return 1; /* Can't do it */} static PyObject *complex_richcompare(PyObject *v, PyObject *w, int op){ int c; Py_complex i, j; PyObject *res; c = PyNumber_CoerceEx(&v, &w); if (c < 0) return NULL; if (c > 0) { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } /* Make sure both arguments are complex. */ if (!(PyComplex_Check(v) && PyComplex_Check(w))) { Py_DECREF(v); Py_DECREF(w); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } i = ((PyComplexObject *)v)->cval; j = ((PyComplexObject *)w)->cval; Py_DECREF(v); Py_DECREF(w); if (op != Py_EQ && op != Py_NE) { PyErr_SetString(PyExc_TypeError, "no ordering relation is defined for complex numbers"); return NULL; } if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ)) res = Py_True; else res = Py_False; Py_INCREF(res); return res;} static PyObject *complex_int(PyObject *v){ PyErr_SetString(PyExc_TypeError, "can't convert complex to int; use int(abs(z))"); return NULL;} static PyObject *complex_long(PyObject *v){ PyErr_SetString(PyExc_TypeError, "can't convert complex to long; use long(abs(z))"); return NULL;} static PyObject *complex_float(PyObject *v){ PyErr_SetString(PyExc_TypeError, "can't convert complex to float; use abs(z)"); return NULL;} static PyObject *complex_conjugate(PyObject *self){ Py_complex c; c = ((PyComplexObject *)self)->cval; c.imag = -c.imag; return PyComplex_FromCComplex(c);} static PyObject *complex_getnewargs(PyComplexObject *v){ return Py_BuildValue("(D)", &v->cval);} static PyMethodDef complex_methods[] = { {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS}, {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS}, {NULL, NULL} /* sentinel */}; static PyMemberDef complex_members[] = { {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY, "the real part of a complex number"}, {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY, "the imaginary part of a complex number"}, {0},}; static PyObject *complex_subtype_from_string(PyTypeObject *type, PyObject *v){ const char *s, *start; char *end; double x=0.0, y=0.0, z; int got_re=0, got_im=0, done=0; int digit_or_dot; int sw_error=0; int sign; char buffer[256]; /* For errors */#ifdef Py_USING_UNICODE char s_buffer[256];#endif Py_ssize_t len; if (PyString_Check(v)) { s = PyString_AS_STRING(v); len = PyString_GET_SIZE(v); }#ifdef Py_USING_UNICODE else if (PyUnicode_Check(v)) { if (PyUnicode_GET_SIZE(v) >= (Py_ssize_t)sizeof(s_buffer)) { PyErr_SetString(PyExc_ValueError, "complex() literal too large to convert"); return NULL; } if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v), PyUnicode_GET_SIZE(v), s_buffer, NULL)) return NULL; s = s_buffer; len = strlen(s); }#endif else if (PyObject_AsCharBuffer(v, &s, &len)) { PyErr_SetString(PyExc_TypeError, "complex() arg is not a string"); return NULL; } /* position on first nonblank */ start = s; while (*s && isspace(Py_CHARMASK(*s))) s++; if (s[0] == '\0') { PyErr_SetString(PyExc_ValueError, "complex() arg is an empty string"); return NULL; } z = -1.0; sign = 1; do { switch (*s) { case '\0': if (s-start != len) { PyErr_SetString( PyExc_ValueError, "complex() arg contains a null byte"); return NULL; } if(!done) sw_error=1; break; case '-': sign = -1; /* Fallthrough */ case '+': if (done) sw_error=1; s++; if ( *s=='\0'||*s=='+'||*s=='-' || isspace(Py_CHARMASK(*s)) ) sw_error=1; break; case 'J': case 'j': if (got_im || done) { sw_error = 1; break; } if (z<0.0) { y=sign; } else{ y=sign*z; } got_im=1; s++; if (*s!='+' && *s!='-' ) done=1; break; default: if (isspace(Py_CHARMASK(*s))) { while (*s && isspace(Py_CHARMASK(*s))) s++; if (s[0] != '\0') sw_error=1; else done = 1; break; } digit_or_dot = (*s=='.' || isdigit(Py_CHARMASK(*s))); if (done||!digit_or_dot) { sw_error=1; break; } errno = 0; PyFPE_START_PROTECT("strtod", return 0) z = PyOS_ascii_strtod(s, &end) ; PyFPE_END_PROTECT(z) if (errno != 0) { PyOS_snprintf(buffer, sizeof(buffer), "float() out of range: %.150s", s); PyErr_SetString( PyExc_ValueError, buffer); return NULL; } s=end; if (*s=='J' || *s=='j') { break; } if (got_re) { sw_error=1; break; } /* accept a real part */ x=sign*z; got_re=1; if (got_im) done=1; z = -1.0; sign = 1; break; } /* end of switch */ } while (s - start < len && !sw_error); if (sw_error) { PyErr_SetString(PyExc_ValueError, "complex() arg is a malformed string"); return NULL; } return complex_subtype_from_doubles(type, x, y);} static PyObject *complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds){ PyObject *r, *i, *tmp, *f; PyNumberMethods *nbr, *nbi = NULL; Py_complex cr, ci; int own_r = 0; static PyObject *complexstr; static char *kwlist[] = {"real", "imag", 0}; r = Py_False; i = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO:complex", kwlist, &r, &i)) return NULL; /* Special-case for single argument that is already complex */ if (PyComplex_CheckExact(r) && i == NULL && type == &PyComplex_Type) { /* Note that we can't know whether it's safe to return a complex *subclass* instance as-is, hence the restriction to exact complexes here. */ Py_INCREF(r); return r; } if (PyString_Check(r) || PyUnicode_Check(r)) { if (i != NULL) { PyErr_SetString(PyExc_TypeError, "complex() can't take second arg" " if first is a string"); return NULL; } return complex_subtype_from_string(type, r); } if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) { PyErr_SetString(PyExc_TypeError, "complex() second arg can't be a string"); return NULL; } /* XXX Hack to support classes with __complex__ method */ if (complexstr == NULL) { complexstr = PyString_InternFromString("__complex__"); if (complexstr == NULL) return NULL; } f = PyObject_GetAttr(r, complexstr); if (f == NULL) PyErr_Clear(); else { PyObject *args = PyTuple_New(0); if (args == NULL) return NULL; r = PyEval_CallObject(f, args); Py_DECREF(args); Py_DECREF(f); if (r == NULL) return NULL; own_r = 1; } nbr = r->ob_type->tp_as_number; if (i != NULL) nbi = i->ob_type->tp_as_number; if (nbr == NULL || nbr->nb_float == NULL || ((i != NULL) && (nbi == NULL || nbi->nb_float == NULL))) { PyErr_SetString(PyExc_TypeError, "complex() argument must be a string or a number"); if (own_r) { Py_DECREF(r); } return NULL; } if (PyComplex_Check(r)) { /* Note that if r is of a complex subtype, we're only retaining its real & imag parts here, and the return value is (properly) of the builtin complex type. */ cr = ((PyComplexObject*)r)->cval; if (own_r) { Py_DECREF(r); } } else { tmp = PyNumber_Float(r); if (own_r) { Py_DECREF(r); } if (tmp == NULL) return NULL; if (!PyFloat_Check(tmp)) { PyErr_SetString(PyExc_TypeError, "float(r) didn't return a float"); Py_DECREF(tmp); return NULL; } cr.real = PyFloat_AsDouble(tmp); Py_DECREF(tmp); cr.imag = 0.0; } if (i == NULL) { ci.real = 0.0; ci.imag = 0.0; } else if (PyComplex_Check(i)) ci = ((PyComplexObject*)i)->cval; else { tmp = (*nbi->nb_float)(i); if (tmp == NULL) return NULL; ci.real = PyFloat_AsDouble(tmp); Py_DECREF(tmp); ci.imag = 0.; } cr.real -= ci.imag; cr.imag += ci.real; return complex_subtype_from_c_complex(type, cr);} PyDoc_STRVAR(complex_doc,"complex(real[, imag]) -> complex number\n""\n""Create a complex number from a real part and an optional imaginary part.\n""This is equivalent to (real + imag*1j) where imag defaults to 0."); static PyNumberMethods complex_as_number = { (binaryfunc)complex_add, /* nb_add */ (binaryfunc)complex_sub, /* nb_subtract */ (binaryfunc)complex_mul, /* nb_multiply */ (binaryfunc)complex_classic_div, /* nb_divide */ (binaryfunc)complex_remainder, /* nb_remainder */ (binaryfunc)complex_divmod, /* nb_divmod */ (ternaryfunc)complex_pow, /* nb_power */ (unaryfunc)complex_neg, /* nb_negative */ (unaryfunc)complex_pos, /* nb_positive */ (unaryfunc)complex_abs, /* nb_absolute */ (inquiry)complex_nonzero, /* nb_nonzero */ 0, /* nb_invert */ 0, /* nb_lshift */ 0, /* nb_rshift */ 0, /* nb_and */ 0, /* nb_xor */ 0, /* nb_or */ complex_coerce, /* nb_coerce */ complex_int, /* nb_int */ complex_long, /* nb_long */ complex_float, /* nb_float */ 0, /* nb_oct */ 0, /* nb_hex */ 0, /* nb_inplace_add */ 0, /* nb_inplace_subtract */ 0, /* nb_inplace_multiply*/ 0, /* nb_inplace_divide */ 0, /* nb_inplace_remainder */ 0, /* nb_inplace_power */ 0, /* nb_inplace_lshift */ 0, /* nb_inplace_rshift */ 0, /* nb_inplace_and */ 0, /* nb_inplace_xor */ 0, /* nb_inplace_or */ (binaryfunc)complex_int_div, /* nb_floor_divide */ (binaryfunc)complex_div, /* nb_true_divide */ 0, /* nb_inplace_floor_divide */ 0, /* nb_inplace_true_divide */}; PyTypeObject PyComplex_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, "complex", sizeof(PyComplexObject), 0, complex_dealloc, /* tp_dealloc */ (printfunc)complex_print, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc)complex_repr, /* tp_repr */ &complex_as_number, /* tp_as_number */Lines 501–1000 of 1031. Previous lines Load more
} return NULL; } static PyObject * complex_neg(PyComplexObject *v) { Py_complex neg; neg.real = -v->cval.real; neg.imag = -v->cval.imag; return PyComplex_FromCComplex(neg); } static PyObject * complex_pos(PyComplexObject *v) { if (PyComplex_CheckExact(v)) { Py_INCREF(v); return (PyObject *)v; } else return PyComplex_FromCComplex(v->cval); } static PyObject * complex_abs(PyComplexObject *v) { double result; PyFPE_START_PROTECT("complex_abs", return 0) result = hypot(v->cval.real,v->cval.imag); PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } static int complex_nonzero(PyComplexObject *v) { return v->cval.real != 0.0 || v->cval.imag != 0.0; } static int complex_coerce(PyObject **pv, PyObject **pw) { Py_complex cval; cval.imag = 0.; if (PyInt_Check(*pw)) { cval.real = (double)PyInt_AsLong(*pw); *pw = PyComplex_FromCComplex(cval); Py_INCREF(*pv); return 0; } else if (PyLong_Check(*pw)) { cval.real = PyLong_AsDouble(*pw); if (cval.real == -1.0 && PyErr_Occurred()) return -1; *pw = PyComplex_FromCComplex(cval); Py_INCREF(*pv); return 0; } else if (PyFloat_Check(*pw)) { cval.real = PyFloat_AsDouble(*pw); *pw = PyComplex_FromCComplex(cval); Py_INCREF(*pv); return 0; } else if (PyComplex_Check(*pw)) { Py_INCREF(*pv); Py_INCREF(*pw); return 0; } return 1; /* Can't do it */ } static PyObject * complex_richcompare(PyObject *v, PyObject *w, int op) { int c; Py_complex i, j; PyObject *res; c = PyNumber_CoerceEx(&v, &w); if (c < 0) return NULL; if (c > 0) { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } /* Make sure both arguments are complex. */ if (!(PyComplex_Check(v) && PyComplex_Check(w))) { Py_DECREF(v); Py_DECREF(w); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } i = ((PyComplexObject *)v)->cval; j = ((PyComplexObject *)w)->cval; Py_DECREF(v); Py_DECREF(w); if (op != Py_EQ && op != Py_NE) { PyErr_SetString(PyExc_TypeError, "no ordering relation is defined for complex numbers"); return NULL; } if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ)) res = Py_True; else res = Py_False; Py_INCREF(res); return res; } static PyObject * complex_int(PyObject *v) { PyErr_SetString(PyExc_TypeError, "can't convert complex to int; use int(abs(z))"); return NULL; } static PyObject * complex_long(PyObject *v) { PyErr_SetString(PyExc_TypeError, "can't convert complex to long; use long(abs(z))"); return NULL; } static PyObject * complex_float(PyObject *v) { PyErr_SetString(PyExc_TypeError, "can't convert complex to float; use abs(z)"); return NULL; } static PyObject * complex_conjugate(PyObject *self) { Py_complex c; c = ((PyComplexObject *)self)->cval; c.imag = -c.imag; return PyComplex_FromCComplex(c); } static PyObject * complex_getnewargs(PyComplexObject *v) { return Py_BuildValue("(D)", &v->cval); } static PyMethodDef complex_methods[] = { {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS}, {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS}, {NULL, NULL} /* sentinel */ }; static PyMemberDef complex_members[] = { {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY, "the real part of a complex number"}, {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY, "the imaginary part of a complex number"}, {0}, }; static PyObject * complex_subtype_from_string(PyTypeObject *type, PyObject *v) { const char *s, *start; char *end; double x=0.0, y=0.0, z; int got_re=0, got_im=0, done=0; int digit_or_dot; int sw_error=0; int sign; char buffer[256]; /* For errors */ #ifdef Py_USING_UNICODE char s_buffer[256]; #endif Py_ssize_t len; if (PyString_Check(v)) { s = PyString_AS_STRING(v); len = PyString_GET_SIZE(v); } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(v)) { if (PyUnicode_GET_SIZE(v) >= (Py_ssize_t)sizeof(s_buffer)) { PyErr_SetString(PyExc_ValueError, "complex() literal too large to convert"); return NULL; } if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v), PyUnicode_GET_SIZE(v), s_buffer, NULL)) return NULL; s = s_buffer; len = strlen(s); } #endif else if (PyObject_AsCharBuffer(v, &s, &len)) { PyErr_SetString(PyExc_TypeError, "complex() arg is not a string"); return NULL; } /* position on first nonblank */ start = s; while (*s && isspace(Py_CHARMASK(*s))) s++; if (s[0] == '\0') { PyErr_SetString(PyExc_ValueError, "complex() arg is an empty string"); return NULL; } z = -1.0; sign = 1; do { switch (*s) { case '\0': if (s-start != len) { PyErr_SetString( PyExc_ValueError, "complex() arg contains a null byte"); return NULL; } if(!done) sw_error=1; break; case '-': sign = -1; /* Fallthrough */ case '+': if (done) sw_error=1; s++; if ( *s=='\0'||*s=='+'||*s=='-' || isspace(Py_CHARMASK(*s)) ) sw_error=1; break; case 'J': case 'j': if (got_im || done) { sw_error = 1; break; } if (z<0.0) { y=sign; } else{ y=sign*z; } got_im=1; s++; if (*s!='+' && *s!='-' ) done=1; break; default: if (isspace(Py_CHARMASK(*s))) { while (*s && isspace(Py_CHARMASK(*s))) s++; if (s[0] != '\0') sw_error=1; else done = 1; break; } digit_or_dot = (*s=='.' || isdigit(Py_CHARMASK(*s))); if (done||!digit_or_dot) { sw_error=1; break; } errno = 0; PyFPE_START_PROTECT("strtod", return 0) z = PyOS_ascii_strtod(s, &end) ; PyFPE_END_PROTECT(z) if (errno != 0) { PyOS_snprintf(buffer, sizeof(buffer), "float() out of range: %.150s", s); PyErr_SetString( PyExc_ValueError, buffer); return NULL; } s=end; if (*s=='J' || *s=='j') { break; } if (got_re) { sw_error=1; break; } /* accept a real part */ x=sign*z; got_re=1; if (got_im) done=1; z = -1.0; sign = 1; break; } /* end of switch */ } while (s - start < len && !sw_error); if (sw_error) { PyErr_SetString(PyExc_ValueError, "complex() arg is a malformed string"); return NULL; } return complex_subtype_from_doubles(type, x, y); } static PyObject * complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *r, *i, *tmp, *f; PyNumberMethods *nbr, *nbi = NULL; Py_complex cr, ci; int own_r = 0; static PyObject *complexstr; static char *kwlist[] = {"real", "imag", 0}; r = Py_False; i = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO:complex", kwlist, &r, &i)) return NULL; /* Special-case for single argument that is already complex */ if (PyComplex_CheckExact(r) && i == NULL && type == &PyComplex_Type) { /* Note that we can't know whether it's safe to return a complex *subclass* instance as-is, hence the restriction to exact complexes here. */ Py_INCREF(r); return r; } if (PyString_Check(r) || PyUnicode_Check(r)) { if (i != NULL) { PyErr_SetString(PyExc_TypeError, "complex() can't take second arg" " if first is a string"); return NULL; } return complex_subtype_from_string(type, r); } if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) { PyErr_SetString(PyExc_TypeError, "complex() second arg can't be a string"); return NULL; } /* XXX Hack to support classes with __complex__ method */ if (complexstr == NULL) { complexstr = PyString_InternFromString("__complex__"); if (complexstr == NULL) return NULL; } f = PyObject_GetAttr(r, complexstr); if (f == NULL) PyErr_Clear(); else { PyObject *args = PyTuple_New(0); if (args == NULL) return NULL; r = PyEval_CallObject(f, args); Py_DECREF(args); Py_DECREF(f); if (r == NULL) return NULL; own_r = 1; } nbr = r->ob_type->tp_as_number; if (i != NULL) nbi = i->ob_type->tp_as_number; if (nbr == NULL || nbr->nb_float == NULL || ((i != NULL) && (nbi == NULL || nbi->nb_float == NULL))) { PyErr_SetString(PyExc_TypeError, "complex() argument must be a string or a number"); if (own_r) { Py_DECREF(r); } return NULL; } if (PyComplex_Check(r)) { /* Note that if r is of a complex subtype, we're only retaining its real & imag parts here, and the return value is (properly) of the builtin complex type. */ cr = ((PyComplexObject*)r)->cval; if (own_r) { Py_DECREF(r); } } else { tmp = PyNumber_Float(r); if (own_r) { Py_DECREF(r); } if (tmp == NULL) return NULL; if (!PyFloat_Check(tmp)) { PyErr_SetString(PyExc_TypeError, "float(r) didn't return a float"); Py_DECREF(tmp); return NULL; } cr.real = PyFloat_AsDouble(tmp); Py_DECREF(tmp); cr.imag = 0.0; } if (i == NULL) { ci.real = 0.0; ci.imag = 0.0; } else if (PyComplex_Check(i)) ci = ((PyComplexObject*)i)->cval; else { tmp = (*nbi->nb_float)(i); if (tmp == NULL) return NULL; ci.real = PyFloat_AsDouble(tmp); Py_DECREF(tmp); ci.imag = 0.; } cr.real -= ci.imag; cr.imag += ci.real; return complex_subtype_from_c_complex(type, cr); } PyDoc_STRVAR(complex_doc, "complex(real[, imag]) -> complex number\n" "\n" "Create a complex number from a real part and an optional imaginary part.\n" "This is equivalent to (real + imag*1j) where imag defaults to 0."); static PyNumberMethods complex_as_number = { (binaryfunc)complex_add, /* nb_add */ (binaryfunc)complex_sub, /* nb_subtract */ (binaryfunc)complex_mul, /* nb_multiply */ (binaryfunc)complex_classic_div, /* nb_divide */ (binaryfunc)complex_remainder, /* nb_remainder */ (binaryfunc)complex_divmod, /* nb_divmod */ (ternaryfunc)complex_pow, /* nb_power */ (unaryfunc)complex_neg, /* nb_negative */ (unaryfunc)complex_pos, /* nb_positive */ (unaryfunc)complex_abs, /* nb_absolute */ (inquiry)complex_nonzero, /* nb_nonzero */ 0, /* nb_invert */ 0, /* nb_lshift */ 0, /* nb_rshift */ 0, /* nb_and */ 0, /* nb_xor */ 0, /* nb_or */ complex_coerce, /* nb_coerce */ complex_int, /* nb_int */ complex_long, /* nb_long */ complex_float, /* nb_float */ 0, /* nb_oct */ 0, /* nb_hex */ 0, /* nb_inplace_add */ 0, /* nb_inplace_subtract */ 0, /* nb_inplace_multiply*/ 0, /* nb_inplace_divide */ 0, /* nb_inplace_remainder */ 0, /* nb_inplace_power */ 0, /* nb_inplace_lshift */ 0, /* nb_inplace_rshift */ 0, /* nb_inplace_and */ 0, /* nb_inplace_xor */ 0, /* nb_inplace_or */ (binaryfunc)complex_int_div, /* nb_floor_divide */ (binaryfunc)complex_div, /* nb_true_divide */ 0, /* nb_inplace_floor_divide */ 0, /* nb_inplace_true_divide */ }; PyTypeObject PyComplex_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, "complex", sizeof(PyComplexObject), 0, complex_dealloc, /* tp_dealloc */ (printfunc)complex_print, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc)complex_repr, /* tp_repr */ &complex_as_number, /* tp_as_number */