Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • python/vendor/current/Objects/complexobject.c

    r2 r388  
    88#include "Python.h"
    99#include "structmember.h"
    10 
    11 #ifdef HAVE_IEEEFP_H
    12 #include <ieeefp.h>
    13 #endif
    1410
    1511#ifndef WITHOUT_COMPLEX
     
    2824*/
    2925
    30 #define PREC_REPR       17
    31 #define PREC_STR        12
     26#define PREC_REPR       17
     27#define PREC_STR        12
    3228
    3329/* elementary operations on complex numbers */
     
    3834c_sum(Py_complex a, Py_complex b)
    3935{
    40         Py_complex r;
    41         r.real = a.real + b.real;
    42         r.imag = a.imag + b.imag;
    43         return r;
     36    Py_complex r;
     37    r.real = a.real + b.real;
     38    r.imag = a.imag + b.imag;
     39    return r;
    4440}
    4541
     
    4743c_diff(Py_complex a, Py_complex b)
    4844{
    49         Py_complex r;
    50         r.real = a.real - b.real;
    51         r.imag = a.imag - b.imag;
    52         return r;
     45    Py_complex r;
     46    r.real = a.real - b.real;
     47    r.imag = a.imag - b.imag;
     48    return r;
    5349}
    5450
     
    5652c_neg(Py_complex a)
    5753{
    58         Py_complex r;
    59         r.real = -a.real;
    60         r.imag = -a.imag;
    61         return r;
     54    Py_complex r;
     55    r.real = -a.real;
     56    r.imag = -a.imag;
     57    return r;
    6258}
    6359
     
    6561c_prod(Py_complex a, Py_complex b)
    6662{
    67         Py_complex r;
    68         r.real = a.real*b.real - a.imag*b.imag;
    69         r.imag = a.real*b.imag + a.imag*b.real;
    70         return r;
     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;
    7167}
    7268
     
    7470c_quot(Py_complex a, Py_complex b)
    7571{
    76         /******************************************************************
    77         This was the original algorithm.  It's grossly prone to spurious
    78         overflow and underflow errors.  It also merrily divides by 0 despite
    79         checking for that(!).  The code still serves a doc purpose here, as
    80         the algorithm following is a simple by-cases transformation of this
    81         one:
    82 
    83         Py_complex r;
    84         double d = b.real*b.real + b.imag*b.imag;
    85         if (d == 0.)
    86                 errno = EDOM;
    87         r.real = (a.real*b.real + a.imag*b.imag)/d;
    88         r.imag = (a.imag*b.real - a.real*b.imag)/d;
    89         return r;
    90         ******************************************************************/
    91 
    92         /* This algorithm is better, and is pretty obvious:  first divide the
    93         * numerators and denominator by whichever of {b.real, b.imag} has
    94         * larger magnitude.  The earliest reference I found was to CACM
    95         * Algorithm 116 (Complex Division, Robert L. Smith, Stanford
    96         * University).  As usual, though, we're still ignoring all IEEE
    97         * endcases.
    98         */
    99          Py_complex r;  /* the result */
    100          const double abs_breal = b.real < 0 ? -b.real : b.real;
    101         const double abs_bimag = b.imag < 0 ? -b.imag : b.imag;
    102 
    103         if (abs_breal >= abs_bimag) {
    104                 /* divide tops and bottom by b.real */
    105                 if (abs_breal == 0.0) {
    106                         errno = EDOM;
    107                         r.real = r.imag = 0.0;
    108                 }
    109                 else {
    110                         const double ratio = b.imag / b.real;
    111                         const double denom = b.real + b.imag * ratio;
    112                         r.real = (a.real + a.imag * ratio) / denom;
    113                         r.imag = (a.imag - a.real * ratio) / denom;
    114                 }
    115         }
    116         else {
    117                 /* divide tops and bottom by b.imag */
    118                 const double ratio = b.real / b.imag;
    119                 const double denom = b.real * ratio + b.imag;
    120                 assert(b.imag != 0.0);
    121                 r.real = (a.real * ratio + a.imag) / denom;
    122                 r.imag = (a.imag * ratio - a.real) / denom;
    123         }
    124         return r;
     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;
    125121}
    126122
     
    128124c_pow(Py_complex a, Py_complex b)
    129125{
    130         Py_complex r;
    131         double vabs,len,at,phase;
    132         if (b.real == 0. && b.imag == 0.) {
    133                 r.real = 1.;
    134                 r.imag = 0.;
    135         }
    136         else if (a.real == 0. && a.imag == 0.) {
    137                 if (b.imag != 0. || b.real < 0.)
    138                         errno = EDOM;
    139                 r.real = 0.;
    140                 r.imag = 0.;
    141         }
    142         else {
    143                 vabs = hypot(a.real,a.imag);
    144                 len = pow(vabs,b.real);
    145                 at = atan2(a.imag, a.real);
    146                 phase = at*b.real;
    147                 if (b.imag != 0.0) {
    148                         len /= exp(at*b.imag);
    149                         phase += b.imag*log(vabs);
    150                 }
    151                 r.real = len*cos(phase);
    152                 r.imag = len*sin(phase);
    153         }
    154         return r;
     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;
    155151}
    156152
     
    158154c_powu(Py_complex x, long n)
    159155{
    160         Py_complex r, p;
    161         long mask = 1;
    162         r = c_1;
    163         p = x;
    164         while (mask > 0 && n >= mask) {
    165                 if (n & mask)
    166                         r = c_prod(r,p);
    167                 mask <<= 1;
    168                 p = c_prod(p,p);
    169         }
    170         return r;
     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;
    171167}
    172168
     
    174170c_powi(Py_complex x, long n)
    175171{
    176         Py_complex cn;
    177 
    178         if (n > 100 || n < -100) {
    179                 cn.real = (double) n;
    180                 cn.imag = 0.;
    181                 return c_pow(x,cn);
    182         }
    183         else if (n > 0)
    184                 return c_powu(x,n);
    185         else
    186                 return c_quot(c_1,c_powu(x,-n));
     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));
    187183
    188184}
     
    191187c_abs(Py_complex z)
    192188{
    193         /* sets errno = ERANGE on overflow;  otherwise errno = 0 */
    194         double result;
    195 
    196         if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
    197                 /* C99 rules: if either the real or the imaginary part is an
    198                    infinity, return infinity, even if the other part is a
    199                    NaN. */
    200                 if (Py_IS_INFINITY(z.real)) {
    201                         result = fabs(z.real);
    202                         errno = 0;
    203                         return result;
    204                 }
    205                 if (Py_IS_INFINITY(z.imag)) {
    206                         result = fabs(z.imag);
    207                         errno = 0;
    208                         return result;
    209                 }
    210                 /* either the real or imaginary part is a NaN,
    211                    and neither is infinite. Result should be NaN. */
    212                 return Py_NAN;
    213         }
    214         result = hypot(z.real, z.imag);
    215         if (!Py_IS_FINITE(result))
    216                 errno = ERANGE;
    217         else
    218                 errno = 0;
    219         return result;
     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;
    220216}
    221217
     
    223219complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)
    224220{
    225         PyObject *op;
    226 
    227         op = type->tp_alloc(type, 0);
    228         if (op != NULL)
    229                 ((PyComplexObject *)op)->cval = cval;
    230         return op;
     221    PyObject *op;
     222
     223    op = type->tp_alloc(type, 0);
     224    if (op != NULL)
     225        ((PyComplexObject *)op)->cval = cval;
     226    return op;
    231227}
    232228
     
    234230PyComplex_FromCComplex(Py_complex cval)
    235231{
    236         register PyComplexObject *op;
    237 
    238         /* Inline PyObject_New */
    239         op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
    240         if (op == NULL)
    241                 return PyErr_NoMemory();
    242         PyObject_INIT(op, &PyComplex_Type);
    243         op->cval = cval;
    244         return (PyObject *) op;
     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;
    245241}
    246242
     
    248244complex_subtype_from_doubles(PyTypeObject *type, double real, double imag)
    249245{
    250         Py_complex c;
    251         c.real = real;
    252         c.imag = imag;
    253         return complex_subtype_from_c_complex(type, c);
     246    Py_complex c;
     247    c.real = real;
     248    c.imag = imag;
     249    return complex_subtype_from_c_complex(type, c);
    254250}
    255251
     
    257253PyComplex_FromDoubles(double real, double imag)
    258254{
    259         Py_complex c;
    260         c.real = real;
    261         c.imag = imag;
    262         return PyComplex_FromCComplex(c);
     255    Py_complex c;
     256    c.real = real;
     257    c.imag = imag;
     258    return PyComplex_FromCComplex(c);
    263259}
    264260
     
    266262PyComplex_RealAsDouble(PyObject *op)
    267263{
    268         if (PyComplex_Check(op)) {
    269                 return ((PyComplexObject *)op)->cval.real;
    270         }
    271         else {
    272                 return PyFloat_AsDouble(op);
    273         }
     264    if (PyComplex_Check(op)) {
     265        return ((PyComplexObject *)op)->cval.real;
     266    }
     267    else {
     268        return PyFloat_AsDouble(op);
     269    }
    274270}
    275271
     
    277273PyComplex_ImagAsDouble(PyObject *op)
    278274{
    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
     283static PyObject *
     284try_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;
    285313}
    286314
     
    288316PyComplex_AsCComplex(PyObject *op)
    289317{
    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    }
    347355}
    348356
     
    350358complex_dealloc(PyObject *op)
    351359{
    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
     364static PyObject *
     365complex_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;
    405425}
    406426
     
    408428complex_print(PyComplexObject *v, FILE *fp, int flags)
    409429{
    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;
    417444}
    418445
     
    420447complex_repr(PyComplexObject *v)
    421448{
    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');
    425450}
    426451
     
    428453complex_str(PyComplexObject *v)
    429454{
    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');
    433456}
    434457
     
    436459complex_hash(PyComplexObject *v)
    437460{
    438         long hashreal, hashimag, combined;
    439         hashreal = _Py_HashDouble(v->cval.real);
    440         if (hashreal == -1)
    441                 return -1;
    442         hashimag = _Py_HashDouble(v->cval.imag);
    443         if (hashimag == -1)
    444                 return -1;
    445         /* Note:  if the imaginary part is 0, hashimag is 0 now,
    446         * so the following returns hashreal unchanged.  This is
    447         * important because numbers of different types that
    448         * compare equal must have the same hash value, so that
    449         * hash(x + 0*j) must equal hash(x).
    450         */
    451         combined = hashreal + 1000003 * hashimag;
    452         if (combined == -1)
    453                 combined = -2;
    454         return combined;
     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;
    455478}
    456479
    457480/* This macro may return! */
    458481#define TO_COMPLEX(obj, c) \
    459         if (PyComplex_Check(obj)) \
    460                 c = ((PyComplexObject *)(obj))->cval; \
    461         else if (to_complex(&(obj), &(c)) < 0) \
    462                 return (obj)
     482    if (PyComplex_Check(obj)) \
     483        c = ((PyComplexObject *)(obj))->cval; \
     484    else if (to_complex(&(obj), &(c)) < 0) \
     485        return (obj)
    463486
    464487static int
     
    469492    pc->real = pc->imag = 0.0;
    470493    if (PyInt_Check(obj)) {
    471         pc->real = PyInt_AS_LONG(obj);
    472         return 0;
     494    pc->real = PyInt_AS_LONG(obj);
     495    return 0;
    473496    }
    474497    if (PyLong_Check(obj)) {
    475         pc->real = PyLong_AsDouble(obj);
    476         if (pc->real == -1.0 && PyErr_Occurred()) {
    477             *pobj = NULL;
    478             return -1;
    479         }
    480         return 0;
     498    pc->real = PyLong_AsDouble(obj);
     499    if (pc->real == -1.0 && PyErr_Occurred()) {
     500        *pobj = NULL;
     501        return -1;
     502    }
     503    return 0;
    481504    }
    482505    if (PyFloat_Check(obj)) {
    483         pc->real = PyFloat_AsDouble(obj);
    484         return 0;
     506    pc->real = PyFloat_AsDouble(obj);
     507    return 0;
    485508    }
    486509    Py_INCREF(Py_NotImplemented);
     
    488511    return -1;
    489512}
    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
     515static PyObject *
     516complex_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
     528static PyObject *
     529complex_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
     541static PyObject *
     542complex_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
     554static PyObject *
     555complex_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
     572static PyObject *
     573complex_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
     595static PyObject *
     596complex_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
     620static PyObject *
     621complex_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;
    607647}
    608648
     
    610650complex_pow(PyObject *v, PyObject *w, PyObject *z)
    611651{
    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
     686static PyObject *
     687complex_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;
    664705}
    665706
     
    667708complex_neg(PyComplexObject *v)
    668709{
    669         Py_complex neg;
    670         neg.real = -v->cval.real;
    671         neg.imag = -v->cval.imag;
    672         return PyComplex_FromCComplex(neg);
     710    Py_complex neg;
     711    neg.real = -v->cval.real;
     712    neg.imag = -v->cval.imag;
     713    return PyComplex_FromCComplex(neg);
    673714}
    674715
     
    676717complex_pos(PyComplexObject *v)
    677718{
    678         if (PyComplex_CheckExact(v)) {
    679                 Py_INCREF(v);
    680                 return (PyObject *)v;
    681         }
    682         else
    683                 return PyComplex_FromCComplex(v->cval);
     719    if (PyComplex_CheckExact(v)) {
     720        Py_INCREF(v);
     721        return (PyObject *)v;
     722    }
     723    else
     724        return PyComplex_FromCComplex(v->cval);
    684725}
    685726
     
    687728complex_abs(PyComplexObject *v)
    688729{
    689         double result;
    690 
    691         PyFPE_START_PROTECT("complex_abs", return 0)
    692         result = c_abs(v->cval);
    693         PyFPE_END_PROTECT(result)
    694 
    695         if (errno == ERANGE) {
    696                 PyErr_SetString(PyExc_OverflowError,
    697                                 "absolute value too large");
    698                 return NULL;
    699         }
    700         return PyFloat_FromDouble(result);
     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);
    701742}
    702743
     
    704745complex_nonzero(PyComplexObject *v)
    705746{
    706         return v->cval.real != 0.0 || v->cval.imag != 0.0;
     747    return v->cval.real != 0.0 || v->cval.imag != 0.0;
    707748}
    708749
     
    710751complex_coerce(PyObject **pv, PyObject **pw)
    711752{
    712         Py_complex cval;
    713         cval.imag = 0.;
    714         if (PyInt_Check(*pw)) {
    715                 cval.real = (double)PyInt_AsLong(*pw);
    716                 *pw = PyComplex_FromCComplex(cval);
    717                 Py_INCREF(*pv);
    718                 return 0;
    719         }
    720         else if (PyLong_Check(*pw)) {
    721                 cval.real = PyLong_AsDouble(*pw);
    722                 if (cval.real == -1.0 && PyErr_Occurred())
    723                         return -1;
    724                 *pw = PyComplex_FromCComplex(cval);
    725                 Py_INCREF(*pv);
    726                 return 0;
    727         }
    728         else if (PyFloat_Check(*pw)) {
    729                 cval.real = PyFloat_AsDouble(*pw);
    730                 *pw = PyComplex_FromCComplex(cval);
    731                 Py_INCREF(*pv);
    732                 return 0;
    733         }
    734         else if (PyComplex_Check(*pw)) {
    735                 Py_INCREF(*pv);
    736                 Py_INCREF(*pw);
    737                 return 0;
    738         }
    739         return 1; /* Can't do it */
     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 */
    740781}
    741782
     
    743784complex_richcompare(PyObject *v, PyObject *w, int op)
    744785{
    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;
    782850}
    783851
     
    785853complex_int(PyObject *v)
    786854{
    787         PyErr_SetString(PyExc_TypeError,
    788                    "can't convert complex to int");
    789         return NULL;
     855    PyErr_SetString(PyExc_TypeError,
     856               "can't convert complex to int");
     857    return NULL;
    790858}
    791859
     
    793861complex_long(PyObject *v)
    794862{
    795         PyErr_SetString(PyExc_TypeError,
    796                    "can't convert complex to long");
    797         return NULL;
     863    PyErr_SetString(PyExc_TypeError,
     864               "can't convert complex to long");
     865    return NULL;
    798866}
    799867
     
    801869complex_float(PyObject *v)
    802870{
    803         PyErr_SetString(PyExc_TypeError,
    804                    "can't convert complex to float");
    805         return NULL;
     871    PyErr_SetString(PyExc_TypeError,
     872               "can't convert complex to float");
     873    return NULL;
    806874}
    807875
     
    809877complex_conjugate(PyObject *self)
    810878{
    811         Py_complex c;
    812         c = ((PyComplexObject *)self)->cval;
    813         c.imag = -c.imag;
    814         return PyComplex_FromCComplex(c);
     879    Py_complex c;
     880    c = ((PyComplexObject *)self)->cval;
     881    c.imag = -c.imag;
     882    return PyComplex_FromCComplex(c);
    815883}
    816884
     
    818886"complex.conjugate() -> complex\n"
    819887"\n"
    820 "Returns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");
     888"Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");
    821889
    822890static PyObject *
    823891complex_getnewargs(PyComplexObject *v)
    824892{
    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
     897PyDoc_STRVAR(complex__format__doc,
     898"complex.__format__() -> str\n"
     899"\n"
     900"Convert to a string according to format_spec.");
     901
     902static PyObject *
     903complex__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;
    827930}
    828931
     
    831934complex_is_finite(PyObject *self)
    832935{
    833         Py_complex c;
    834         c = ((PyComplexObject *)self)->cval;
    835         return PyBool_FromLong((long)(Py_IS_FINITE(c.real) &&
    836                                       Py_IS_FINITE(c.imag)));
     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)));
    837940}
    838941
     
    844947
    845948static PyMethodDef complex_methods[] = {
    846         {"conjugate",   (PyCFunction)complex_conjugate, METH_NOARGS,
    847         complex_conjugate_doc},
     949    {"conjugate",       (PyCFunction)complex_conjugate, METH_NOARGS,
     950    complex_conjugate_doc},
    848951#if 0
    849         {"is_finite",   (PyCFunction)complex_is_finite, METH_NOARGS,
    850         complex_is_finite_doc},
     952    {"is_finite",       (PyCFunction)complex_is_finite, METH_NOARGS,
     953    complex_is_finite_doc},
    851954#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 */
    854959};
    855960
    856961static PyMemberDef complex_members[] = {
    857         {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY,
    858         "the real part of a complex number"},
    859         {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY,
    860         "the imaginary part of a complex number"},
    861         {0},
     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},
    862967};
    863968
     
    865970complex_subtype_from_string(PyTypeObject *type, PyObject *v)
    866971{
    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;
    875976#ifdef Py_USING_UNICODE
    876         char s_buffer[256];
     977    char *s_buffer = NULL;
    877978#endif
    878         Py_ssize_t len;
    879 
    880         if (PyString_Check(v)) {
    881                 s = PyString_AS_STRING(v);
    882                 len = PyString_GET_SIZE(v);
    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    }
    884985#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    }
    899998#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;
    10371128}
    10381129
     
    10401131complex_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    10411132{
    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);
    11821261}
    11831262
     
    11891268
    11901269static 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 */
    12291308};
    12301309
    12311310PyTypeObject 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 */
    12711351};
    12721352
Note: See TracChangeset for help on using the changeset viewer.