LCOV - code coverage report
Current view: top level - Objects - complexobject.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 43 439 9.8 %
Date: 2023-03-20 08:15:36 Functions: 8 37 21.6 %
Branches: 14 314 4.5 %

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

Generated by: LCOV version 1.14