1 2 /* Complex object implementation */ 3 4 /* Borrows heavily from floatobject.c */ 5 6 /* Submitted by Jim Hugunin */ 7 8 #include "Python.h" 9 #include "structmember.h" 10 11 /* elementary operations on complex numbers */ 12 13 static Py_complex c_1 = {1., 0.}; 14 15 Py_complex 16 _Py_c_sum(Py_complex a, Py_complex b) 17 { 18 Py_complex r; 19 r.real = a.real + b.real; 20 r.imag = a.imag + b.imag; 21 return r; 22 } 23 24 Py_complex 25 _Py_c_diff(Py_complex a, Py_complex b) 26 { 27 Py_complex r; 28 r.real = a.real - b.real; 29 r.imag = a.imag - b.imag; 30 return r; 31 } 32 33 Py_complex 34 _Py_c_neg(Py_complex a) 35 { 36 Py_complex r; 37 r.real = -a.real; 38 r.imag = -a.imag; 39 return r; 40 } 41 42 Py_complex 43 _Py_c_prod(Py_complex a, Py_complex b) 44 { 45 Py_complex r; 46 r.real = a.real*b.real - a.imag*b.imag; 47 r.imag = a.real*b.imag + a.imag*b.real; 48 return r; 49 } 50 51 Py_complex 52 _Py_c_quot(Py_complex a, Py_complex b) 53 { 54 /****************************************************************** 55 This was the original algorithm. It's grossly prone to spurious 56 overflow and underflow errors. It also merrily divides by 0 despite 57 checking for that(!). The code still serves a doc purpose here, as 58 the algorithm following is a simple by-cases transformation of this 59 one: 60 61 Py_complex r; 62 double d = b.real*b.real + b.imag*b.imag; 63 if (d == 0.) 64 errno = EDOM; 65 r.real = (a.real*b.real + a.imag*b.imag)/d; 66 r.imag = (a.imag*b.real - a.real*b.imag)/d; 67 return r; 68 ******************************************************************/ 69 70 /* This algorithm is better, and is pretty obvious: first divide the 71 * numerators and denominator by whichever of {b.real, b.imag} has 72 * larger magnitude. The earliest reference I found was to CACM 73 * Algorithm 116 (Complex Division, Robert L. Smith, Stanford 74 * University). As usual, though, we're still ignoring all IEEE 75 * endcases. 76 */ 77 Py_complex r; /* the result */ 78 const double abs_breal = b.real < 0 ? -b.real : b.real; 79 const double abs_bimag = b.imag < 0 ? -b.imag : b.imag; 80 81 if (abs_breal >= abs_bimag) { 82 /* divide tops and bottom by b.real */ 83 if (abs_breal == 0.0) { 84 errno = EDOM; 85 r.real = r.imag = 0.0; 86 } 87 else { 88 const double ratio = b.imag / b.real; 89 const double denom = b.real + b.imag * ratio; 90 r.real = (a.real + a.imag * ratio) / denom; 91 r.imag = (a.imag - a.real * ratio) / denom; 92 } 93 } 94 else if (abs_bimag >= abs_breal) { 95 /* divide tops and bottom by b.imag */ 96 const double ratio = b.real / b.imag; 97 const double denom = b.real * ratio + b.imag; 98 assert(b.imag != 0.0); 99 r.real = (a.real * ratio + a.imag) / denom; 100 r.imag = (a.imag * ratio - a.real) / denom; 101 } 102 else { 103 /* At least one of b.real or b.imag is a NaN */ 104 r.real = r.imag = Py_NAN; 105 } 106 return r; 107 } 108 109 Py_complex 110 _Py_c_pow(Py_complex a, Py_complex b) 111 { 112 Py_complex r; 113 double vabs,len,at,phase; 114 if (b.real == 0. && b.imag == 0.) { 115 r.real = 1.; 116 r.imag = 0.; 117 } 118 else if (a.real == 0. && a.imag == 0.) { 119 if (b.imag != 0. || b.real < 0.) 120 errno = EDOM; 121 r.real = 0.; 122 r.imag = 0.; 123 } 124 else { 125 vabs = hypot(a.real,a.imag); 126 len = pow(vabs,b.real); 127 at = atan2(a.imag, a.real); 128 phase = at*b.real; 129 if (b.imag != 0.0) { 130 len /= exp(at*b.imag); 131 phase += b.imag*log(vabs); 132 } 133 r.real = len*cos(phase); 134 r.imag = len*sin(phase); 135 } 136 return r; 137 } 138 139 static Py_complex 140 c_powu(Py_complex x, long n) 141 { 142 Py_complex r, p; 143 long mask = 1; 144 r = c_1; 145 p = x; 146 while (mask > 0 && n >= mask) { 147 if (n & mask) 148 r = _Py_c_prod(r,p); 149 mask <<= 1; 150 p = _Py_c_prod(p,p); 151 } 152 return r; 153 } 154 155 static Py_complex 156 c_powi(Py_complex x, long n) 157 { 158 Py_complex cn; 159 160 if (n > 100 || n < -100) { 161 cn.real = (double) n; 162 cn.imag = 0.; 163 return _Py_c_pow(x,cn); 164 } 165 else if (n > 0) 166 return c_powu(x,n); 167 else 168 return _Py_c_quot(c_1, c_powu(x,-n)); 169 170 } 171 172 double 173 _Py_c_abs(Py_complex z) 174 { 175 /* sets errno = ERANGE on overflow; otherwise errno = 0 */ 176 double result; 177 178 if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) { 179 /* C99 rules: if either the real or the imaginary part is an 180 infinity, return infinity, even if the other part is a 181 NaN. */ 182 if (Py_IS_INFINITY(z.real)) { 183 result = fabs(z.real); 184 errno = 0; 185 return result; 186 } 187 if (Py_IS_INFINITY(z.imag)) { 188 result = fabs(z.imag); 189 errno = 0; 190 return result; 191 } 192 /* either the real or imaginary part is a NaN, 193 and neither is infinite. Result should be NaN. */ 194 return Py_NAN; 195 } 196 result = hypot(z.real, z.imag); 197 if (!Py_IS_FINITE(result)) 198 errno = ERANGE; 199 else 200 errno = 0; 201 return result; 202 } 203 204 static PyObject * 205 complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval) 206 { 207 PyObject *op; 208 209 op = type->tp_alloc(type, 0); 210 if (op != NULL) 211 ((PyComplexObject *)op)->cval = cval; 212 return op; 213 } 214 215 PyObject * 216 PyComplex_FromCComplex(Py_complex cval) 217 { 218 PyComplexObject *op; 219 220 /* Inline PyObject_New */ 221 op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject)); 222 if (op == NULL) 223 return PyErr_NoMemory(); 224 (void)PyObject_INIT(op, &PyComplex_Type); 225 op->cval = cval; 226 return (PyObject *) op; 227 } 228 229 static PyObject * 230 complex_subtype_from_doubles(PyTypeObject *type, double real, double imag) 231 { 232 Py_complex c; 233 c.real = real; 234 c.imag = imag; 235 return complex_subtype_from_c_complex(type, c); 236 } 237 238 PyObject * 239 PyComplex_FromDoubles(double real, double imag) 240 { 241 Py_complex c; 242 c.real = real; 243 c.imag = imag; 244 return PyComplex_FromCComplex(c); 245 } 246 247 double 248 PyComplex_RealAsDouble(PyObject *op) 249 { 250 if (PyComplex_Check(op)) { 251 return ((PyComplexObject *)op)->cval.real; 252 } 253 else { 254 return PyFloat_AsDouble(op); 255 } 256 } 257 258 double 259 PyComplex_ImagAsDouble(PyObject *op) 260 { 261 if (PyComplex_Check(op)) { 262 return ((PyComplexObject *)op)->cval.imag; 263 } 264 else { 265 return 0.0; 266 } 267 } 268 269 static PyObject * 270 try_complex_special_method(PyObject *op) { 271 PyObject *f; 272 _Py_IDENTIFIER(__complex__); 273 274 f = _PyObject_LookupSpecial(op, &PyId___complex__); 275 if (f) { 276 PyObject *res = PyObject_CallFunctionObjArgs(f, NULL); 277 Py_DECREF(f); 278 if (res != NULL && !PyComplex_Check(res)) { 279 PyErr_SetString(PyExc_TypeError, 280 "__complex__ should return a complex object"); 281 Py_DECREF(res); 282 return NULL; 283 } 284 return res; 285 } 286 return NULL; 287 } 288 289 Py_complex 290 PyComplex_AsCComplex(PyObject *op) 291 { 292 Py_complex cv; 293 PyObject *newop = NULL; 294 295 assert(op); 296 /* If op is already of type PyComplex_Type, return its value */ 297 if (PyComplex_Check(op)) { 298 return ((PyComplexObject *)op)->cval; 299 } 300 /* If not, use op's __complex__ method, if it exists */ 301 302 /* return -1 on failure */ 303 cv.real = -1.; 304 cv.imag = 0.; 305 306 newop = try_complex_special_method(op); 307 308 if (newop) { 309 cv = ((PyComplexObject *)newop)->cval; 310 Py_DECREF(newop); 311 return cv; 312 } 313 else if (PyErr_Occurred()) { 314 return cv; 315 } 316 /* If neither of the above works, interpret op as a float giving the 317 real part of the result, and fill in the imaginary part as 0. */ 318 else { 319 /* PyFloat_AsDouble will return -1 on failure */ 320 cv.real = PyFloat_AsDouble(op); 321 return cv; 322 } 323 } 324 325 static void 326 complex_dealloc(PyObject *op) 327 { 328 op->ob_type->tp_free(op); 329 } 330 331 static PyObject * 332 complex_repr(PyComplexObject *v) 333 { 334 int precision = 0; 335 char format_code = 'r'; 336 PyObject *result = NULL; 337 338 /* If these are non-NULL, they'll need to be freed. */ 339 char *pre = NULL; 340 char *im = NULL; 341 342 /* These do not need to be freed. re is either an alias 343 for pre or a pointer to a constant. lead and tail 344 are pointers to constants. */ 345 char *re = NULL; 346 char *lead = ""; 347 char *tail = ""; 348 349 if (v->cval.real == 0. && copysign(1.0, v->cval.real)==1.0) { 350 /* Real part is +0: just output the imaginary part and do not 351 include parens. */ 352 re = ""; 353 im = PyOS_double_to_string(v->cval.imag, format_code, 354 precision, 0, NULL); 355 if (!im) { 356 PyErr_NoMemory(); 357 goto done; 358 } 359 } else { 360 /* Format imaginary part with sign, real part without. Include 361 parens in the result. */ 362 pre = PyOS_double_to_string(v->cval.real, format_code, 363 precision, 0, NULL); 364 if (!pre) { 365 PyErr_NoMemory(); 366 goto done; 367 } 368 re = pre; 369 370 im = PyOS_double_to_string(v->cval.imag, format_code, 371 precision, Py_DTSF_SIGN, NULL); 372 if (!im) { 373 PyErr_NoMemory(); 374 goto done; 375 } 376 lead = "("; 377 tail = ")"; 378 } 379 result = PyUnicode_FromFormat("%s%s%sj%s", lead, re, im, tail); 380 done: 381 PyMem_Free(im); 382 PyMem_Free(pre); 383 384 return result; 385 } 386 387 static Py_hash_t 388 complex_hash(PyComplexObject *v) 389 { 390 Py_uhash_t hashreal, hashimag, combined; 391 hashreal = (Py_uhash_t)_Py_HashDouble(v->cval.real); 392 if (hashreal == (Py_uhash_t)-1) 393 return -1; 394 hashimag = (Py_uhash_t)_Py_HashDouble(v->cval.imag); 395 if (hashimag == (Py_uhash_t)-1) 396 return -1; 397 /* Note: if the imaginary part is 0, hashimag is 0 now, 398 * so the following returns hashreal unchanged. This is 399 * important because numbers of different types that 400 * compare equal must have the same hash value, so that 401 * hash(x + 0*j) must equal hash(x). 402 */ 403 combined = hashreal + _PyHASH_IMAG * hashimag; 404 if (combined == (Py_uhash_t)-1) 405 combined = (Py_uhash_t)-2; 406 return (Py_hash_t)combined; 407 } 408 409 /* This macro may return! */ 410 #define TO_COMPLEX(obj, c) \ 411 if (PyComplex_Check(obj)) \ 412 c = ((PyComplexObject *)(obj))->cval; \ 413 else if (to_complex(&(obj), &(c)) < 0) \ 414 return (obj) 415 416 static int 417 to_complex(PyObject **pobj, Py_complex *pc) 418 { 419 PyObject *obj = *pobj; 420 421 pc->real = pc->imag = 0.0; 422 if (PyLong_Check(obj)) { 423 pc->real = PyLong_AsDouble(obj); 424 if (pc->real == -1.0 && PyErr_Occurred()) { 425 *pobj = NULL; 426 return -1; 427 } 428 return 0; 429 } 430 if (PyFloat_Check(obj)) { 431 pc->real = PyFloat_AsDouble(obj); 432 return 0; 433 } 434 Py_INCREF(Py_NotImplemented); 435 *pobj = Py_NotImplemented; 436 return -1; 437 } 438 439 440 static PyObject * 441 complex_add(PyObject *v, PyObject *w) 442 { 443 Py_complex result; 444 Py_complex a, b; 445 TO_COMPLEX(v, a); 446 TO_COMPLEX(w, b); 447 PyFPE_START_PROTECT("complex_add", return 0) 448 result = _Py_c_sum(a, b); 449 PyFPE_END_PROTECT(result) 450 return PyComplex_FromCComplex(result); 451 } 452 453 static PyObject * 454 complex_sub(PyObject *v, PyObject *w) 455 { 456 Py_complex result; 457 Py_complex a, b; 458 TO_COMPLEX(v, a); 459 TO_COMPLEX(w, b); 460 PyFPE_START_PROTECT("complex_sub", return 0) 461 result = _Py_c_diff(a, b); 462 PyFPE_END_PROTECT(result) 463 return PyComplex_FromCComplex(result); 464 } 465 466 static PyObject * 467 complex_mul(PyObject *v, PyObject *w) 468 { 469 Py_complex result; 470 Py_complex a, b; 471 TO_COMPLEX(v, a); 472 TO_COMPLEX(w, b); 473 PyFPE_START_PROTECT("complex_mul", return 0) 474 result = _Py_c_prod(a, b); 475 PyFPE_END_PROTECT(result) 476 return PyComplex_FromCComplex(result); 477 } 478 479 static PyObject * 480 complex_div(PyObject *v, PyObject *w) 481 { 482 Py_complex quot; 483 Py_complex a, b; 484 TO_COMPLEX(v, a); 485 TO_COMPLEX(w, b); 486 PyFPE_START_PROTECT("complex_div", return 0) 487 errno = 0; 488 quot = _Py_c_quot(a, b); 489 PyFPE_END_PROTECT(quot) 490 if (errno == EDOM) { 491 PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero"); 492 return NULL; 493 } 494 return PyComplex_FromCComplex(quot); 495 } 496 497 static PyObject * 498 complex_remainder(PyObject *v, PyObject *w) 499 { 500 PyErr_SetString(PyExc_TypeError, 501 "can't mod complex numbers."); 502 return NULL; 503 } 504 505 506 static PyObject * 507 complex_divmod(PyObject *v, PyObject *w) 508 { 509 PyErr_SetString(PyExc_TypeError, 510 "can't take floor or mod of complex number."); 511 return NULL; 512 } 513 514 static PyObject * 515 complex_pow(PyObject *v, PyObject *w, PyObject *z) 516 { 517 Py_complex p; 518 Py_complex exponent; 519 long int_exponent; 520 Py_complex a, b; 521 TO_COMPLEX(v, a); 522 TO_COMPLEX(w, b); 523 524 if (z != Py_None) { 525 PyErr_SetString(PyExc_ValueError, "complex modulo"); 526 return NULL; 527 } 528 PyFPE_START_PROTECT("complex_pow", return 0) 529 errno = 0; 530 exponent = b; 531 int_exponent = (long)exponent.real; 532 if (exponent.imag == 0. && exponent.real == int_exponent) 533 p = c_powi(a, int_exponent); 534 else 535 p = _Py_c_pow(a, exponent); 536 537 PyFPE_END_PROTECT(p) 538 Py_ADJUST_ERANGE2(p.real, p.imag); 539 if (errno == EDOM) { 540 PyErr_SetString(PyExc_ZeroDivisionError, 541 "0.0 to a negative or complex power"); 542 return NULL; 543 } 544 else if (errno == ERANGE) { 545 PyErr_SetString(PyExc_OverflowError, 546 "complex exponentiation"); 547 return NULL; 548 } 549 return PyComplex_FromCComplex(p); 550 } 551 552 static PyObject * 553 complex_int_div(PyObject *v, PyObject *w) 554 { 555 PyErr_SetString(PyExc_TypeError, 556 "can't take floor of complex number."); 557 return NULL; 558 } 559 560 static PyObject * 561 complex_neg(PyComplexObject *v) 562 { 563 Py_complex neg; 564 neg.real = -v->cval.real; 565 neg.imag = -v->cval.imag; 566 return PyComplex_FromCComplex(neg); 567 } 568 569 static PyObject * 570 complex_pos(PyComplexObject *v) 571 { 572 if (PyComplex_CheckExact(v)) { 573 Py_INCREF(v); 574 return (PyObject *)v; 575 } 576 else 577 return PyComplex_FromCComplex(v->cval); 578 } 579 580 static PyObject * 581 complex_abs(PyComplexObject *v) 582 { 583 double result; 584 585 PyFPE_START_PROTECT("complex_abs", return 0) 586 result = _Py_c_abs(v->cval); 587 PyFPE_END_PROTECT(result) 588 589 if (errno == ERANGE) { 590 PyErr_SetString(PyExc_OverflowError, 591 "absolute value too large"); 592 return NULL; 593 } 594 return PyFloat_FromDouble(result); 595 } 596 597 static int 598 complex_bool(PyComplexObject *v) 599 { 600 return v->cval.real != 0.0 || v->cval.imag != 0.0; 601 } 602 603 static PyObject * 604 complex_richcompare(PyObject *v, PyObject *w, int op) 605 { 606 PyObject *res; 607 Py_complex i; 608 int equal; 609 610 if (op != Py_EQ && op != Py_NE) { 611 goto Unimplemented; 612 } 613 614 assert(PyComplex_Check(v)); 615 TO_COMPLEX(v, i); 616 617 if (PyLong_Check(w)) { 618 /* Check for 0.0 imaginary part first to avoid the rich 619 * comparison when possible. 620 */ 621 if (i.imag == 0.0) { 622 PyObject *j, *sub_res; 623 j = PyFloat_FromDouble(i.real); 624 if (j == NULL) 625 return NULL; 626 627 sub_res = PyObject_RichCompare(j, w, op); 628 Py_DECREF(j); 629 return sub_res; 630 } 631 else { 632 equal = 0; 633 } 634 } 635 else if (PyFloat_Check(w)) { 636 equal = (i.real == PyFloat_AsDouble(w) && i.imag == 0.0); 637 } 638 else if (PyComplex_Check(w)) { 639 Py_complex j; 640 641 TO_COMPLEX(w, j); 642 equal = (i.real == j.real && i.imag == j.imag); 643 } 644 else { 645 goto Unimplemented; 646 } 647 648 if (equal == (op == Py_EQ)) 649 res = Py_True; 650 else 651 res = Py_False; 652 653 Py_INCREF(res); 654 return res; 655 656 Unimplemented: 657 Py_RETURN_NOTIMPLEMENTED; 658 } 659 660 static PyObject * 661 complex_int(PyObject *v) 662 { 663 PyErr_SetString(PyExc_TypeError, 664 "can't convert complex to int"); 665 return NULL; 666 } 667 668 static PyObject * 669 complex_float(PyObject *v) 670 { 671 PyErr_SetString(PyExc_TypeError, 672 "can't convert complex to float"); 673 return NULL; 674 } 675 676 static PyObject * 677 complex_conjugate(PyObject *self) 678 { 679 Py_complex c; 680 c = ((PyComplexObject *)self)->cval; 681 c.imag = -c.imag; 682 return PyComplex_FromCComplex(c); 683 } 684 685 PyDoc_STRVAR(complex_conjugate_doc, 686 "complex.conjugate() -> complex\n" 687 "\n" 688 "Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j."); 689 690 static PyObject * 691 complex_getnewargs(PyComplexObject *v) 692 { 693 Py_complex c = v->cval; 694 return Py_BuildValue("(dd)", c.real, c.imag); 695 } 696 697 PyDoc_STRVAR(complex__format__doc, 698 "complex.__format__() -> str\n" 699 "\n" 700 "Convert to a string according to format_spec."); 701 702 static PyObject * 703 complex__format__(PyObject* self, PyObject* args) 704 { 705 PyObject *format_spec; 706 _PyUnicodeWriter writer; 707 int ret; 708 709 if (!PyArg_ParseTuple(args, "U:__format__", &format_spec)) 710 return NULL; 711 712 _PyUnicodeWriter_Init(&writer); 713 ret = _PyComplex_FormatAdvancedWriter( 714 &writer, 715 self, 716 format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); 717 if (ret == -1) { 718 _PyUnicodeWriter_Dealloc(&writer); 719 return NULL; 720 } 721 return _PyUnicodeWriter_Finish(&writer); 722 } 723 724 #if 0 725 static PyObject * 726 complex_is_finite(PyObject *self) 727 { 728 Py_complex c; 729 c = ((PyComplexObject *)self)->cval; 730 return PyBool_FromLong((long)(Py_IS_FINITE(c.real) && 731 Py_IS_FINITE(c.imag))); 732 } 733 734 PyDoc_STRVAR(complex_is_finite_doc, 735 "complex.is_finite() -> bool\n" 736 "\n" 737 "Returns True if the real and the imaginary part is finite."); 738 #endif 739 740 static PyMethodDef complex_methods[] = { 741 {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS, 742 complex_conjugate_doc}, 743 #if 0 744 {"is_finite", (PyCFunction)complex_is_finite, METH_NOARGS, 745 complex_is_finite_doc}, 746 #endif 747 {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS}, 748 {"__format__", (PyCFunction)complex__format__, 749 METH_VARARGS, complex__format__doc}, 750 {NULL, NULL} /* sentinel */ 751 }; 752 753 static PyMemberDef complex_members[] = { 754 {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY, 755 "the real part of a complex number"}, 756 {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY, 757 "the imaginary part of a complex number"}, 758 {0}, 759 }; 760 761 static PyObject * 762 complex_from_string_inner(const char *s, Py_ssize_t len, void *type) 763 { 764 double x=0.0, y=0.0, z; 765 int got_bracket=0; 766 const char *start; 767 char *end; 768 769 /* position on first nonblank */ 770 start = s; 771 while (Py_ISSPACE(*s)) 772 s++; 773 if (*s == '(') { 774 /* Skip over possible bracket from repr(). */ 775 got_bracket = 1; 776 s++; 777 while (Py_ISSPACE(*s)) 778 s++; 779 } 780 781 /* a valid complex string usually takes one of the three forms: 782 783 <float> - real part only 784 <float>j - imaginary part only 785 <float><signed-float>j - real and imaginary parts 786 787 where <float> represents any numeric string that's accepted by the 788 float constructor (including 'nan', 'inf', 'infinity', etc.), and 789 <signed-float> is any string of the form <float> whose first 790 character is '+' or '-'. 791 792 For backwards compatibility, the extra forms 793 794 <float><sign>j 795 <sign>j 796 j 797 798 are also accepted, though support for these forms may be removed from 799 a future version of Python. 800 */ 801 802 /* first look for forms starting with <float> */ 803 z = PyOS_string_to_double(s, &end, NULL); 804 if (z == -1.0 && PyErr_Occurred()) { 805 if (PyErr_ExceptionMatches(PyExc_ValueError)) 806 PyErr_Clear(); 807 else 808 return NULL; 809 } 810 if (end != s) { 811 /* all 4 forms starting with <float> land here */ 812 s = end; 813 if (*s == '+' || *s == '-') { 814 /* <float><signed-float>j | <float><sign>j */ 815 x = z; 816 y = PyOS_string_to_double(s, &end, NULL); 817 if (y == -1.0 && PyErr_Occurred()) { 818 if (PyErr_ExceptionMatches(PyExc_ValueError)) 819 PyErr_Clear(); 820 else 821 return NULL; 822 } 823 if (end != s) 824 /* <float><signed-float>j */ 825 s = end; 826 else { 827 /* <float><sign>j */ 828 y = *s == '+' ? 1.0 : -1.0; 829 s++; 830 } 831 if (!(*s == 'j' || *s == 'J')) 832 goto parse_error; 833 s++; 834 } 835 else if (*s == 'j' || *s == 'J') { 836 /* <float>j */ 837 s++; 838 y = z; 839 } 840 else 841 /* <float> */ 842 x = z; 843 } 844 else { 845 /* not starting with <float>; must be <sign>j or j */ 846 if (*s == '+' || *s == '-') { 847 /* <sign>j */ 848 y = *s == '+' ? 1.0 : -1.0; 849 s++; 850 } 851 else 852 /* j */ 853 y = 1.0; 854 if (!(*s == 'j' || *s == 'J')) 855 goto parse_error; 856 s++; 857 } 858 859 /* trailing whitespace and closing bracket */ 860 while (Py_ISSPACE(*s)) 861 s++; 862 if (got_bracket) { 863 /* if there was an opening parenthesis, then the corresponding 864 closing parenthesis should be right here */ 865 if (*s != ')') 866 goto parse_error; 867 s++; 868 while (Py_ISSPACE(*s)) 869 s++; 870 } 871 872 /* we should now be at the end of the string */ 873 if (s-start != len) 874 goto parse_error; 875 876 return complex_subtype_from_doubles((PyTypeObject *)type, x, y); 877 878 parse_error: 879 PyErr_SetString(PyExc_ValueError, 880 "complex() arg is a malformed string"); 881 return NULL; 882 } 883 884 static PyObject * 885 complex_subtype_from_string(PyTypeObject *type, PyObject *v) 886 { 887 const char *s; 888 PyObject *s_buffer = NULL, *result = NULL; 889 Py_ssize_t len; 890 891 if (PyUnicode_Check(v)) { 892 s_buffer = _PyUnicode_TransformDecimalAndSpaceToASCII(v); 893 if (s_buffer == NULL) { 894 return NULL; 895 } 896 s = PyUnicode_AsUTF8AndSize(s_buffer, &len); 897 if (s == NULL) { 898 goto exit; 899 } 900 } 901 else { 902 PyErr_Format(PyExc_TypeError, 903 "complex() argument must be a string or a number, not '%.200s'", 904 Py_TYPE(v)->tp_name); 905 return NULL; 906 } 907 908 result = _Py_string_to_number_with_underscores(s, len, "complex", v, type, 909 complex_from_string_inner); 910 exit: 911 Py_DECREF(s_buffer); 912 return result; 913 } 914 915 static PyObject * 916 complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 917 { 918 PyObject *r, *i, *tmp; 919 PyNumberMethods *nbr, *nbi = NULL; 920 Py_complex cr, ci; 921 int own_r = 0; 922 int cr_is_complex = 0; 923 int ci_is_complex = 0; 924 static char *kwlist[] = {"real", "imag", 0}; 925 926 r = Py_False; 927 i = NULL; 928 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO:complex", kwlist, 929 &r, &i)) 930 return NULL; 931 932 /* Special-case for a single argument when type(arg) is complex. */ 933 if (PyComplex_CheckExact(r) && i == NULL && 934 type == &PyComplex_Type) { 935 /* Note that we can't know whether it's safe to return 936 a complex *subclass* instance as-is, hence the restriction 937 to exact complexes here. If either the input or the 938 output is a complex subclass, it will be handled below 939 as a non-orthogonal vector. */ 940 Py_INCREF(r); 941 return r; 942 } 943 if (PyUnicode_Check(r)) { 944 if (i != NULL) { 945 PyErr_SetString(PyExc_TypeError, 946 "complex() can't take second arg" 947 " if first is a string"); 948 return NULL; 949 } 950 return complex_subtype_from_string(type, r); 951 } 952 if (i != NULL && PyUnicode_Check(i)) { 953 PyErr_SetString(PyExc_TypeError, 954 "complex() second arg can't be a string"); 955 return NULL; 956 } 957 958 tmp = try_complex_special_method(r); 959 if (tmp) { 960 r = tmp; 961 own_r = 1; 962 } 963 else if (PyErr_Occurred()) { 964 return NULL; 965 } 966 967 nbr = r->ob_type->tp_as_number; 968 if (nbr == NULL || nbr->nb_float == NULL) { 969 PyErr_Format(PyExc_TypeError, 970 "complex() first argument must be a string or a number, " 971 "not '%.200s'", 972 Py_TYPE(r)->tp_name); 973 if (own_r) { 974 Py_DECREF(r); 975 } 976 return NULL; 977 } 978 if (i != NULL) { 979 nbi = i->ob_type->tp_as_number; 980 if (nbi == NULL || nbi->nb_float == NULL) { 981 PyErr_Format(PyExc_TypeError, 982 "complex() second argument must be a number, " 983 "not '%.200s'", 984 Py_TYPE(i)->tp_name); 985 if (own_r) { 986 Py_DECREF(r); 987 } 988 return NULL; 989 } 990 } 991 992 /* If we get this far, then the "real" and "imag" parts should 993 both be treated as numbers, and the constructor should return a 994 complex number equal to (real + imag*1j). 995 996 Note that we do NOT assume the input to already be in canonical 997 form; the "real" and "imag" parts might themselves be complex 998 numbers, which slightly complicates the code below. */ 999 if (PyComplex_Check(r)) { 1000 /* Note that if r is of a complex subtype, we're only 1001 retaining its real & imag parts here, and the return 1002 value is (properly) of the builtin complex type. */ 1003 cr = ((PyComplexObject*)r)->cval; 1004 cr_is_complex = 1; 1005 if (own_r) { 1006 Py_DECREF(r); 1007 } 1008 } 1009 else { 1010 /* The "real" part really is entirely real, and contributes 1011 nothing in the imaginary direction. 1012 Just treat it as a double. */ 1013 tmp = PyNumber_Float(r); 1014 if (own_r) { 1015 /* r was a newly created complex number, rather 1016 than the original "real" argument. */ 1017 Py_DECREF(r); 1018 } 1019 if (tmp == NULL) 1020 return NULL; 1021 if (!PyFloat_Check(tmp)) { 1022 PyErr_SetString(PyExc_TypeError, 1023 "float(r) didn't return a float"); 1024 Py_DECREF(tmp); 1025 return NULL; 1026 } 1027 cr.real = PyFloat_AsDouble(tmp); 1028 cr.imag = 0.0; 1029 Py_DECREF(tmp); 1030 } 1031 if (i == NULL) { 1032 ci.real = cr.imag; 1033 } 1034 else if (PyComplex_Check(i)) { 1035 ci = ((PyComplexObject*)i)->cval; 1036 ci_is_complex = 1; 1037 } else { 1038 /* The "imag" part really is entirely imaginary, and 1039 contributes nothing in the real direction. 1040 Just treat it as a double. */ 1041 tmp = (*nbi->nb_float)(i); 1042 if (tmp == NULL) 1043 return NULL; 1044 ci.real = PyFloat_AsDouble(tmp); 1045 Py_DECREF(tmp); 1046 } 1047 /* If the input was in canonical form, then the "real" and "imag" 1048 parts are real numbers, so that ci.imag and cr.imag are zero. 1049 We need this correction in case they were not real numbers. */ 1050 1051 if (ci_is_complex) { 1052 cr.real -= ci.imag; 1053 } 1054 if (cr_is_complex && i != NULL) { 1055 ci.real += cr.imag; 1056 } 1057 return complex_subtype_from_doubles(type, cr.real, ci.real); 1058 } 1059 1060 PyDoc_STRVAR(complex_doc, 1061 "complex(real[, imag]) -> complex number\n" 1062 "\n" 1063 "Create a complex number from a real part and an optional imaginary part.\n" 1064 "This is equivalent to (real + imag*1j) where imag defaults to 0."); 1065 1066 static PyNumberMethods complex_as_number = { 1067 (binaryfunc)complex_add, /* nb_add */ 1068 (binaryfunc)complex_sub, /* nb_subtract */ 1069 (binaryfunc)complex_mul, /* nb_multiply */ 1070 (binaryfunc)complex_remainder, /* nb_remainder */ 1071 (binaryfunc)complex_divmod, /* nb_divmod */ 1072 (ternaryfunc)complex_pow, /* nb_power */ 1073 (unaryfunc)complex_neg, /* nb_negative */ 1074 (unaryfunc)complex_pos, /* nb_positive */ 1075 (unaryfunc)complex_abs, /* nb_absolute */ 1076 (inquiry)complex_bool, /* nb_bool */ 1077 0, /* nb_invert */ 1078 0, /* nb_lshift */ 1079 0, /* nb_rshift */ 1080 0, /* nb_and */ 1081 0, /* nb_xor */ 1082 0, /* nb_or */ 1083 complex_int, /* nb_int */ 1084 0, /* nb_reserved */ 1085 complex_float, /* nb_float */ 1086 0, /* nb_inplace_add */ 1087 0, /* nb_inplace_subtract */ 1088 0, /* nb_inplace_multiply*/ 1089 0, /* nb_inplace_remainder */ 1090 0, /* nb_inplace_power */ 1091 0, /* nb_inplace_lshift */ 1092 0, /* nb_inplace_rshift */ 1093 0, /* nb_inplace_and */ 1094 0, /* nb_inplace_xor */ 1095 0, /* nb_inplace_or */ 1096 (binaryfunc)complex_int_div, /* nb_floor_divide */ 1097 (binaryfunc)complex_div, /* nb_true_divide */ 1098 0, /* nb_inplace_floor_divide */ 1099 0, /* nb_inplace_true_divide */ 1100 }; 1101 1102 PyTypeObject PyComplex_Type = { 1103 PyVarObject_HEAD_INIT(&PyType_Type, 0) 1104 "complex", 1105 sizeof(PyComplexObject), 1106 0, 1107 complex_dealloc, /* tp_dealloc */ 1108 0, /* tp_print */ 1109 0, /* tp_getattr */ 1110 0, /* tp_setattr */ 1111 0, /* tp_reserved */ 1112 (reprfunc)complex_repr, /* tp_repr */ 1113 &complex_as_number, /* tp_as_number */ 1114 0, /* tp_as_sequence */ 1115 0, /* tp_as_mapping */ 1116 (hashfunc)complex_hash, /* tp_hash */ 1117 0, /* tp_call */ 1118 (reprfunc)complex_repr, /* tp_str */ 1119 PyObject_GenericGetAttr, /* tp_getattro */ 1120 0, /* tp_setattro */ 1121 0, /* tp_as_buffer */ 1122 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 1123 complex_doc, /* tp_doc */ 1124 0, /* tp_traverse */ 1125 0, /* tp_clear */ 1126 complex_richcompare, /* tp_richcompare */ 1127 0, /* tp_weaklistoffset */ 1128 0, /* tp_iter */ 1129 0, /* tp_iternext */ 1130 complex_methods, /* tp_methods */ 1131 complex_members, /* tp_members */ 1132 0, /* tp_getset */ 1133 0, /* tp_base */ 1134 0, /* tp_dict */ 1135 0, /* tp_descr_get */ 1136 0, /* tp_descr_set */ 1137 0, /* tp_dictoffset */ 1138 0, /* tp_init */ 1139 PyType_GenericAlloc, /* tp_alloc */ 1140 complex_new, /* tp_new */ 1141 PyObject_Del, /* tp_free */ 1142 }; 1143
