Changeset 388 for python/vendor/current/Objects/complexobject.c
- Timestamp:
- Mar 19, 2014, 11:11:30 AM (11 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
python/vendor/current/Objects/complexobject.c
r2 r388 8 8 #include "Python.h" 9 9 #include "structmember.h" 10 11 #ifdef HAVE_IEEEFP_H12 #include <ieeefp.h>13 #endif14 10 15 11 #ifndef WITHOUT_COMPLEX … … 28 24 */ 29 25 30 #define PREC_REPR 31 #define PREC_STR 26 #define PREC_REPR 17 27 #define PREC_STR 12 32 28 33 29 /* elementary operations on complex numbers */ … … 38 34 c_sum(Py_complex a, Py_complex b) 39 35 { 40 41 42 43 36 Py_complex r; 37 r.real = a.real + b.real; 38 r.imag = a.imag + b.imag; 39 return r; 44 40 } 45 41 … … 47 43 c_diff(Py_complex a, Py_complex b) 48 44 { 49 50 51 52 45 Py_complex r; 46 r.real = a.real - b.real; 47 r.imag = a.imag - b.imag; 48 return r; 53 49 } 54 50 … … 56 52 c_neg(Py_complex a) 57 53 { 58 59 60 61 54 Py_complex r; 55 r.real = -a.real; 56 r.imag = -a.imag; 57 return r; 62 58 } 63 59 … … 65 61 c_prod(Py_complex a, Py_complex b) 66 62 { 67 68 69 70 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; 71 67 } 72 68 … … 74 70 c_quot(Py_complex a, Py_complex b) 75 71 { 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 Py_complex r;/* the result */100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 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; 125 121 } 126 122 … … 128 124 c_pow(Py_complex a, Py_complex b) 129 125 { 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 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 = EDOM; 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; 155 151 } 156 152 … … 158 154 c_powu(Py_complex x, long n) 159 155 { 160 161 162 163 164 165 166 167 168 169 170 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; 171 167 } 172 168 … … 174 170 c_powi(Py_complex x, long n) 175 171 { 176 177 178 179 180 181 182 183 184 185 186 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)); 187 183 188 184 } … … 191 187 c_abs(Py_complex z) 192 188 { 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 189 /* sets errno = ERANGE on overflow; otherwise errno = 0 */ 190 double result; 191 192 if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) { 193 /* C99 rules: if either the real or the imaginary part is an 194 infinity, return infinity, even if the other part is a 195 NaN. */ 196 if (Py_IS_INFINITY(z.real)) { 197 result = fabs(z.real); 198 errno = 0; 199 return result; 200 } 201 if (Py_IS_INFINITY(z.imag)) { 202 result = fabs(z.imag); 203 errno = 0; 204 return result; 205 } 206 /* either the real or imaginary part is a NaN, 207 and neither is infinite. Result should be NaN. */ 208 return Py_NAN; 209 } 210 result = hypot(z.real, z.imag); 211 if (!Py_IS_FINITE(result)) 212 errno = ERANGE; 213 else 214 errno = 0; 215 return result; 220 216 } 221 217 … … 223 219 complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval) 224 220 { 225 226 227 228 229 230 221 PyObject *op; 222 223 op = type->tp_alloc(type, 0); 224 if (op != NULL) 225 ((PyComplexObject *)op)->cval = cval; 226 return op; 231 227 } 232 228 … … 234 230 PyComplex_FromCComplex(Py_complex cval) 235 231 { 236 237 238 239 240 241 242 243 244 232 register PyComplexObject *op; 233 234 /* Inline PyObject_New */ 235 op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject)); 236 if (op == NULL) 237 return PyErr_NoMemory(); 238 PyObject_INIT(op, &PyComplex_Type); 239 op->cval = cval; 240 return (PyObject *) op; 245 241 } 246 242 … … 248 244 complex_subtype_from_doubles(PyTypeObject *type, double real, double imag) 249 245 { 250 251 252 253 246 Py_complex c; 247 c.real = real; 248 c.imag = imag; 249 return complex_subtype_from_c_complex(type, c); 254 250 } 255 251 … … 257 253 PyComplex_FromDoubles(double real, double imag) 258 254 { 259 260 261 262 255 Py_complex c; 256 c.real = real; 257 c.imag = imag; 258 return PyComplex_FromCComplex(c); 263 259 } 264 260 … … 266 262 PyComplex_RealAsDouble(PyObject *op) 267 263 { 268 269 270 271 272 273 264 if (PyComplex_Check(op)) { 265 return ((PyComplexObject *)op)->cval.real; 266 } 267 else { 268 return PyFloat_AsDouble(op); 269 } 274 270 } 275 271 … … 277 273 PyComplex_ImagAsDouble(PyObject *op) 278 274 { 279 if (PyComplex_Check(op)) { 280 return ((PyComplexObject *)op)->cval.imag; 281 } 282 else { 283 return 0.0; 284 } 275 if (PyComplex_Check(op)) { 276 return ((PyComplexObject *)op)->cval.imag; 277 } 278 else { 279 return 0.0; 280 } 281 } 282 283 static PyObject * 284 try_complex_special_method(PyObject *op) { 285 PyObject *f; 286 static PyObject *complexstr; 287 288 if (complexstr == NULL) { 289 complexstr = PyString_InternFromString("__complex__"); 290 if (complexstr == NULL) 291 return NULL; 292 } 293 if (PyInstance_Check(op)) { 294 f = PyObject_GetAttr(op, complexstr); 295 if (f == NULL) { 296 if (PyErr_ExceptionMatches(PyExc_AttributeError)) 297 PyErr_Clear(); 298 else 299 return NULL; 300 } 301 } 302 else { 303 f = _PyObject_LookupSpecial(op, "__complex__", &complexstr); 304 if (f == NULL && PyErr_Occurred()) 305 return NULL; 306 } 307 if (f != NULL) { 308 PyObject *res = PyObject_CallFunctionObjArgs(f, NULL); 309 Py_DECREF(f); 310 return res; 311 } 312 return NULL; 285 313 } 286 314 … … 288 316 PyComplex_AsCComplex(PyObject *op) 289 317 { 290 Py_complex cv; 291 PyObject *newop = NULL; 292 static PyObject *complex_str = NULL; 293 294 assert(op); 295 /* If op is already of type PyComplex_Type, return its value */ 296 if (PyComplex_Check(op)) { 297 return ((PyComplexObject *)op)->cval; 298 } 299 /* If not, use op's __complex__ method, if it exists */ 300 301 /* return -1 on failure */ 302 cv.real = -1.; 303 cv.imag = 0.; 304 305 if (complex_str == NULL) { 306 if (!(complex_str = PyString_InternFromString("__complex__"))) 307 return cv; 308 } 309 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); 314 if (!newop) 315 return cv; 316 } 317 /* else try __float__ */ 318 } else { 319 PyObject *complexfunc; 320 complexfunc = _PyType_Lookup(op->ob_type, complex_str); 321 /* complexfunc is a borrowed reference */ 322 if (complexfunc) { 323 newop = PyObject_CallFunctionObjArgs(complexfunc, op, NULL); 324 if (!newop) 325 return cv; 326 } 327 } 328 329 if (newop) { 330 if (!PyComplex_Check(newop)) { 331 PyErr_SetString(PyExc_TypeError, 332 "__complex__ should return a complex object"); 333 Py_DECREF(newop); 334 return cv; 335 } 336 cv = ((PyComplexObject *)newop)->cval; 337 Py_DECREF(newop); 338 return cv; 339 } 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. */ 342 else { 343 /* PyFloat_AsDouble will return -1 on failure */ 344 cv.real = PyFloat_AsDouble(op); 345 return cv; 346 } 318 Py_complex cv; 319 PyObject *newop = NULL; 320 321 assert(op); 322 /* If op is already of type PyComplex_Type, return its value */ 323 if (PyComplex_Check(op)) { 324 return ((PyComplexObject *)op)->cval; 325 } 326 /* If not, use op's __complex__ method, if it exists */ 327 328 /* return -1 on failure */ 329 cv.real = -1.; 330 cv.imag = 0.; 331 332 newop = try_complex_special_method(op); 333 334 if (newop) { 335 if (!PyComplex_Check(newop)) { 336 PyErr_SetString(PyExc_TypeError, 337 "__complex__ should return a complex object"); 338 Py_DECREF(newop); 339 return cv; 340 } 341 cv = ((PyComplexObject *)newop)->cval; 342 Py_DECREF(newop); 343 return cv; 344 } 345 else if (PyErr_Occurred()) { 346 return cv; 347 } 348 /* If neither of the above works, interpret op as a float giving the 349 real part of the result, and fill in the imaginary part as 0. */ 350 else { 351 /* PyFloat_AsDouble will return -1 on failure */ 352 cv.real = PyFloat_AsDouble(op); 353 return cv; 354 } 347 355 } 348 356 … … 350 358 complex_dealloc(PyObject *op) 351 359 { 352 op->ob_type->tp_free(op); 353 } 354 355 356 static void 357 complex_to_buf(char *buf, int bufsz, PyComplexObject *v, int precision) 358 { 359 char format[32]; 360 if (v->cval.real == 0.) { 361 if (!Py_IS_FINITE(v->cval.imag)) { 362 if (Py_IS_NAN(v->cval.imag)) 363 strncpy(buf, "nan*j", 6); 364 else if (copysign(1, v->cval.imag) == 1) 365 strncpy(buf, "inf*j", 6); 366 else 367 strncpy(buf, "-inf*j", 7); 368 } 369 else { 370 PyOS_snprintf(format, sizeof(format), "%%.%ig", precision); 371 PyOS_ascii_formatd(buf, bufsz - 1, format, v->cval.imag); 372 strncat(buf, "j", 1); 373 } 374 } else { 375 char re[64], im[64]; 376 /* Format imaginary part with sign, real part without */ 377 if (!Py_IS_FINITE(v->cval.real)) { 378 if (Py_IS_NAN(v->cval.real)) 379 strncpy(re, "nan", 4); 380 /* else if (copysign(1, v->cval.real) == 1) */ 381 else if (v->cval.real > 0) 382 strncpy(re, "inf", 4); 383 else 384 strncpy(re, "-inf", 5); 385 } 386 else { 387 PyOS_snprintf(format, sizeof(format), "%%.%ig", precision); 388 PyOS_ascii_formatd(re, sizeof(re), format, v->cval.real); 389 } 390 if (!Py_IS_FINITE(v->cval.imag)) { 391 if (Py_IS_NAN(v->cval.imag)) 392 strncpy(im, "+nan*", 6); 393 /* else if (copysign(1, v->cval.imag) == 1) */ 394 else if (v->cval.imag > 0) 395 strncpy(im, "+inf*", 6); 396 else 397 strncpy(im, "-inf*", 6); 398 } 399 else { 400 PyOS_snprintf(format, sizeof(format), "%%+.%ig", precision); 401 PyOS_ascii_formatd(im, sizeof(im), format, v->cval.imag); 402 } 403 PyOS_snprintf(buf, bufsz, "(%s%sj)", re, im); 404 } 360 op->ob_type->tp_free(op); 361 } 362 363 364 static PyObject * 365 complex_format(PyComplexObject *v, int precision, char format_code) 366 { 367 PyObject *result = NULL; 368 Py_ssize_t len; 369 370 /* If these are non-NULL, they'll need to be freed. */ 371 char *pre = NULL; 372 char *im = NULL; 373 char *buf = NULL; 374 375 /* These do not need to be freed. re is either an alias 376 for pre or a pointer to a constant. lead and tail 377 are pointers to constants. */ 378 char *re = NULL; 379 char *lead = ""; 380 char *tail = ""; 381 382 if (v->cval.real == 0. && copysign(1.0, v->cval.real)==1.0) { 383 re = ""; 384 im = PyOS_double_to_string(v->cval.imag, format_code, 385 precision, 0, NULL); 386 if (!im) { 387 PyErr_NoMemory(); 388 goto done; 389 } 390 } else { 391 /* Format imaginary part with sign, real part without */ 392 pre = PyOS_double_to_string(v->cval.real, format_code, 393 precision, 0, NULL); 394 if (!pre) { 395 PyErr_NoMemory(); 396 goto done; 397 } 398 re = pre; 399 400 im = PyOS_double_to_string(v->cval.imag, format_code, 401 precision, Py_DTSF_SIGN, NULL); 402 if (!im) { 403 PyErr_NoMemory(); 404 goto done; 405 } 406 lead = "("; 407 tail = ")"; 408 } 409 /* Alloc the final buffer. Add one for the "j" in the format string, 410 and one for the trailing zero. */ 411 len = strlen(lead) + strlen(re) + strlen(im) + strlen(tail) + 2; 412 buf = PyMem_Malloc(len); 413 if (!buf) { 414 PyErr_NoMemory(); 415 goto done; 416 } 417 PyOS_snprintf(buf, len, "%s%s%sj%s", lead, re, im, tail); 418 result = PyString_FromString(buf); 419 done: 420 PyMem_Free(im); 421 PyMem_Free(pre); 422 PyMem_Free(buf); 423 424 return result; 405 425 } 406 426 … … 408 428 complex_print(PyComplexObject *v, FILE *fp, int flags) 409 429 { 410 char buf[100]; 411 complex_to_buf(buf, sizeof(buf), v, 412 (flags & Py_PRINT_RAW) ? PREC_STR : PREC_REPR); 413 Py_BEGIN_ALLOW_THREADS 414 fputs(buf, fp); 415 Py_END_ALLOW_THREADS 416 return 0; 430 PyObject *formatv; 431 char *buf; 432 if (flags & Py_PRINT_RAW) 433 formatv = complex_format(v, PyFloat_STR_PRECISION, 'g'); 434 else 435 formatv = complex_format(v, 0, 'r'); 436 if (formatv == NULL) 437 return -1; 438 buf = PyString_AS_STRING(formatv); 439 Py_BEGIN_ALLOW_THREADS 440 fputs(buf, fp); 441 Py_END_ALLOW_THREADS 442 Py_DECREF(formatv); 443 return 0; 417 444 } 418 445 … … 420 447 complex_repr(PyComplexObject *v) 421 448 { 422 char buf[100]; 423 complex_to_buf(buf, sizeof(buf), v, PREC_REPR); 424 return PyString_FromString(buf); 449 return complex_format(v, 0, 'r'); 425 450 } 426 451 … … 428 453 complex_str(PyComplexObject *v) 429 454 { 430 char buf[100]; 431 complex_to_buf(buf, sizeof(buf), v, PREC_STR); 432 return PyString_FromString(buf); 455 return complex_format(v, PyFloat_STR_PRECISION, 'g'); 433 456 } 434 457 … … 436 459 complex_hash(PyComplexObject *v) 437 460 { 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 461 long hashreal, hashimag, combined; 462 hashreal = _Py_HashDouble(v->cval.real); 463 if (hashreal == -1) 464 return -1; 465 hashimag = _Py_HashDouble(v->cval.imag); 466 if (hashimag == -1) 467 return -1; 468 /* Note: if the imaginary part is 0, hashimag is 0 now, 469 * so the following returns hashreal unchanged. This is 470 * important because numbers of different types that 471 * compare equal must have the same hash value, so that 472 * hash(x + 0*j) must equal hash(x). 473 */ 474 combined = hashreal + 1000003 * hashimag; 475 if (combined == -1) 476 combined = -2; 477 return combined; 455 478 } 456 479 457 480 /* This macro may return! */ 458 481 #define TO_COMPLEX(obj, c) \ 459 460 461 462 482 if (PyComplex_Check(obj)) \ 483 c = ((PyComplexObject *)(obj))->cval; \ 484 else if (to_complex(&(obj), &(c)) < 0) \ 485 return (obj) 463 486 464 487 static int … … 469 492 pc->real = pc->imag = 0.0; 470 493 if (PyInt_Check(obj)) { 471 472 494 pc->real = PyInt_AS_LONG(obj); 495 return 0; 473 496 } 474 497 if (PyLong_Check(obj)) { 475 476 477 478 479 480 498 pc->real = PyLong_AsDouble(obj); 499 if (pc->real == -1.0 && PyErr_Occurred()) { 500 *pobj = NULL; 501 return -1; 502 } 503 return 0; 481 504 } 482 505 if (PyFloat_Check(obj)) { 483 484 506 pc->real = PyFloat_AsDouble(obj); 507 return 0; 485 508 } 486 509 Py_INCREF(Py_NotImplemented); … … 488 511 return -1; 489 512 } 490 491 492 static PyObject * 493 complex_add(PyComplexObject *v, PyComplexObject *w) 494 { 495 Py_complex result; 496 PyFPE_START_PROTECT("complex_add", return 0) 497 result = c_sum(v->cval,w->cval); 498 PyFPE_END_PROTECT(result) 499 return PyComplex_FromCComplex(result); 500 } 501 502 static PyObject * 503 complex_sub(PyComplexObject *v, PyComplexObject *w) 504 { 505 Py_complex result; 506 PyFPE_START_PROTECT("complex_sub", return 0) 507 result = c_diff(v->cval,w->cval); 508 PyFPE_END_PROTECT(result) 509 return PyComplex_FromCComplex(result); 510 } 511 512 static PyObject * 513 complex_mul(PyComplexObject *v, PyComplexObject *w) 514 { 515 Py_complex result; 516 PyFPE_START_PROTECT("complex_mul", return 0) 517 result = c_prod(v->cval,w->cval); 518 PyFPE_END_PROTECT(result) 519 return PyComplex_FromCComplex(result); 520 } 521 522 static PyObject * 523 complex_div(PyComplexObject *v, PyComplexObject *w) 524 { 525 Py_complex quot; 526 527 PyFPE_START_PROTECT("complex_div", return 0) 528 errno = 0; 529 quot = c_quot(v->cval,w->cval); 530 PyFPE_END_PROTECT(quot) 531 if (errno == EDOM) { 532 PyErr_SetString(PyExc_ZeroDivisionError, "complex division"); 533 return NULL; 534 } 535 return PyComplex_FromCComplex(quot); 536 } 537 538 static PyObject * 539 complex_classic_div(PyComplexObject *v, PyComplexObject *w) 540 { 541 Py_complex quot; 542 543 if (Py_DivisionWarningFlag >= 2 && 544 PyErr_Warn(PyExc_DeprecationWarning, 545 "classic complex division") < 0) 546 return NULL; 547 548 PyFPE_START_PROTECT("complex_classic_div", return 0) 549 errno = 0; 550 quot = c_quot(v->cval,w->cval); 551 PyFPE_END_PROTECT(quot) 552 if (errno == EDOM) { 553 PyErr_SetString(PyExc_ZeroDivisionError, "complex division"); 554 return NULL; 555 } 556 return PyComplex_FromCComplex(quot); 557 } 558 559 static PyObject * 560 complex_remainder(PyComplexObject *v, PyComplexObject *w) 561 { 562 Py_complex div, mod; 563 564 if (PyErr_Warn(PyExc_DeprecationWarning, 565 "complex divmod(), // and % are deprecated") < 0) 566 return NULL; 567 568 errno = 0; 569 div = c_quot(v->cval,w->cval); /* The raw divisor value. */ 570 if (errno == EDOM) { 571 PyErr_SetString(PyExc_ZeroDivisionError, "complex remainder"); 572 return NULL; 573 } 574 div.real = floor(div.real); /* Use the floor of the real part. */ 575 div.imag = 0.0; 576 mod = c_diff(v->cval, c_prod(w->cval, div)); 577 578 return PyComplex_FromCComplex(mod); 579 } 580 581 582 static PyObject * 583 complex_divmod(PyComplexObject *v, PyComplexObject *w) 584 { 585 Py_complex div, mod; 586 PyObject *d, *m, *z; 587 588 if (PyErr_Warn(PyExc_DeprecationWarning, 589 "complex divmod(), // and % are deprecated") < 0) 590 return NULL; 591 592 errno = 0; 593 div = c_quot(v->cval,w->cval); /* The raw divisor value. */ 594 if (errno == EDOM) { 595 PyErr_SetString(PyExc_ZeroDivisionError, "complex divmod()"); 596 return NULL; 597 } 598 div.real = floor(div.real); /* Use the floor of the real part. */ 599 div.imag = 0.0; 600 mod = c_diff(v->cval, c_prod(w->cval, div)); 601 d = PyComplex_FromCComplex(div); 602 m = PyComplex_FromCComplex(mod); 603 z = PyTuple_Pack(2, d, m); 604 Py_XDECREF(d); 605 Py_XDECREF(m); 606 return z; 513 514 515 static PyObject * 516 complex_add(PyObject *v, PyObject *w) 517 { 518 Py_complex result; 519 Py_complex a, b; 520 TO_COMPLEX(v, a); 521 TO_COMPLEX(w, b); 522 PyFPE_START_PROTECT("complex_add", return 0) 523 result = c_sum(a, b); 524 PyFPE_END_PROTECT(result) 525 return PyComplex_FromCComplex(result); 526 } 527 528 static PyObject * 529 complex_sub(PyObject *v, PyObject *w) 530 { 531 Py_complex result; 532 Py_complex a, b; 533 TO_COMPLEX(v, a); 534 TO_COMPLEX(w, b);; 535 PyFPE_START_PROTECT("complex_sub", return 0) 536 result = c_diff(a, b); 537 PyFPE_END_PROTECT(result) 538 return PyComplex_FromCComplex(result); 539 } 540 541 static PyObject * 542 complex_mul(PyObject *v, PyObject *w) 543 { 544 Py_complex result; 545 Py_complex a, b; 546 TO_COMPLEX(v, a); 547 TO_COMPLEX(w, b); 548 PyFPE_START_PROTECT("complex_mul", return 0) 549 result = c_prod(a, b); 550 PyFPE_END_PROTECT(result) 551 return PyComplex_FromCComplex(result); 552 } 553 554 static PyObject * 555 complex_div(PyObject *v, PyObject *w) 556 { 557 Py_complex quot; 558 Py_complex a, b; 559 TO_COMPLEX(v, a); 560 TO_COMPLEX(w, b); 561 PyFPE_START_PROTECT("complex_div", return 0) 562 errno = 0; 563 quot = c_quot(a, b); 564 PyFPE_END_PROTECT(quot) 565 if (errno == EDOM) { 566 PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero"); 567 return NULL; 568 } 569 return PyComplex_FromCComplex(quot); 570 } 571 572 static PyObject * 573 complex_classic_div(PyObject *v, PyObject *w) 574 { 575 Py_complex quot; 576 Py_complex a, b; 577 TO_COMPLEX(v, a); 578 TO_COMPLEX(w, b); 579 if (Py_DivisionWarningFlag >= 2 && 580 PyErr_Warn(PyExc_DeprecationWarning, 581 "classic complex division") < 0) 582 return NULL; 583 584 PyFPE_START_PROTECT("complex_classic_div", return 0) 585 errno = 0; 586 quot = c_quot(a, b); 587 PyFPE_END_PROTECT(quot) 588 if (errno == EDOM) { 589 PyErr_SetString(PyExc_ZeroDivisionError, "complex division by zero"); 590 return NULL; 591 } 592 return PyComplex_FromCComplex(quot); 593 } 594 595 static PyObject * 596 complex_remainder(PyObject *v, PyObject *w) 597 { 598 Py_complex div, mod; 599 Py_complex a, b; 600 TO_COMPLEX(v, a); 601 TO_COMPLEX(w, b); 602 if (PyErr_Warn(PyExc_DeprecationWarning, 603 "complex divmod(), // and % are deprecated") < 0) 604 return NULL; 605 606 errno = 0; 607 div = c_quot(a, b); /* The raw divisor value. */ 608 if (errno == EDOM) { 609 PyErr_SetString(PyExc_ZeroDivisionError, "complex remainder"); 610 return NULL; 611 } 612 div.real = floor(div.real); /* Use the floor of the real part. */ 613 div.imag = 0.0; 614 mod = c_diff(a, c_prod(b, div)); 615 616 return PyComplex_FromCComplex(mod); 617 } 618 619 620 static PyObject * 621 complex_divmod(PyObject *v, PyObject *w) 622 { 623 Py_complex div, mod; 624 PyObject *d, *m, *z; 625 Py_complex a, b; 626 TO_COMPLEX(v, a); 627 TO_COMPLEX(w, b); 628 if (PyErr_Warn(PyExc_DeprecationWarning, 629 "complex divmod(), // and % are deprecated") < 0) 630 return NULL; 631 632 errno = 0; 633 div = c_quot(a, b); /* The raw divisor value. */ 634 if (errno == EDOM) { 635 PyErr_SetString(PyExc_ZeroDivisionError, "complex divmod()"); 636 return NULL; 637 } 638 div.real = floor(div.real); /* Use the floor of the real part. */ 639 div.imag = 0.0; 640 mod = c_diff(a, c_prod(b, div)); 641 d = PyComplex_FromCComplex(div); 642 m = PyComplex_FromCComplex(mod); 643 z = PyTuple_Pack(2, d, m); 644 Py_XDECREF(d); 645 Py_XDECREF(m); 646 return z; 607 647 } 608 648 … … 610 650 complex_pow(PyObject *v, PyObject *w, PyObject *z) 611 651 { 612 Py_complex p; 613 Py_complex exponent; 614 long int_exponent; 615 Py_complex a, b; 616 TO_COMPLEX(v, a); 617 TO_COMPLEX(w, b); 618 619 if (z!=Py_None) { 620 PyErr_SetString(PyExc_ValueError, "complex modulo"); 621 return NULL; 622 } 623 PyFPE_START_PROTECT("complex_pow", return 0) 624 errno = 0; 625 exponent = b; 626 int_exponent = (long)exponent.real; 627 if (exponent.imag == 0. && exponent.real == int_exponent) 628 p = c_powi(a,int_exponent); 629 else 630 p = c_pow(a,exponent); 631 632 PyFPE_END_PROTECT(p) 633 Py_ADJUST_ERANGE2(p.real, p.imag); 634 if (errno == EDOM) { 635 PyErr_SetString(PyExc_ZeroDivisionError, 636 "0.0 to a negative or complex power"); 637 return NULL; 638 } 639 else if (errno == ERANGE) { 640 PyErr_SetString(PyExc_OverflowError, 641 "complex exponentiation"); 642 return NULL; 643 } 644 return PyComplex_FromCComplex(p); 645 } 646 647 static PyObject * 648 complex_int_div(PyComplexObject *v, PyComplexObject *w) 649 { 650 PyObject *t, *r; 651 652 if (PyErr_Warn(PyExc_DeprecationWarning, 653 "complex divmod(), // and % are deprecated") < 0) 654 return NULL; 655 656 t = complex_divmod(v, w); 657 if (t != NULL) { 658 r = PyTuple_GET_ITEM(t, 0); 659 Py_INCREF(r); 660 Py_DECREF(t); 661 return r; 662 } 663 return NULL; 652 Py_complex p; 653 Py_complex exponent; 654 long int_exponent; 655 Py_complex a, b; 656 TO_COMPLEX(v, a); 657 TO_COMPLEX(w, b); 658 if (z!=Py_None) { 659 PyErr_SetString(PyExc_ValueError, "complex modulo"); 660 return NULL; 661 } 662 PyFPE_START_PROTECT("complex_pow", return 0) 663 errno = 0; 664 exponent = b; 665 int_exponent = (long)exponent.real; 666 if (exponent.imag == 0. && exponent.real == int_exponent) 667 p = c_powi(a,int_exponent); 668 else 669 p = c_pow(a,exponent); 670 671 PyFPE_END_PROTECT(p) 672 Py_ADJUST_ERANGE2(p.real, p.imag); 673 if (errno == EDOM) { 674 PyErr_SetString(PyExc_ZeroDivisionError, 675 "0.0 to a negative or complex power"); 676 return NULL; 677 } 678 else if (errno == ERANGE) { 679 PyErr_SetString(PyExc_OverflowError, 680 "complex exponentiation"); 681 return NULL; 682 } 683 return PyComplex_FromCComplex(p); 684 } 685 686 static PyObject * 687 complex_int_div(PyObject *v, PyObject *w) 688 { 689 PyObject *t, *r; 690 Py_complex a, b; 691 TO_COMPLEX(v, a); 692 TO_COMPLEX(w, b); 693 if (PyErr_Warn(PyExc_DeprecationWarning, 694 "complex divmod(), // and % are deprecated") < 0) 695 return NULL; 696 697 t = complex_divmod(v, w); 698 if (t != NULL) { 699 r = PyTuple_GET_ITEM(t, 0); 700 Py_INCREF(r); 701 Py_DECREF(t); 702 return r; 703 } 704 return NULL; 664 705 } 665 706 … … 667 708 complex_neg(PyComplexObject *v) 668 709 { 669 670 671 672 710 Py_complex neg; 711 neg.real = -v->cval.real; 712 neg.imag = -v->cval.imag; 713 return PyComplex_FromCComplex(neg); 673 714 } 674 715 … … 676 717 complex_pos(PyComplexObject *v) 677 718 { 678 679 680 681 682 683 719 if (PyComplex_CheckExact(v)) { 720 Py_INCREF(v); 721 return (PyObject *)v; 722 } 723 else 724 return PyComplex_FromCComplex(v->cval); 684 725 } 685 726 … … 687 728 complex_abs(PyComplexObject *v) 688 729 { 689 690 691 692 693 694 695 696 697 698 699 700 730 double result; 731 732 PyFPE_START_PROTECT("complex_abs", return 0) 733 result = c_abs(v->cval); 734 PyFPE_END_PROTECT(result) 735 736 if (errno == ERANGE) { 737 PyErr_SetString(PyExc_OverflowError, 738 "absolute value too large"); 739 return NULL; 740 } 741 return PyFloat_FromDouble(result); 701 742 } 702 743 … … 704 745 complex_nonzero(PyComplexObject *v) 705 746 { 706 747 return v->cval.real != 0.0 || v->cval.imag != 0.0; 707 748 } 708 749 … … 710 751 complex_coerce(PyObject **pv, PyObject **pw) 711 752 { 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 753 Py_complex cval; 754 cval.imag = 0.; 755 if (PyInt_Check(*pw)) { 756 cval.real = (double)PyInt_AsLong(*pw); 757 *pw = PyComplex_FromCComplex(cval); 758 Py_INCREF(*pv); 759 return 0; 760 } 761 else if (PyLong_Check(*pw)) { 762 cval.real = PyLong_AsDouble(*pw); 763 if (cval.real == -1.0 && PyErr_Occurred()) 764 return -1; 765 *pw = PyComplex_FromCComplex(cval); 766 Py_INCREF(*pv); 767 return 0; 768 } 769 else if (PyFloat_Check(*pw)) { 770 cval.real = PyFloat_AsDouble(*pw); 771 *pw = PyComplex_FromCComplex(cval); 772 Py_INCREF(*pv); 773 return 0; 774 } 775 else if (PyComplex_Check(*pw)) { 776 Py_INCREF(*pv); 777 Py_INCREF(*pw); 778 return 0; 779 } 780 return 1; /* Can't do it */ 740 781 } 741 782 … … 743 784 complex_richcompare(PyObject *v, PyObject *w, int op) 744 785 { 745 int c; 746 Py_complex i, j; 747 PyObject *res; 748 749 c = PyNumber_CoerceEx(&v, &w); 750 if (c < 0) 751 return NULL; 752 if (c > 0) { 753 Py_INCREF(Py_NotImplemented); 754 return Py_NotImplemented; 755 } 756 /* Make sure both arguments are complex. */ 757 if (!(PyComplex_Check(v) && PyComplex_Check(w))) { 758 Py_DECREF(v); 759 Py_DECREF(w); 760 Py_INCREF(Py_NotImplemented); 761 return Py_NotImplemented; 762 } 763 764 i = ((PyComplexObject *)v)->cval; 765 j = ((PyComplexObject *)w)->cval; 766 Py_DECREF(v); 767 Py_DECREF(w); 768 769 if (op != Py_EQ && op != Py_NE) { 770 PyErr_SetString(PyExc_TypeError, 771 "no ordering relation is defined for complex numbers"); 772 return NULL; 773 } 774 775 if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ)) 776 res = Py_True; 777 else 778 res = Py_False; 779 780 Py_INCREF(res); 781 return res; 786 PyObject *res; 787 Py_complex i; 788 int equal; 789 790 if (op != Py_EQ && op != Py_NE) { 791 /* for backwards compatibility, comparisons with non-numbers return 792 * NotImplemented. Only comparisons with core numeric types raise 793 * TypeError. 794 */ 795 if (PyInt_Check(w) || PyLong_Check(w) || 796 PyFloat_Check(w) || PyComplex_Check(w)) { 797 PyErr_SetString(PyExc_TypeError, 798 "no ordering relation is defined " 799 "for complex numbers"); 800 return NULL; 801 } 802 goto Unimplemented; 803 } 804 805 assert(PyComplex_Check(v)); 806 TO_COMPLEX(v, i); 807 808 if (PyInt_Check(w) || PyLong_Check(w)) { 809 /* Check for 0.0 imaginary part first to avoid the rich 810 * comparison when possible. 811 */ 812 if (i.imag == 0.0) { 813 PyObject *j, *sub_res; 814 j = PyFloat_FromDouble(i.real); 815 if (j == NULL) 816 return NULL; 817 818 sub_res = PyObject_RichCompare(j, w, op); 819 Py_DECREF(j); 820 return sub_res; 821 } 822 else { 823 equal = 0; 824 } 825 } 826 else if (PyFloat_Check(w)) { 827 equal = (i.real == PyFloat_AsDouble(w) && i.imag == 0.0); 828 } 829 else if (PyComplex_Check(w)) { 830 Py_complex j; 831 832 TO_COMPLEX(w, j); 833 equal = (i.real == j.real && i.imag == j.imag); 834 } 835 else { 836 goto Unimplemented; 837 } 838 839 if (equal == (op == Py_EQ)) 840 res = Py_True; 841 else 842 res = Py_False; 843 844 Py_INCREF(res); 845 return res; 846 847 Unimplemented: 848 Py_INCREF(Py_NotImplemented); 849 return Py_NotImplemented; 782 850 } 783 851 … … 785 853 complex_int(PyObject *v) 786 854 { 787 788 789 855 PyErr_SetString(PyExc_TypeError, 856 "can't convert complex to int"); 857 return NULL; 790 858 } 791 859 … … 793 861 complex_long(PyObject *v) 794 862 { 795 796 797 863 PyErr_SetString(PyExc_TypeError, 864 "can't convert complex to long"); 865 return NULL; 798 866 } 799 867 … … 801 869 complex_float(PyObject *v) 802 870 { 803 804 805 871 PyErr_SetString(PyExc_TypeError, 872 "can't convert complex to float"); 873 return NULL; 806 874 } 807 875 … … 809 877 complex_conjugate(PyObject *self) 810 878 { 811 812 813 814 879 Py_complex c; 880 c = ((PyComplexObject *)self)->cval; 881 c.imag = -c.imag; 882 return PyComplex_FromCComplex(c); 815 883 } 816 884 … … 818 886 "complex.conjugate() -> complex\n" 819 887 "\n" 820 "Return sthe complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");888 "Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j."); 821 889 822 890 static PyObject * 823 891 complex_getnewargs(PyComplexObject *v) 824 892 { 825 Py_complex c = v->cval; 826 return Py_BuildValue("(dd)", c.real, c.imag); 893 Py_complex c = v->cval; 894 return Py_BuildValue("(dd)", c.real, c.imag); 895 } 896 897 PyDoc_STRVAR(complex__format__doc, 898 "complex.__format__() -> str\n" 899 "\n" 900 "Convert to a string according to format_spec."); 901 902 static PyObject * 903 complex__format__(PyObject* self, PyObject* args) 904 { 905 PyObject *format_spec; 906 907 if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) 908 return NULL; 909 if (PyBytes_Check(format_spec)) 910 return _PyComplex_FormatAdvanced(self, 911 PyBytes_AS_STRING(format_spec), 912 PyBytes_GET_SIZE(format_spec)); 913 if (PyUnicode_Check(format_spec)) { 914 /* Convert format_spec to a str */ 915 PyObject *result; 916 PyObject *str_spec = PyObject_Str(format_spec); 917 918 if (str_spec == NULL) 919 return NULL; 920 921 result = _PyComplex_FormatAdvanced(self, 922 PyBytes_AS_STRING(str_spec), 923 PyBytes_GET_SIZE(str_spec)); 924 925 Py_DECREF(str_spec); 926 return result; 927 } 928 PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode"); 929 return NULL; 827 930 } 828 931 … … 831 934 complex_is_finite(PyObject *self) 832 935 { 833 834 835 836 936 Py_complex c; 937 c = ((PyComplexObject *)self)->cval; 938 return PyBool_FromLong((long)(Py_IS_FINITE(c.real) && 939 Py_IS_FINITE(c.imag))); 837 940 } 838 941 … … 844 947 845 948 static PyMethodDef complex_methods[] = { 846 {"conjugate", (PyCFunction)complex_conjugate,METH_NOARGS,847 949 {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS, 950 complex_conjugate_doc}, 848 951 #if 0 849 {"is_finite", (PyCFunction)complex_is_finite,METH_NOARGS,850 952 {"is_finite", (PyCFunction)complex_is_finite, METH_NOARGS, 953 complex_is_finite_doc}, 851 954 #endif 852 {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS}, 853 {NULL, NULL} /* sentinel */ 955 {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS}, 956 {"__format__", (PyCFunction)complex__format__, 957 METH_VARARGS, complex__format__doc}, 958 {NULL, NULL} /* sentinel */ 854 959 }; 855 960 856 961 static PyMemberDef complex_members[] = { 857 858 859 860 861 962 {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY, 963 "the real part of a complex number"}, 964 {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY, 965 "the imaginary part of a complex number"}, 966 {0}, 862 967 }; 863 968 … … 865 970 complex_subtype_from_string(PyTypeObject *type, PyObject *v) 866 971 { 867 const char *s, *start; 868 char *end; 869 double x=0.0, y=0.0, z; 870 int got_re=0, got_im=0, got_bracket=0, done=0; 871 int digit_or_dot; 872 int sw_error=0; 873 int sign; 874 char buffer[256]; /* For errors */ 972 const char *s, *start; 973 char *end; 974 double x=0.0, y=0.0, z; 975 int got_bracket=0; 875 976 #ifdef Py_USING_UNICODE 876 char s_buffer[256];977 char *s_buffer = NULL; 877 978 #endif 878 879 880 881 882 883 979 Py_ssize_t len; 980 981 if (PyString_Check(v)) { 982 s = PyString_AS_STRING(v); 983 len = PyString_GET_SIZE(v); 984 } 884 985 #ifdef Py_USING_UNICODE 885 else if (PyUnicode_Check(v)) { 886 if (PyUnicode_GET_SIZE(v) >= (Py_ssize_t)sizeof(s_buffer)) { 887 PyErr_SetString(PyExc_ValueError, 888 "complex() literal too large to convert"); 889 return NULL; 890 } 891 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v), 892 PyUnicode_GET_SIZE(v), 893 s_buffer, 894 NULL)) 895 return NULL; 896 s = s_buffer; 897 len = strlen(s); 898 } 986 else if (PyUnicode_Check(v)) { 987 s_buffer = (char *)PyMem_MALLOC(PyUnicode_GET_SIZE(v)+1); 988 if (s_buffer == NULL) 989 return PyErr_NoMemory(); 990 if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v), 991 PyUnicode_GET_SIZE(v), 992 s_buffer, 993 NULL)) 994 goto error; 995 s = s_buffer; 996 len = strlen(s); 997 } 899 998 #endif 900 else if (PyObject_AsCharBuffer(v, &s, &len)) { 901 PyErr_SetString(PyExc_TypeError, 902 "complex() arg is not a string"); 903 return NULL; 904 } 905 906 /* position on first nonblank */ 907 start = s; 908 while (*s && isspace(Py_CHARMASK(*s))) 909 s++; 910 if (s[0] == '\0') { 911 PyErr_SetString(PyExc_ValueError, 912 "complex() arg is an empty string"); 913 return NULL; 914 } 915 if (s[0] == '(') { 916 /* Skip over possible bracket from repr(). */ 917 got_bracket = 1; 918 s++; 919 while (*s && isspace(Py_CHARMASK(*s))) 920 s++; 921 } 922 923 z = -1.0; 924 sign = 1; 925 do { 926 927 switch (*s) { 928 929 case '\0': 930 if (s-start != len) { 931 PyErr_SetString( 932 PyExc_ValueError, 933 "complex() arg contains a null byte"); 934 return NULL; 935 } 936 if(!done) sw_error=1; 937 break; 938 939 case ')': 940 if (!got_bracket || !(got_re || got_im)) { 941 sw_error=1; 942 break; 943 } 944 got_bracket=0; 945 done=1; 946 s++; 947 while (*s && isspace(Py_CHARMASK(*s))) 948 s++; 949 if (*s) sw_error=1; 950 break; 951 952 case '-': 953 sign = -1; 954 /* Fallthrough */ 955 case '+': 956 if (done) sw_error=1; 957 s++; 958 if ( *s=='\0'||*s=='+'||*s=='-'||*s==')'|| 959 isspace(Py_CHARMASK(*s)) ) sw_error=1; 960 break; 961 962 case 'J': 963 case 'j': 964 if (got_im || done) { 965 sw_error = 1; 966 break; 967 } 968 if (z<0.0) { 969 y=sign; 970 } 971 else{ 972 y=sign*z; 973 } 974 got_im=1; 975 s++; 976 if (*s!='+' && *s!='-' ) 977 done=1; 978 break; 979 980 default: 981 if (isspace(Py_CHARMASK(*s))) { 982 while (*s && isspace(Py_CHARMASK(*s))) 983 s++; 984 if (*s && *s != ')') 985 sw_error=1; 986 else 987 done = 1; 988 break; 989 } 990 digit_or_dot = 991 (*s=='.' || isdigit(Py_CHARMASK(*s))); 992 if (done||!digit_or_dot) { 993 sw_error=1; 994 break; 995 } 996 errno = 0; 997 PyFPE_START_PROTECT("strtod", return 0) 998 z = PyOS_ascii_strtod(s, &end) ; 999 PyFPE_END_PROTECT(z) 1000 if (errno == ERANGE && fabs(z) >= 1.0) { 1001 PyOS_snprintf(buffer, sizeof(buffer), 1002 "float() out of range: %.150s", s); 1003 PyErr_SetString( 1004 PyExc_ValueError, 1005 buffer); 1006 return NULL; 1007 } 1008 s=end; 1009 if (*s=='J' || *s=='j') { 1010 1011 break; 1012 } 1013 if (got_re) { 1014 sw_error=1; 1015 break; 1016 } 1017 1018 /* accept a real part */ 1019 x=sign*z; 1020 got_re=1; 1021 if (got_im) done=1; 1022 z = -1.0; 1023 sign = 1; 1024 break; 1025 1026 } /* end of switch */ 1027 1028 } while (s - start < len && !sw_error); 1029 1030 if (sw_error || got_bracket) { 1031 PyErr_SetString(PyExc_ValueError, 1032 "complex() arg is a malformed string"); 1033 return NULL; 1034 } 1035 1036 return complex_subtype_from_doubles(type, x, y); 999 else if (PyObject_AsCharBuffer(v, &s, &len)) { 1000 PyErr_SetString(PyExc_TypeError, 1001 "complex() arg is not a string"); 1002 return NULL; 1003 } 1004 1005 /* position on first nonblank */ 1006 start = s; 1007 while (Py_ISSPACE(*s)) 1008 s++; 1009 if (*s == '(') { 1010 /* Skip over possible bracket from repr(). */ 1011 got_bracket = 1; 1012 s++; 1013 while (Py_ISSPACE(*s)) 1014 s++; 1015 } 1016 1017 /* a valid complex string usually takes one of the three forms: 1018 1019 <float> - real part only 1020 <float>j - imaginary part only 1021 <float><signed-float>j - real and imaginary parts 1022 1023 where <float> represents any numeric string that's accepted by the 1024 float constructor (including 'nan', 'inf', 'infinity', etc.), and 1025 <signed-float> is any string of the form <float> whose first 1026 character is '+' or '-'. 1027 1028 For backwards compatibility, the extra forms 1029 1030 <float><sign>j 1031 <sign>j 1032 j 1033 1034 are also accepted, though support for these forms may be removed from 1035 a future version of Python. 1036 */ 1037 1038 /* first look for forms starting with <float> */ 1039 z = PyOS_string_to_double(s, &end, NULL); 1040 if (z == -1.0 && PyErr_Occurred()) { 1041 if (PyErr_ExceptionMatches(PyExc_ValueError)) 1042 PyErr_Clear(); 1043 else 1044 goto error; 1045 } 1046 if (end != s) { 1047 /* all 4 forms starting with <float> land here */ 1048 s = end; 1049 if (*s == '+' || *s == '-') { 1050 /* <float><signed-float>j | <float><sign>j */ 1051 x = z; 1052 y = PyOS_string_to_double(s, &end, NULL); 1053 if (y == -1.0 && PyErr_Occurred()) { 1054 if (PyErr_ExceptionMatches(PyExc_ValueError)) 1055 PyErr_Clear(); 1056 else 1057 goto error; 1058 } 1059 if (end != s) 1060 /* <float><signed-float>j */ 1061 s = end; 1062 else { 1063 /* <float><sign>j */ 1064 y = *s == '+' ? 1.0 : -1.0; 1065 s++; 1066 } 1067 if (!(*s == 'j' || *s == 'J')) 1068 goto parse_error; 1069 s++; 1070 } 1071 else if (*s == 'j' || *s == 'J') { 1072 /* <float>j */ 1073 s++; 1074 y = z; 1075 } 1076 else 1077 /* <float> */ 1078 x = z; 1079 } 1080 else { 1081 /* not starting with <float>; must be <sign>j or j */ 1082 if (*s == '+' || *s == '-') { 1083 /* <sign>j */ 1084 y = *s == '+' ? 1.0 : -1.0; 1085 s++; 1086 } 1087 else 1088 /* j */ 1089 y = 1.0; 1090 if (!(*s == 'j' || *s == 'J')) 1091 goto parse_error; 1092 s++; 1093 } 1094 1095 /* trailing whitespace and closing bracket */ 1096 while (Py_ISSPACE(*s)) 1097 s++; 1098 if (got_bracket) { 1099 /* if there was an opening parenthesis, then the corresponding 1100 closing parenthesis should be right here */ 1101 if (*s != ')') 1102 goto parse_error; 1103 s++; 1104 while (Py_ISSPACE(*s)) 1105 s++; 1106 } 1107 1108 /* we should now be at the end of the string */ 1109 if (s-start != len) 1110 goto parse_error; 1111 1112 1113 #ifdef Py_USING_UNICODE 1114 if (s_buffer) 1115 PyMem_FREE(s_buffer); 1116 #endif 1117 return complex_subtype_from_doubles(type, x, y); 1118 1119 parse_error: 1120 PyErr_SetString(PyExc_ValueError, 1121 "complex() arg is a malformed string"); 1122 error: 1123 #ifdef Py_USING_UNICODE 1124 if (s_buffer) 1125 PyMem_FREE(s_buffer); 1126 #endif 1127 return NULL; 1037 1128 } 1038 1129 … … 1040 1131 complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 1041 1132 { 1042 PyObject *r, *i, *tmp, *f; 1043 PyNumberMethods *nbr, *nbi = NULL; 1044 Py_complex cr, ci; 1045 int own_r = 0; 1046 int cr_is_complex = 0; 1047 int ci_is_complex = 0; 1048 static PyObject *complexstr; 1049 static char *kwlist[] = {"real", "imag", 0}; 1050 1051 r = Py_False; 1052 i = NULL; 1053 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO:complex", kwlist, 1054 &r, &i)) 1055 return NULL; 1056 1057 /* Special-case for a single argument when type(arg) is complex. */ 1058 if (PyComplex_CheckExact(r) && i == NULL && 1059 type == &PyComplex_Type) { 1060 /* Note that we can't know whether it's safe to return 1061 a complex *subclass* instance as-is, hence the restriction 1062 to exact complexes here. If either the input or the 1063 output is a complex subclass, it will be handled below 1064 as a non-orthogonal vector. */ 1065 Py_INCREF(r); 1066 return r; 1067 } 1068 if (PyString_Check(r) || PyUnicode_Check(r)) { 1069 if (i != NULL) { 1070 PyErr_SetString(PyExc_TypeError, 1071 "complex() can't take second arg" 1072 " if first is a string"); 1073 return NULL; 1074 } 1075 return complex_subtype_from_string(type, r); 1076 } 1077 if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) { 1078 PyErr_SetString(PyExc_TypeError, 1079 "complex() second arg can't be a string"); 1080 return NULL; 1081 } 1082 1083 /* XXX Hack to support classes with __complex__ method */ 1084 if (complexstr == NULL) { 1085 complexstr = PyString_InternFromString("__complex__"); 1086 if (complexstr == NULL) 1087 return NULL; 1088 } 1089 f = PyObject_GetAttr(r, complexstr); 1090 if (f == NULL) 1091 PyErr_Clear(); 1092 else { 1093 PyObject *args = PyTuple_New(0); 1094 if (args == NULL) 1095 return NULL; 1096 r = PyEval_CallObject(f, args); 1097 Py_DECREF(args); 1098 Py_DECREF(f); 1099 if (r == NULL) 1100 return NULL; 1101 own_r = 1; 1102 } 1103 nbr = r->ob_type->tp_as_number; 1104 if (i != NULL) 1105 nbi = i->ob_type->tp_as_number; 1106 if (nbr == NULL || nbr->nb_float == NULL || 1107 ((i != NULL) && (nbi == NULL || nbi->nb_float == NULL))) { 1108 PyErr_SetString(PyExc_TypeError, 1109 "complex() argument must be a string or a number"); 1110 if (own_r) { 1111 Py_DECREF(r); 1112 } 1113 return NULL; 1114 } 1115 1116 /* If we get this far, then the "real" and "imag" parts should 1117 both be treated as numbers, and the constructor should return a 1118 complex number equal to (real + imag*1j). 1119 1120 Note that we do NOT assume the input to already be in canonical 1121 form; the "real" and "imag" parts might themselves be complex 1122 numbers, which slightly complicates the code below. */ 1123 if (PyComplex_Check(r)) { 1124 /* Note that if r is of a complex subtype, we're only 1125 retaining its real & imag parts here, and the return 1126 value is (properly) of the builtin complex type. */ 1127 cr = ((PyComplexObject*)r)->cval; 1128 cr_is_complex = 1; 1129 if (own_r) { 1130 Py_DECREF(r); 1131 } 1132 } 1133 else { 1134 /* The "real" part really is entirely real, and contributes 1135 nothing in the imaginary direction. 1136 Just treat it as a double. */ 1137 tmp = PyNumber_Float(r); 1138 if (own_r) { 1139 /* r was a newly created complex number, rather 1140 than the original "real" argument. */ 1141 Py_DECREF(r); 1142 } 1143 if (tmp == NULL) 1144 return NULL; 1145 if (!PyFloat_Check(tmp)) { 1146 PyErr_SetString(PyExc_TypeError, 1147 "float(r) didn't return a float"); 1148 Py_DECREF(tmp); 1149 return NULL; 1150 } 1151 cr.real = PyFloat_AsDouble(tmp); 1152 cr.imag = 0.0; /* Shut up compiler warning */ 1153 Py_DECREF(tmp); 1154 } 1155 if (i == NULL) { 1156 ci.real = 0.0; 1157 } 1158 else if (PyComplex_Check(i)) { 1159 ci = ((PyComplexObject*)i)->cval; 1160 ci_is_complex = 1; 1161 } else { 1162 /* The "imag" part really is entirely imaginary, and 1163 contributes nothing in the real direction. 1164 Just treat it as a double. */ 1165 tmp = (*nbi->nb_float)(i); 1166 if (tmp == NULL) 1167 return NULL; 1168 ci.real = PyFloat_AsDouble(tmp); 1169 Py_DECREF(tmp); 1170 } 1171 /* If the input was in canonical form, then the "real" and "imag" 1172 parts are real numbers, so that ci.imag and cr.imag are zero. 1173 We need this correction in case they were not real numbers. */ 1174 1175 if (ci_is_complex) { 1176 cr.real -= ci.imag; 1177 } 1178 if (cr_is_complex) { 1179 ci.real += cr.imag; 1180 } 1181 return complex_subtype_from_doubles(type, cr.real, ci.real); 1133 PyObject *r, *i, *tmp; 1134 PyNumberMethods *nbr, *nbi = NULL; 1135 Py_complex cr, ci; 1136 int own_r = 0; 1137 int cr_is_complex = 0; 1138 int ci_is_complex = 0; 1139 static char *kwlist[] = {"real", "imag", 0}; 1140 1141 r = Py_False; 1142 i = NULL; 1143 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO:complex", kwlist, 1144 &r, &i)) 1145 return NULL; 1146 1147 /* Special-case for a single argument when type(arg) is complex. */ 1148 if (PyComplex_CheckExact(r) && i == NULL && 1149 type == &PyComplex_Type) { 1150 /* Note that we can't know whether it's safe to return 1151 a complex *subclass* instance as-is, hence the restriction 1152 to exact complexes here. If either the input or the 1153 output is a complex subclass, it will be handled below 1154 as a non-orthogonal vector. */ 1155 Py_INCREF(r); 1156 return r; 1157 } 1158 if (PyString_Check(r) || PyUnicode_Check(r)) { 1159 if (i != NULL) { 1160 PyErr_SetString(PyExc_TypeError, 1161 "complex() can't take second arg" 1162 " if first is a string"); 1163 return NULL; 1164 } 1165 return complex_subtype_from_string(type, r); 1166 } 1167 if (i != NULL && (PyString_Check(i) || PyUnicode_Check(i))) { 1168 PyErr_SetString(PyExc_TypeError, 1169 "complex() second arg can't be a string"); 1170 return NULL; 1171 } 1172 1173 tmp = try_complex_special_method(r); 1174 if (tmp) { 1175 r = tmp; 1176 own_r = 1; 1177 } 1178 else if (PyErr_Occurred()) { 1179 return NULL; 1180 } 1181 1182 nbr = r->ob_type->tp_as_number; 1183 if (i != NULL) 1184 nbi = i->ob_type->tp_as_number; 1185 if (nbr == NULL || nbr->nb_float == NULL || 1186 ((i != NULL) && (nbi == NULL || nbi->nb_float == NULL))) { 1187 PyErr_SetString(PyExc_TypeError, 1188 "complex() argument must be a string or a number"); 1189 if (own_r) { 1190 Py_DECREF(r); 1191 } 1192 return NULL; 1193 } 1194 1195 /* If we get this far, then the "real" and "imag" parts should 1196 both be treated as numbers, and the constructor should return a 1197 complex number equal to (real + imag*1j). 1198 1199 Note that we do NOT assume the input to already be in canonical 1200 form; the "real" and "imag" parts might themselves be complex 1201 numbers, which slightly complicates the code below. */ 1202 if (PyComplex_Check(r)) { 1203 /* Note that if r is of a complex subtype, we're only 1204 retaining its real & imag parts here, and the return 1205 value is (properly) of the builtin complex type. */ 1206 cr = ((PyComplexObject*)r)->cval; 1207 cr_is_complex = 1; 1208 if (own_r) { 1209 Py_DECREF(r); 1210 } 1211 } 1212 else { 1213 /* The "real" part really is entirely real, and contributes 1214 nothing in the imaginary direction. 1215 Just treat it as a double. */ 1216 tmp = PyNumber_Float(r); 1217 if (own_r) { 1218 /* r was a newly created complex number, rather 1219 than the original "real" argument. */ 1220 Py_DECREF(r); 1221 } 1222 if (tmp == NULL) 1223 return NULL; 1224 if (!PyFloat_Check(tmp)) { 1225 PyErr_SetString(PyExc_TypeError, 1226 "float(r) didn't return a float"); 1227 Py_DECREF(tmp); 1228 return NULL; 1229 } 1230 cr.real = PyFloat_AsDouble(tmp); 1231 cr.imag = 0.0; /* Shut up compiler warning */ 1232 Py_DECREF(tmp); 1233 } 1234 if (i == NULL) { 1235 ci.real = 0.0; 1236 } 1237 else if (PyComplex_Check(i)) { 1238 ci = ((PyComplexObject*)i)->cval; 1239 ci_is_complex = 1; 1240 } else { 1241 /* The "imag" part really is entirely imaginary, and 1242 contributes nothing in the real direction. 1243 Just treat it as a double. */ 1244 tmp = (*nbi->nb_float)(i); 1245 if (tmp == NULL) 1246 return NULL; 1247 ci.real = PyFloat_AsDouble(tmp); 1248 Py_DECREF(tmp); 1249 } 1250 /* If the input was in canonical form, then the "real" and "imag" 1251 parts are real numbers, so that ci.imag and cr.imag are zero. 1252 We need this correction in case they were not real numbers. */ 1253 1254 if (ci_is_complex) { 1255 cr.real -= ci.imag; 1256 } 1257 if (cr_is_complex) { 1258 ci.real += cr.imag; 1259 } 1260 return complex_subtype_from_doubles(type, cr.real, ci.real); 1182 1261 } 1183 1262 … … 1189 1268 1190 1269 static PyNumberMethods complex_as_number = { 1191 (binaryfunc)complex_add,/* nb_add */1192 (binaryfunc)complex_sub,/* nb_subtract */1193 (binaryfunc)complex_mul,/* nb_multiply */1194 (binaryfunc)complex_classic_div,/* nb_divide */1195 (binaryfunc)complex_remainder,/* nb_remainder */1196 (binaryfunc)complex_divmod,/* nb_divmod */1197 (ternaryfunc)complex_pow,/* nb_power */1198 (unaryfunc)complex_neg,/* nb_negative */1199 (unaryfunc)complex_pos,/* nb_positive */1200 (unaryfunc)complex_abs,/* nb_absolute */1201 (inquiry)complex_nonzero,/* nb_nonzero */1202 0,/* nb_invert */1203 0,/* nb_lshift */1204 0,/* nb_rshift */1205 0,/* nb_and */1206 0,/* nb_xor */1207 0,/* nb_or */1208 complex_coerce,/* nb_coerce */1209 complex_int,/* nb_int */1210 complex_long,/* nb_long */1211 complex_float,/* nb_float */1212 0,/* nb_oct */1213 0,/* nb_hex */1214 0,/* nb_inplace_add */1215 0,/* nb_inplace_subtract */1216 0,/* nb_inplace_multiply*/1217 0,/* nb_inplace_divide */1218 0,/* nb_inplace_remainder */1219 0,/* nb_inplace_power */1220 0,/* nb_inplace_lshift */1221 0,/* nb_inplace_rshift */1222 0,/* nb_inplace_and */1223 0,/* nb_inplace_xor */1224 0,/* nb_inplace_or */1225 (binaryfunc)complex_int_div,/* nb_floor_divide */1226 (binaryfunc)complex_div,/* nb_true_divide */1227 0,/* nb_inplace_floor_divide */1228 0,/* nb_inplace_true_divide */1270 (binaryfunc)complex_add, /* nb_add */ 1271 (binaryfunc)complex_sub, /* nb_subtract */ 1272 (binaryfunc)complex_mul, /* nb_multiply */ 1273 (binaryfunc)complex_classic_div, /* nb_divide */ 1274 (binaryfunc)complex_remainder, /* nb_remainder */ 1275 (binaryfunc)complex_divmod, /* nb_divmod */ 1276 (ternaryfunc)complex_pow, /* nb_power */ 1277 (unaryfunc)complex_neg, /* nb_negative */ 1278 (unaryfunc)complex_pos, /* nb_positive */ 1279 (unaryfunc)complex_abs, /* nb_absolute */ 1280 (inquiry)complex_nonzero, /* nb_nonzero */ 1281 0, /* nb_invert */ 1282 0, /* nb_lshift */ 1283 0, /* nb_rshift */ 1284 0, /* nb_and */ 1285 0, /* nb_xor */ 1286 0, /* nb_or */ 1287 complex_coerce, /* nb_coerce */ 1288 complex_int, /* nb_int */ 1289 complex_long, /* nb_long */ 1290 complex_float, /* nb_float */ 1291 0, /* nb_oct */ 1292 0, /* nb_hex */ 1293 0, /* nb_inplace_add */ 1294 0, /* nb_inplace_subtract */ 1295 0, /* nb_inplace_multiply*/ 1296 0, /* nb_inplace_divide */ 1297 0, /* nb_inplace_remainder */ 1298 0, /* nb_inplace_power */ 1299 0, /* nb_inplace_lshift */ 1300 0, /* nb_inplace_rshift */ 1301 0, /* nb_inplace_and */ 1302 0, /* nb_inplace_xor */ 1303 0, /* nb_inplace_or */ 1304 (binaryfunc)complex_int_div, /* nb_floor_divide */ 1305 (binaryfunc)complex_div, /* nb_true_divide */ 1306 0, /* nb_inplace_floor_divide */ 1307 0, /* nb_inplace_true_divide */ 1229 1308 }; 1230 1309 1231 1310 PyTypeObject PyComplex_Type = { 1232 PyVarObject_HEAD_INIT(&PyType_Type, 0) 1233 "complex", 1234 sizeof(PyComplexObject), 1235 0, 1236 complex_dealloc, /* tp_dealloc */ 1237 (printfunc)complex_print, /* tp_print */ 1238 0, /* tp_getattr */ 1239 0, /* tp_setattr */ 1240 0, /* tp_compare */ 1241 (reprfunc)complex_repr, /* tp_repr */ 1242 &complex_as_number, /* tp_as_number */ 1243 0, /* tp_as_sequence */ 1244 0, /* tp_as_mapping */ 1245 (hashfunc)complex_hash, /* tp_hash */ 1246 0, /* tp_call */ 1247 (reprfunc)complex_str, /* tp_str */ 1248 PyObject_GenericGetAttr, /* tp_getattro */ 1249 0, /* tp_setattro */ 1250 0, /* tp_as_buffer */ 1251 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 1252 complex_doc, /* tp_doc */ 1253 0, /* tp_traverse */ 1254 0, /* tp_clear */ 1255 complex_richcompare, /* tp_richcompare */ 1256 0, /* tp_weaklistoffset */ 1257 0, /* tp_iter */ 1258 0, /* tp_iternext */ 1259 complex_methods, /* tp_methods */ 1260 complex_members, /* tp_members */ 1261 0, /* tp_getset */ 1262 0, /* tp_base */ 1263 0, /* tp_dict */ 1264 0, /* tp_descr_get */ 1265 0, /* tp_descr_set */ 1266 0, /* tp_dictoffset */ 1267 0, /* tp_init */ 1268 PyType_GenericAlloc, /* tp_alloc */ 1269 complex_new, /* tp_new */ 1270 PyObject_Del, /* tp_free */ 1311 PyVarObject_HEAD_INIT(&PyType_Type, 0) 1312 "complex", 1313 sizeof(PyComplexObject), 1314 0, 1315 complex_dealloc, /* tp_dealloc */ 1316 (printfunc)complex_print, /* tp_print */ 1317 0, /* tp_getattr */ 1318 0, /* tp_setattr */ 1319 0, /* tp_compare */ 1320 (reprfunc)complex_repr, /* tp_repr */ 1321 &complex_as_number, /* tp_as_number */ 1322 0, /* tp_as_sequence */ 1323 0, /* tp_as_mapping */ 1324 (hashfunc)complex_hash, /* tp_hash */ 1325 0, /* tp_call */ 1326 (reprfunc)complex_str, /* tp_str */ 1327 PyObject_GenericGetAttr, /* tp_getattro */ 1328 0, /* tp_setattro */ 1329 0, /* tp_as_buffer */ 1330 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | 1331 Py_TPFLAGS_BASETYPE, /* tp_flags */ 1332 complex_doc, /* tp_doc */ 1333 0, /* tp_traverse */ 1334 0, /* tp_clear */ 1335 complex_richcompare, /* tp_richcompare */ 1336 0, /* tp_weaklistoffset */ 1337 0, /* tp_iter */ 1338 0, /* tp_iternext */ 1339 complex_methods, /* tp_methods */ 1340 complex_members, /* tp_members */ 1341 0, /* tp_getset */ 1342 0, /* tp_base */ 1343 0, /* tp_dict */ 1344 0, /* tp_descr_get */ 1345 0, /* tp_descr_set */ 1346 0, /* tp_dictoffset */ 1347 0, /* tp_init */ 1348 PyType_GenericAlloc, /* tp_alloc */ 1349 complex_new, /* tp_new */ 1350 PyObject_Del, /* tp_free */ 1271 1351 }; 1272 1352
Note:
See TracChangeset
for help on using the changeset viewer.