Objects/complexobject.c

   1
   2 /* Complex object implementation */
   3
   4 /* Borrows heavily from floatobject.c */
   5
   6 /* Submitted by Jim Hugunin */
   7
   8 #ifndef WITHOUT_COMPLEX
   9
  10 #include "Python.h"
  11 #include "structmember.h"
  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
  31 static Py_complex c_1 = {1., 0.};
  32
  33 Py_complex
  34 c_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
  42 Py_complex
  43 c_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
  51 Py_complex
  52 c_neg(Py_complex a)
  53 {
  54         Py_complex r;
  55         r.real = -a.real;
  56         r.imag = -a.imag;
  57         return r;
  58 }
  59
  60 Py_complex
  61 c_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
  69 Py_complex
  70 c_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
 123 Py_complex
 124 c_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 = ERANGE;
 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
 153 static Py_complex
 154 c_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
 169 static Py_complex
 170 c_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
 186 static PyObject *
 187 complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)
 188 {
 189         PyObject *op;
 190
 191         op = PyType_GenericAlloc(type, 0);
 192         if (op != NULL)
 193                 ((PyComplexObject *)op)->cval = cval;
 194         return op;
 195 }
 196
 197 PyObject *
 198 PyComplex_FromCComplex(Py_complex cval)
 199 {
 200         register PyComplexObject *op;
 201
 202         /* PyObject_New is inlined */
 203         op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
 204         if (op == NULL)
 205                 return PyErr_NoMemory();
 206         PyObject_INIT(op, &PyComplex_Type);
 207         op->cval = cval;
 208         return (PyObject *) op;
 209 }
 210
 211 static PyObject *
 212 complex_subtype_from_doubles(PyTypeObject *type, double real, double imag)
 213 {
 214         Py_complex c;
 215         c.real = real;
 216         c.imag = imag;
 217         return complex_subtype_from_c_complex(type, c);
 218 }
 219
 220 PyObject *
 221 PyComplex_FromDoubles(double real, double imag)
 222 {
 223         Py_complex c;
 224         c.real = real;
 225         c.imag = imag;
 226         return PyComplex_FromCComplex(c);
 227 }
 228
 229 double
 230 PyComplex_RealAsDouble(PyObject *op)
 231 {
 232         if (PyComplex_Check(op)) {
 233                 return ((PyComplexObject *)op)->cval.real;
 234         }
 235         else {
 236                 return PyFloat_AsDouble(op);
 237         }
 238 }
 239
 240 double
 241 PyComplex_ImagAsDouble(PyObject *op)
 242 {
 243         if (PyComplex_Check(op)) {
 244                 return ((PyComplexObject *)op)->cval.imag;
 245         }
 246         else {
 247                 return 0.0;
 248         }
 249 }
 250
 251 Py_complex
 252 PyComplex_AsCComplex(PyObject *op)
 253 {
 254         Py_complex cv;
 255         if (PyComplex_Check(op)) {
 256                 return ((PyComplexObject *)op)->cval;
 257         }
 258         else {
 259                 cv.real = PyFloat_AsDouble(op);
 260                 cv.imag = 0.;
 261                 return cv;
 262         }
 263 }
 264
 265 static void
 266 complex_dealloc(PyObject *op)
 267 {
 268         op->ob_type->tp_free(op);
 269 }
 270
 271
 272 static void
 273 complex_to_buf(char *buf, int bufsz, PyComplexObject *v, int precision)
 274 {
 275         if (v->cval.real == 0.)
 276                 PyOS_snprintf(buf, bufsz, "%.*gj",
 277                               precision, v->cval.imag);
 278         else
 279                 PyOS_snprintf(buf, bufsz, "(%.*g%+.*gj)",
 280                               precision, v->cval.real,
 281                               precision, v->cval.imag);
 282 }
 283
 284 static int
 285 complex_print(PyComplexObject *v, FILE *fp, int flags)
 286 {
 287         char buf[100];
 288         complex_to_buf(buf, sizeof(buf), v,
 289                        (flags & Py_PRINT_RAW) ? PREC_STR : PREC_REPR);
 290         fputs(buf, fp);
 291         return 0;
 292 }
 293
 294 static PyObject *
 295 complex_repr(PyComplexObject *v)
 296 {
 297         char buf[100];
 298         complex_to_buf(buf, sizeof(buf), v, PREC_REPR);
 299         return PyString_FromString(buf);
 300 }
 301
 302 static PyObject *
 303 complex_str(PyComplexObject *v)
 304 {
 305         char buf[100];
 306         complex_to_buf(buf, sizeof(buf), v, PREC_STR);
 307         return PyString_FromString(buf);
 308 }
 309
 310 static long
 311 complex_hash(PyComplexObject *v)
 312 {
 313         long hashreal, hashimag, combined;
 314         hashreal = _Py_HashDouble(v->cval.real);
 315         if (hashreal == -1)
 316                 return -1;
 317         hashimag = _Py_HashDouble(v->cval.imag);
 318         if (hashimag == -1)
 319                 return -1;
 320         /* Note:  if the imaginary part is 0, hashimag is 0 now,
 321          * so the following returns hashreal unchanged.  This is
 322          * important because numbers of different types that
 323          * compare equal must have the same hash value, so that
 324          * hash(x + 0*j) must equal hash(x).
 325          */
 326         combined = hashreal + 1000003 * hashimag;
 327         if (combined == -1)
 328                 combined = -2;
 329         return combined;
 330 }
 331
 332 static PyObject *
 333 complex_add(PyComplexObject *v, PyComplexObject *w)
 334 {
 335         Py_complex result;
 336         PyFPE_START_PROTECT("complex_add", return 0)
 337         result = c_sum(v->cval,w->cval);
 338         PyFPE_END_PROTECT(result)
 339         return PyComplex_FromCComplex(result);
 340 }
 341
 342 static PyObject *
 343 complex_sub(PyComplexObject *v, PyComplexObject *w)
 344 {
 345         Py_complex result;
 346         PyFPE_START_PROTECT("complex_sub", return 0)
 347         result = c_diff(v->cval,w->cval);
 348         PyFPE_END_PROTECT(result)
 349         return PyComplex_FromCComplex(result);
 350 }
 351
 352 static PyObject *
 353 complex_mul(PyComplexObject *v, PyComplexObject *w)
 354 {
 355         Py_complex result;
 356         PyFPE_START_PROTECT("complex_mul", return 0)
 357         result = c_prod(v->cval,w->cval);
 358         PyFPE_END_PROTECT(result)
 359         return PyComplex_FromCComplex(result);
 360 }
 361
 362 static PyObject *
 363 complex_div(PyComplexObject *v, PyComplexObject *w)
 364 {
 365         Py_complex quot;
 366         PyFPE_START_PROTECT("complex_div", return 0)
 367         errno = 0;
 368         quot = c_quot(v->cval,w->cval);
 369         PyFPE_END_PROTECT(quot)
 370         if (errno == EDOM) {
 371                 PyErr_SetString(PyExc_ZeroDivisionError, "complex division");
 372                 return NULL;
 373         }
 374         return PyComplex_FromCComplex(quot);
 375 }
 376
 377 static PyObject *
 378 complex_classic_div(PyComplexObject *v, PyComplexObject *w)
 379 {
 380         Py_complex quot;
 381
 382         if (Py_DivisionWarningFlag >= 2 &&
 383             PyErr_Warn(PyExc_DeprecationWarning,
 384                        "classic complex division") < 0)
 385                 return NULL;
 386
 387         PyFPE_START_PROTECT("complex_classic_div", return 0)
 388         errno = 0;
 389         quot = c_quot(v->cval,w->cval);
 390         PyFPE_END_PROTECT(quot)
 391         if (errno == EDOM) {
 392                 PyErr_SetString(PyExc_ZeroDivisionError, "complex division");
 393                 return NULL;
 394         }
 395         return PyComplex_FromCComplex(quot);
 396 }
 397
 398 static PyObject *
 399 complex_remainder(PyComplexObject *v, PyComplexObject *w)
 400 {
 401         Py_complex div, mod;
 402         errno = 0;
 403         div = c_quot(v->cval,w->cval); /* The raw divisor value. */
 404         if (errno == EDOM) {
 405                 PyErr_SetString(PyExc_ZeroDivisionError, "complex remainder");
 406                 return NULL;
 407         }
 408         div.real = floor(div.real); /* Use the floor of the real part. */
 409         div.imag = 0.0;
 410         mod = c_diff(v->cval, c_prod(w->cval, div));
 411
 412         return PyComplex_FromCComplex(mod);
 413 }
 414
 415
 416 static PyObject *
 417 complex_divmod(PyComplexObject *v, PyComplexObject *w)
 418 {
 419         Py_complex div, mod;
 420         PyObject *d, *m, *z;
 421         errno = 0;
 422         div = c_quot(v->cval,w->cval); /* The raw divisor value. */
 423         if (errno == EDOM) {
 424                 PyErr_SetString(PyExc_ZeroDivisionError, "complex divmod()");
 425                 return NULL;
 426         }
 427         div.real = floor(div.real); /* Use the floor of the real part. */
 428         div.imag = 0.0;
 429         mod = c_diff(v->cval, c_prod(w->cval, div));
 430         d = PyComplex_FromCComplex(div);
 431         m = PyComplex_FromCComplex(mod);
 432         z = Py_BuildValue("(OO)", d, m);
 433         Py_XDECREF(d);
 434         Py_XDECREF(m);
 435         return z;
 436 }
 437
 438 static PyObject *
 439 complex_pow(PyComplexObject *v, PyObject *w, PyComplexObject *z)
 440 {
 441         Py_complex p;
 442         Py_complex exponent;
 443         long int_exponent;
 444
 445         if ((PyObject *)z!=Py_None) {
 446                 PyErr_SetString(PyExc_ValueError, "complex modulo");
 447                 return NULL;
 448         }
 449         PyFPE_START_PROTECT("complex_pow", return 0)
 450         errno = 0;
 451         exponent = ((PyComplexObject*)w)->cval;
 452         int_exponent = (long)exponent.real;
 453         if (exponent.imag == 0. && exponent.real == int_exponent)
 454                 p = c_powi(v->cval,int_exponent);
 455         else
 456                 p = c_pow(v->cval,exponent);
 457
 458         PyFPE_END_PROTECT(p)
 459         if (errno == ERANGE) {
 460                 PyErr_SetString(PyExc_ValueError,
 461                                 "0.0 to a negative or complex power");
 462                 return NULL;
 463         }
 464         return PyComplex_FromCComplex(p);
 465 }
 466
 467 static PyObject *
 468 complex_int_div(PyComplexObject *v, PyComplexObject *w)
 469 {
 470         PyObject *t, *r;
 471
 472         t = complex_divmod(v, w);
 473         if (t != NULL) {
 474                 r = PyTuple_GET_ITEM(t, 0);
 475                 Py_INCREF(r);
 476                 Py_DECREF(t);
 477                 return r;
 478         }
 479         return NULL;
 480 }
 481
 482 static PyObject *
 483 complex_neg(PyComplexObject *v)
 484 {
 485         Py_complex neg;
 486         neg.real = -v->cval.real;
 487         neg.imag = -v->cval.imag;
 488         return PyComplex_FromCComplex(neg);
 489 }
 490
 491 static PyObject *
 492 complex_pos(PyComplexObject *v)
 493 {
 494         if (PyComplex_CheckExact(v)) {
 495                 Py_INCREF(v);
 496                 return (PyObject *)v;
 497         }
 498         else
 499                 return PyComplex_FromCComplex(v->cval);
 500 }
 501
 502 static PyObject *
 503 complex_abs(PyComplexObject *v)
 504 {
 505         double result;
 506         PyFPE_START_PROTECT("complex_abs", return 0)
 507         result = hypot(v->cval.real,v->cval.imag);
 508         PyFPE_END_PROTECT(result)
 509         return PyFloat_FromDouble(result);
 510 }
 511
 512 static int
 513 complex_nonzero(PyComplexObject *v)
 514 {
 515         return v->cval.real != 0.0 || v->cval.imag != 0.0;
 516 }
 517
 518 static int
 519 complex_coerce(PyObject **pv, PyObject **pw)
 520 {
 521         Py_complex cval;
 522         cval.imag = 0.;
 523         if (PyInt_Check(*pw)) {
 524                 cval.real = (double)PyInt_AsLong(*pw);
 525                 *pw = PyComplex_FromCComplex(cval);
 526                 Py_INCREF(*pv);
 527                 return 0;
 528         }
 529         else if (PyLong_Check(*pw)) {
 530                 cval.real = PyLong_AsDouble(*pw);
 531                 if (cval.real == -1.0 && PyErr_Occurred())
 532                         return -1;
 533                 *pw = PyComplex_FromCComplex(cval);
 534                 Py_INCREF(*pv);
 535                 return 0;
 536         }
 537         else if (PyFloat_Check(*pw)) {
 538                 cval.real = PyFloat_AsDouble(*pw);
 539                 *pw = PyComplex_FromCComplex(cval);
 540                 Py_INCREF(*pv);
 541                 return 0;
 542         }
 543         else if (PyComplex_Check(*pw)) {
 544                 Py_INCREF(*pv);
 545                 Py_INCREF(*pw);
 546                 return 0;
 547         }
 548         return 1; /* Can't do it */
 549 }
 550
 551 static PyObject *
 552 complex_richcompare(PyObject *v, PyObject *w, int op)
 553 {
 554         int c;
 555         Py_complex i, j;
 556         PyObject *res;
 557
 558         c = PyNumber_CoerceEx(&v, &w);
 559         if (c < 0)
 560                 return NULL;
 561         if (c > 0) {
 562                 Py_INCREF(Py_NotImplemented);
 563                 return Py_NotImplemented;
 564         }
 565         /* Make sure both arguments are complex. */
 566         if (!(PyComplex_Check(v) && PyComplex_Check(w))) {
 567                 Py_DECREF(v);
 568                 Py_DECREF(w);
 569                 Py_INCREF(Py_NotImplemented);
 570                 return Py_NotImplemented;
 571         }
 572
 573         i = ((PyComplexObject *)v)->cval;
 574         j = ((PyComplexObject *)w)->cval;
 575         Py_DECREF(v);
 576         Py_DECREF(w);
 577
 578         if (op != Py_EQ && op != Py_NE) {
 579                 PyErr_SetString(PyExc_TypeError,
 580                         "cannot compare complex numbers using <, <=, >, >=");
 581                 return NULL;
 582         }
 583
 584         if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ))
 585                 res = Py_True;
 586         else
 587                 res = Py_False;
 588
 589         Py_INCREF(res);
 590         return res;
 591 }
 592
 593 static PyObject *
 594 complex_int(PyObject *v)
 595 {
 596         PyErr_SetString(PyExc_TypeError,
 597                    "can't convert complex to int; use e.g. int(abs(z))");
 598         return NULL;
 599 }
 600
 601 static PyObject *
 602 complex_long(PyObject *v)
 603 {
 604         PyErr_SetString(PyExc_TypeError,
 605                    "can't convert complex to long; use e.g. long(abs(z))");
 606         return NULL;
 607 }
 608
 609 static PyObject *
 610 complex_float(PyObject *v)
 611 {
 612         PyErr_SetString(PyExc_TypeError,
 613                    "can't convert complex to float; use e.g. abs(z)");
 614         return NULL;
 615 }
 616
 617 static PyObject *
 618 complex_conjugate(PyObject *self)
 619 {
 620         Py_complex c;
 621         c = ((PyComplexObject *)self)->cval;
 622         c.imag = -c.imag;
 623         return PyComplex_FromCComplex(c);
 624 }
 625
 626 static PyMethodDef complex_methods[] = {
 627         {"conjugate",   (PyCFunction)complex_conjugate, METH_NOARGS},
 628         {NULL,          NULL}           /* sentinel */
 629 };
 630
 631 static PyMemberDef complex_members[] = {
 632         {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), 0,
 633          "the real part of a complex number"},
 634         {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), 0,
 635          "the imaginary part of a complex number"},
 636         {0},
 637 };
 638
 639 static PyObject *
 640 complex_subtype_from_string(PyTypeObject *type, PyObject *v)
 641 {
 642         extern double strtod(const char *, char **);
 643         const char *s, *start;
 644         char *end;
 645         double x=0.0, y=0.0, z;
 646         int got_re=0, got_im=0, done=0;
 647         int digit_or_dot;
 648         int sw_error=0;
 649         int sign;
 650         char buffer[256]; /* For errors */
 651 #ifdef Py_USING_UNICODE
 652         char s_buffer[256];
 653 #endif
 654         int len;
 655
 656         if (PyString_Check(v)) {
 657                 s = PyString_AS_STRING(v);
 658                 len = PyString_GET_SIZE(v);
 659         }
 660 #ifdef Py_USING_UNICODE
 661         else if (PyUnicode_Check(v)) {
 662                 if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) {
 663                         PyErr_SetString(PyExc_ValueError,
 664                                  "complex() literal too large to convert");
 665                         return NULL;
 666                 }
 667                 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v),
 668                                             PyUnicode_GET_SIZE(v),
 669                                             s_buffer,
 670                                             NULL))
 671                         return NULL;
 672                 s = s_buffer;
 673                 len = (int)strlen(s);
 674         }
 675 #endif
 676         else if (PyObject_AsCharBuffer(v, &s, &len)) {
 677                 PyErr_SetString(PyExc_TypeError,
 678                                 "complex() arg is not a string");
 679                 return NULL;
 680         }
 681
 682         /* position on first nonblank */
 683         start = s;
 684         while (*s && isspace(Py_CHARMASK(*s)))
 685                 s++;
 686         if (s[0] == '\0') {
 687                 PyErr_SetString(PyExc_ValueError,
 688                                 "complex() arg is an empty string");
 689                 return NULL;
 690         }
 691
 692         z = -1.0;
 693         sign = 1;
 694         do {
 695
 696                 switch (*s) {
 697
 698                 case '\0':
 699                         if (s-start != len) {
 700                                 PyErr_SetString(
 701                                         PyExc_ValueError,
 702                                         "complex() arg contains a null byte");
 703                                 return NULL;
 704                         }
 705                         if(!done) sw_error=1;
 706                         break;
 707
 708                 case '-':
 709                         sign = -1;
 710                                 /* Fallthrough */
 711                 case '+':
 712                         if (done)  sw_error=1;
 713                         s++;
 714                         if  (  *s=='\0'||*s=='+'||*s=='-'  ||
 715                                isspace(Py_CHARMASK(*s))  )  sw_error=1;
 716                         break;
 717
 718                 case 'J':
 719                 case 'j':
 720                         if (got_im || done) {
 721                                 sw_error = 1;
 722                                 break;
 723                         }
 724                         if  (z<0.0) {
 725                                 y=sign;
 726                         }
 727                         else{
 728                                 y=sign*z;
 729                         }
 730                         got_im=1;
 731                         s++;
 732                         if  (*s!='+' && *s!='-' )
 733                                 done=1;
 734                         break;
 735
 736                 default:
 737                         if (isspace(Py_CHARMASK(*s))) {
 738                                 while (*s && isspace(Py_CHARMASK(*s)))
 739                                         s++;
 740                                 if (s[0] != '\0')
 741                                         sw_error=1;
 742                                 else
 743                                         done = 1;
 744                                 break;
 745                         }
 746                         digit_or_dot =
 747                                 (*s=='.' || isdigit(Py_CHARMASK(*s)));
 748                         if  (done||!digit_or_dot) {
 749                                 sw_error=1;
 750                                 break;
 751                         }
 752                         errno = 0;
 753                         PyFPE_START_PROTECT("strtod", return 0)
 754                                 z = strtod(s, &end) ;
 755                         PyFPE_END_PROTECT(z)
 756                                 if (errno != 0) {
 757                                         PyOS_snprintf(buffer, sizeof(buffer),
 758                                           "float() out of range: %.150s", s);
 759                                         PyErr_SetString(
 760                                                 PyExc_ValueError,
 761                                                 buffer);
 762                                         return NULL;
 763                                 }
 764                         s=end;
 765                         if  (*s=='J' || *s=='j') {
 766
 767                                 break;
 768                         }
 769                         if  (got_re) {
 770                                 sw_error=1;
 771                                 break;
 772                         }
 773
 774                                 /* accept a real part */
 775                         x=sign*z;
 776                         got_re=1;
 777                         if  (got_im)  done=1;
 778                         z = -1.0;
 779                         sign = 1;
 780                         break;
 781
 782                 }  /* end of switch  */
 783
 784         } while (*s!='\0' && !sw_error);
 785
 786         if (sw_error) {
 787                 PyErr_SetString(PyExc_ValueError,
 788                                 "complex() arg is a malformed string");
 789                 return NULL;
 790         }
 791
 792         return complex_subtype_from_doubles(type, x, y);
 793 }
 794
 795 static PyObject *
 796 complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 797 {
 798         PyObject *r, *i, *tmp;
 799         PyNumberMethods *nbr, *nbi = NULL;
 800         Py_complex cr, ci;
 801         int own_r = 0;
 802         static char *kwlist[] = {"real", "imag", 0};
 803
 804         r = Py_False;
 805         i = NULL;
 806         if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO:complex", kwlist,
 807                                          &r, &i))
 808                 return NULL;
 809         if (PyString_Check(r) || PyUnicode_Check(r)) {
 810                 if (i != NULL) {
 811                         PyErr_SetString(PyExc_TypeError,
 812                                         "complex() can't take second arg"
 813                                         " if first is a string");
 814                         return NULL;
 815                 }
 816                 return complex_subtype_from_string(type, r);
 817         }
 818         if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) {
 819                 PyErr_SetString(PyExc_TypeError,
 820                                 "complex() second arg can't be a string");
 821                 return NULL;
 822         }
 823
 824         nbr = r->ob_type->tp_as_number;
 825         if (i != NULL)
 826                 nbi = i->ob_type->tp_as_number;
 827         if (nbr == NULL || nbr->nb_float == NULL ||
 828             ((i != NULL) && (nbi == NULL || nbi->nb_float == NULL))) {
 829                 PyErr_SetString(PyExc_TypeError,
 830                            "complex() arg can't be converted to complex");
 831                 return NULL;
 832         }
 833         /* XXX Hack to support classes with __complex__ method */
 834         if (PyInstance_Check(r)) {
 835                 static PyObject *complexstr;
 836                 PyObject *f;
 837                 if (complexstr == NULL) {
 838                         complexstr = PyString_InternFromString("__complex__");
 839                         if (complexstr == NULL)
 840                                 return NULL;
 841                 }
 842                 f = PyObject_GetAttr(r, complexstr);
 843                 if (f == NULL)
 844                         PyErr_Clear();
 845                 else {
 846                         PyObject *args = Py_BuildValue("()");
 847                         if (args == NULL)
 848                                 return NULL;
 849                         r = PyEval_CallObject(f, args);
 850                         Py_DECREF(args);
 851                         Py_DECREF(f);
 852                         if (r == NULL)
 853                                 return NULL;
 854                         own_r = 1;
 855                 }
 856         }
 857         if (PyComplex_Check(r)) {
 858                 /* Note that if r is of a complex subtype, we're only
 859                    retaining its real & imag parts here, and the return
 860                    value is (properly) of the builtin complex type. */
 861                 cr = ((PyComplexObject*)r)->cval;
 862                 if (own_r) {
 863                         Py_DECREF(r);
 864                 }
 865         }
 866         else {
 867                 tmp = PyNumber_Float(r);
 868                 if (own_r) {
 869                         Py_DECREF(r);
 870                 }
 871                 if (tmp == NULL)
 872                         return NULL;
 873                 if (!PyFloat_Check(tmp)) {
 874                         PyErr_SetString(PyExc_TypeError,
 875                                         "float(r) didn't return a float");
 876                         Py_DECREF(tmp);
 877                         return NULL;
 878                 }
 879                 cr.real = PyFloat_AsDouble(tmp);
 880                 Py_DECREF(tmp);
 881                 cr.imag = 0.0;
 882         }
 883         if (i == NULL) {
 884                 ci.real = 0.0;
 885                 ci.imag = 0.0;
 886         }
 887         else if (PyComplex_Check(i))
 888                 ci = ((PyComplexObject*)i)->cval;
 889         else {
 890                 tmp = (*nbi->nb_float)(i);
 891                 if (tmp == NULL)
 892                         return NULL;
 893                 ci.real = PyFloat_AsDouble(tmp);
 894                 Py_DECREF(tmp);
 895                 ci.imag = 0.;
 896         }
 897         cr.real -= ci.imag;
 898         cr.imag += ci.real;
 899         return complex_subtype_from_c_complex(type, cr);
 900 }
 901
 902 static char complex_doc[] =
 903 "complex(real[, imag]) -> complex number\n"
 904 "\n"
 905 "Create a complex number from a real part and an optional imaginary part.\n"
 906 "This is equivalent to (real + imag*1j) where imag defaults to 0.";
 907
 908 static PyNumberMethods complex_as_number = {
 909         (binaryfunc)complex_add,                /* nb_add */
 910         (binaryfunc)complex_sub,                /* nb_subtract */
 911         (binaryfunc)complex_mul,                /* nb_multiply */
 912         (binaryfunc)complex_classic_div,        /* nb_divide */
 913         (binaryfunc)complex_remainder,          /* nb_remainder */
 914         (binaryfunc)complex_divmod,             /* nb_divmod */
 915         (ternaryfunc)complex_pow,               /* nb_power */
 916         (unaryfunc)complex_neg,                 /* nb_negative */
 917         (unaryfunc)complex_pos,                 /* nb_positive */
 918         (unaryfunc)complex_abs,                 /* nb_absolute */
 919         (inquiry)complex_nonzero,               /* nb_nonzero */
 920         0,                                      /* nb_invert */
 921         0,                                      /* nb_lshift */
 922         0,                                      /* nb_rshift */
 923         0,                                      /* nb_and */
 924         0,                                      /* nb_xor */
 925         0,                                      /* nb_or */
 926         (coercion)complex_coerce,               /* nb_coerce */
 927         (unaryfunc)complex_int,                 /* nb_int */
 928         (unaryfunc)complex_long,                /* nb_long */
 929         (unaryfunc)complex_float,               /* nb_float */
 930         0,                                      /* nb_oct */
 931         0,                                      /* nb_hex */
 932         0,                                      /* nb_inplace_add */
 933         0,                                      /* nb_inplace_subtract */
 934         0,                                      /* nb_inplace_multiply*/
 935         0,                                      /* nb_inplace_divide */
 936         0,                                      /* nb_inplace_remainder */
 937         0,                                      /* nb_inplace_power */
 938         0,                                      /* nb_inplace_lshift */
 939         0,                                      /* nb_inplace_rshift */
 940         0,                                      /* nb_inplace_and */
 941         0,                                      /* nb_inplace_xor */
 942         0,                                      /* nb_inplace_or */
 943         (binaryfunc)complex_int_div,            /* nb_floor_divide */
 944         (binaryfunc)complex_div,                /* nb_true_divide */
 945         0,                                      /* nb_inplace_floor_divide */
 946         0,                                      /* nb_inplace_true_divide */
 947 };
 948
 949 PyTypeObject PyComplex_Type = {
 950         PyObject_HEAD_INIT(&PyType_Type)
 951         0,
 952         "complex",
 953         sizeof(PyComplexObject),
 954         0,
 955         (destructor)complex_dealloc,            /* tp_dealloc */
 956         (printfunc)complex_print,               /* tp_print */
 957         0,                                      /* tp_getattr */
 958         0,                                      /* tp_setattr */
 959         0,                                      /* tp_compare */
 960         (reprfunc)complex_repr,                 /* tp_repr */
 961         &complex_as_number,                     /* tp_as_number */
 962         0,                                      /* tp_as_sequence */
 963         0,                                      /* tp_as_mapping */
 964         (hashfunc)complex_hash,                 /* tp_hash */
 965         0,                                      /* tp_call */
 966         (reprfunc)complex_str,                  /* tp_str */
 967         PyObject_GenericGetAttr,                /* tp_getattro */
 968         0,                                      /* tp_setattro */
 969         0,                                      /* tp_as_buffer */
 970         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 971         complex_doc,                            /* tp_doc */
 972         0,                                      /* tp_traverse */
 973         0,                                      /* tp_clear */
 974         complex_richcompare,                    /* tp_richcompare */
 975         0,                                      /* tp_weaklistoffset */
 976         0,                                      /* tp_iter */
 977         0,                                      /* tp_iternext */
 978         complex_methods,                        /* tp_methods */
 979         complex_members,                        /* tp_members */
 980         0,                                      /* tp_getset */
 981         0,                                      /* tp_base */
 982         0,                                      /* tp_dict */
 983         0,                                      /* tp_descr_get */
 984         0,                                      /* tp_descr_set */
 985         0,                                      /* tp_dictoffset */
 986         0,                                      /* tp_init */
 987         0,                                      /* tp_alloc */
 988         complex_new,                            /* tp_new */
 989         _PyObject_Del,                          /* tp_free */
 990 };
 991
 992 #endif