#include "Python.h"

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_complexobject.h" // _PyComplex_FormatAdvancedWriter()

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_object.h" // _PyObject_Init()

#include "pycore_pymath.h" // _Py_ADJUST_ERANGE2()

#include "clinic/complexobject.c.h"

static Py_complex c_1 = {1., 0.};

_Py_c_sum(Py_complex a, Py_complex b)

{

Py_complex r;

r.real = a.real + b.real;

r.imag = a.imag + b.imag;

return r;

}

_Py_c_diff(Py_complex a, Py_complex b)

{

Py_complex r;

r.real = a.real - b.real;

r.imag = a.imag - b.imag;

return r;

}

_Py_c_neg(Py_complex a)

{

Py_complex r;

r.real = -a.real;

r.imag = -a.imag;

return r;

}

_Py_c_prod(Py_complex a, Py_complex b)

{

Py_complex r;

r.real = a.real*b.real - a.imag*b.imag;

r.imag = a.real*b.imag + a.imag*b.real;

return r;

}

#ifdef _M_ARM64

#pragma optimize("", off)

_Py_c_quot(Py_complex a, Py_complex b)

{

/******************************************************************

/* This algorithm is better, and is pretty obvious: first divide the

Py_complex r; /* the result */

const double abs_breal = b.real < 0 ? -b.real : b.real;

const double abs_bimag = b.imag < 0 ? -b.imag : b.imag;

if (abs_breal >= abs_bimag) {

/* divide tops and bottom by b.real */

if (abs_breal == 0.0) {

errno = EDOM;

r.real = r.imag = 0.0;

}

else {

const double ratio = b.imag / b.real;

const double denom = b.real + b.imag * ratio;

r.real = (a.real + a.imag * ratio) / denom;

r.imag = (a.imag - a.real * ratio) / denom;

}

}

else if (abs_bimag >= abs_breal) {

/* divide tops and bottom by b.imag */

const double ratio = b.real / b.imag;

const double denom = b.real * ratio + b.imag;

assert(b.imag != 0.0);

r.real = (a.real * ratio + a.imag) / denom;

r.imag = (a.imag * ratio - a.real) / denom;

}

else {

/* At least one of b.real or b.imag is a NaN */

r.real = r.imag = Py_NAN;

}

/* Recover infinities and zeros that computed as nan+nanj. See e.g.

if (isnan(r.real) && isnan(r.imag)) {

if ((isinf(a.real) || isinf(a.imag))

&& isfinite(b.real) && isfinite(b.imag))

{

const double x = copysign(isinf(a.real) ? 1.0 : 0.0, a.real);

const double y = copysign(isinf(a.imag) ? 1.0 : 0.0, a.imag);

r.real = Py_INFINITY * (x*b.real + y*b.imag);

r.imag = Py_INFINITY * (y*b.real - x*b.imag);

}

else if ((isinf(abs_breal) || isinf(abs_bimag))

&& isfinite(a.real) && isfinite(a.imag))

{

const double x = copysign(isinf(b.real) ? 1.0 : 0.0, b.real);

const double y = copysign(isinf(b.imag) ? 1.0 : 0.0, b.imag);

r.real = 0.0 * (a.real*x + a.imag*y);

r.imag = 0.0 * (a.imag*x - a.real*y);

}

}

return r;

}

#ifdef _M_ARM64

#pragma optimize("", on)

_Py_c_pow(Py_complex a, Py_complex b)

{

Py_complex r;

double vabs,len,at,phase;

if (b.real == 0. && b.imag == 0.) {

r.real = 1.;

r.imag = 0.;

}

else if (a.real == 0. && a.imag == 0.) {

if (b.imag != 0. || b.real < 0.)

errno = EDOM;

r.real = 0.;

r.imag = 0.;

}

else {

vabs = hypot(a.real,a.imag);

len = pow(vabs,b.real);

at = atan2(a.imag, a.real);

phase = at*b.real;

if (b.imag != 0.0) {

len /= exp(at*b.imag);

phase += b.imag*log(vabs);

}

r.real = len*cos(phase);

r.imag = len*sin(phase);

_Py_ADJUST_ERANGE2(r.real, r.imag);

}

return r;

}

static Py_complex

c_powu(Py_complex x, long n)

{

Py_complex r, p;

long mask = 1;

r = c_1;

p = x;

while (mask > 0 && n >= mask) {

if (n & mask)

r = _Py_c_prod(r,p);

mask <<= 1;

p = _Py_c_prod(p,p);

}

return r;

}

static Py_complex

c_powi(Py_complex x, long n)

{

if (n > 0)

return c_powu(x,n);

else

return _Py_c_quot(c_1, c_powu(x,-n));

}

_Py_c_abs(Py_complex z)

{

/* sets errno = ERANGE on overflow; otherwise errno = 0 */

double result;

if (!isfinite(z.real) || !isfinite(z.imag)) {

/* C99 rules: if either the real or the imaginary part is an

if (isinf(z.real)) {

result = fabs(z.real);

errno = 0;

return result;

}

if (isinf(z.imag)) {

result = fabs(z.imag);

errno = 0;

return result;

}

/* either the real or imaginary part is a NaN,

return Py_NAN;

}

result = hypot(z.real, z.imag);

if (!isfinite(result))

errno = ERANGE;

else

errno = 0;

return result;

}

static PyObject *

complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)

{

PyObject *op;

op = type->tp_alloc(type, 0);

if (op != NULL)

((PyComplexObject *)op)->cval = cval;

return op;

}

PyObject *

PyComplex_FromCComplex(Py_complex cval)

{

/* Inline PyObject_New */

PyComplexObject *op = PyObject_Malloc(sizeof(PyComplexObject));

if (op == NULL) {

return PyErr_NoMemory();

}

_PyObject_Init((PyObject*)op, &PyComplex_Type);

op->cval = cval;

return (PyObject *) op;

}

static PyObject *

complex_subtype_from_doubles(PyTypeObject *type, double real, double imag)

{

Py_complex c;

c.real = real;

c.imag = imag;

return complex_subtype_from_c_complex(type, c);

}

PyObject *

PyComplex_FromDoubles(double real, double imag)

{

Py_complex c;

c.real = real;

c.imag = imag;

return PyComplex_FromCComplex(c);

}

static PyObject * try_complex_special_method(PyObject *);

PyComplex_RealAsDouble(PyObject *op)

{

double real = -1.0;

if (PyComplex_Check(op)) {

real = ((PyComplexObject *)op)->cval.real;

}

else {

PyObject* newop = try_complex_special_method(op);

if (newop) {

real = ((PyComplexObject *)newop)->cval.real;

Py_DECREF(newop);

} else if (!PyErr_Occurred()) {

real = PyFloat_AsDouble(op);

}

}

return real;

}

PyComplex_ImagAsDouble(PyObject *op)

{

double imag = -1.0;

if (PyComplex_Check(op)) {

imag = ((PyComplexObject *)op)->cval.imag;

}

else {

PyObject* newop = try_complex_special_method(op);

if (newop) {

imag = ((PyComplexObject *)newop)->cval.imag;

Py_DECREF(newop);

} else if (!PyErr_Occurred()) {

PyFloat_AsDouble(op);

if (!PyErr_Occurred()) {

imag = 0.0;

}

}

}

return imag;

}

static PyObject *

try_complex_special_method(PyObject *op)

{

PyObject *f;

f = _PyObject_LookupSpecial(op, &_Py_ID(__complex__));

if (f) {

PyObject *res = _PyObject_CallNoArgs(f);

Py_DECREF(f);

if (!res || PyComplex_CheckExact(res)) {

return res;

}

if (!PyComplex_Check(res)) {

PyErr_Format(PyExc_TypeError,

"__complex__ returned non-complex (type %.200s)",

Py_TYPE(res)->tp_name);

Py_DECREF(res);

return NULL;

}

/* Issue #29894: warn if 'res' not of exact type complex. */

if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,

"__complex__ returned non-complex (type %.200s). "

"The ability to return an instance of a strict subclass of complex "

"is deprecated, and may be removed in a future version of Python.",

Py_TYPE(res)->tp_name)) {

Py_DECREF(res);

return NULL;

}

return res;

}

return NULL;

}

PyComplex_AsCComplex(PyObject *op)

{

Py_complex cv;

PyObject *newop = NULL;

assert(op);

/* If op is already of type PyComplex_Type, return its value */

if (PyComplex_Check(op)) {

return ((PyComplexObject *)op)->cval;

}

/* If not, use op's __complex__ method, if it exists */

/* return -1 on failure */

cv.real = -1.;

cv.imag = 0.;

newop = try_complex_special_method(op);

if (newop) {

cv = ((PyComplexObject *)newop)->cval;

Py_DECREF(newop);

return cv;

}

else if (PyErr_Occurred()) {

return cv;

}

/* If neither of the above works, interpret op as a float giving the

else {

/* PyFloat_AsDouble will return -1 on failure */

cv.real = PyFloat_AsDouble(op);

return cv;

}

}

static PyObject *

complex_repr(PyComplexObject *v)

{

int precision = 0;

char format_code = 'r';

PyObject *result = NULL;

/* If these are non-NULL, they'll need to be freed. */

char *pre = NULL;

char *im = NULL;

/* These do not need to be freed. re is either an alias

const char *re = NULL;

const char *lead = "";

const char *tail = "";

if (v->cval.real == 0. && copysign(1.0, v->cval.real)==1.0) {

/* Real part is +0: just output the imaginary part and do not

re = "";

im = PyOS_double_to_string(v->cval.imag, format_code,

precision, 0, NULL);

if (!im) {

PyErr_NoMemory();

goto done;

}

} else {

/* Format imaginary part with sign, real part without. Include

pre = PyOS_double_to_string(v->cval.real, format_code,

precision, 0, NULL);

if (!pre) {

PyErr_NoMemory();

goto done;

}

re = pre;

im = PyOS_double_to_string(v->cval.imag, format_code,

precision, Py_DTSF_SIGN, NULL);

if (!im) {

PyErr_NoMemory();

goto done;

}

lead = "(";

tail = ")";

}

result = PyUnicode_FromFormat("%s%s%sj%s", lead, re, im, tail);

done:

PyMem_Free(im);

PyMem_Free(pre);

return result;

}

static Py_hash_t

complex_hash(PyComplexObject *v)

{

Py_uhash_t hashreal, hashimag, combined;

hashreal = (Py_uhash_t)_Py_HashDouble((PyObject *) v, v->cval.real);

if (hashreal == (Py_uhash_t)-1)

return -1;

hashimag = (Py_uhash_t)_Py_HashDouble((PyObject *)v, v->cval.imag);

if (hashimag == (Py_uhash_t)-1)

return -1;

/* Note: if the imaginary part is 0, hashimag is 0 now,

combined = hashreal + _PyHASH_IMAG * hashimag;

if (combined == (Py_uhash_t)-1)

combined = (Py_uhash_t)-2;

return (Py_hash_t)combined;

}

#define TO_COMPLEX(obj, c) \

if (PyComplex_Check(obj)) \

c = ((PyComplexObject *)(obj))->cval; \

else if (to_complex(&(obj), &(c)) < 0) \

return (obj)

static int

to_complex(PyObject **pobj, Py_complex *pc)

{

PyObject *obj = *pobj;

pc->real = pc->imag = 0.0;

if (PyLong_Check(obj)) {

pc->real = PyLong_AsDouble(obj);

if (pc->real == -1.0 && PyErr_Occurred()) {

*pobj = NULL;

return -1;

}

return 0;

}

if (PyFloat_Check(obj)) {

pc->real = PyFloat_AsDouble(obj);

return 0;

}

*pobj = Py_NewRef(Py_NotImplemented);

return -1;

}

static PyObject *

complex_add(PyObject *v, PyObject *w)

{

Py_complex result;

Py_complex a, b;

TO_COMPLEX(v, a);

TO_COMPLEX(w, b);

result = _Py_c_sum(a, b);

return PyComplex_FromCComplex(result);

}

static PyObject *

complex_sub(PyObject *v, PyObject *w)

{

Py_complex result;

Py_complex a, b;

TO_COMPLEX(v, a);

TO_COMPLEX(w, b);

result = _Py_c_diff(a, b);

return PyComplex_FromCComplex(result);

}

static PyObject *

complex_mul(PyObject *v, PyObject *w)

{

Py_complex result;

Py_complex a, b;

TO_COMPLEX(v, a);

TO_COMPLEX(w, b);

result = _Py_c_prod(a, b);

return PyComplex_FromCComplex(result);

}

static PyObject *

complex_div(PyObject *v, PyObject *w)

{

Py_complex quot;

Py_complex a, b;

TO_COMPLEX(v, a);

TO_COMPLEX(w, b);

errno = 0;

quot = _Py_c_quot(a, b);

if (errno == EDOM) {

PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");

return NULL;

}

return PyComplex_FromCComplex(quot);

}

static PyObject *

complex_pow(PyObject *v, PyObject *w, PyObject *z)

{

Py_complex p;

Py_complex a, b;

TO_COMPLEX(v, a);

TO_COMPLEX(w, b);

if (z != Py_None) {

PyErr_SetString(PyExc_ValueError, "complex modulo");

return NULL;

}

errno = 0;

// Check whether the exponent has a small integer value, and if so use

// a faster and more accurate algorithm.

if (b.imag == 0.0 && b.real == floor(b.real) && fabs(b.real) <= 100.0) {

p = c_powi(a, (long)b.real);

_Py_ADJUST_ERANGE2(p.real, p.imag);

}

else {

p = _Py_c_pow(a, b);

}

if (errno == EDOM) {

PyErr_SetString(PyExc_ZeroDivisionError,

"zero to a negative or complex power");

return NULL;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError,

"complex exponentiation");

return NULL;

}

return PyComplex_FromCComplex(p);

}

static PyObject *

complex_neg(PyComplexObject *v)

{

Py_complex neg;

neg.real = -v->cval.real;

neg.imag = -v->cval.imag;

return PyComplex_FromCComplex(neg);

}

static PyObject *

complex_pos(PyComplexObject *v)

{

if (PyComplex_CheckExact(v)) {

return Py_NewRef(v);

}

else

return PyComplex_FromCComplex(v->cval);

}

static PyObject *

complex_abs(PyComplexObject *v)

{

double result;

result = _Py_c_abs(v->cval);

if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError,

"absolute value too large");

return NULL;

}

return PyFloat_FromDouble(result);

}

static int

complex_bool(PyComplexObject *v)

{

return v->cval.real != 0.0 || v->cval.imag != 0.0;

}

static PyObject *

complex_richcompare(PyObject *v, PyObject *w, int op)

{

PyObject *res;

Py_complex i;

int equal;

if (op != Py_EQ && op != Py_NE) {

goto Unimplemented;

}

assert(PyComplex_Check(v));

TO_COMPLEX(v, i);

if (PyLong_Check(w)) {

/* Check for 0.0 imaginary part first to avoid the rich

if (i.imag == 0.0) {

PyObject *j, *sub_res;

j = PyFloat_FromDouble(i.real);

if (j == NULL)

return NULL;

sub_res = PyObject_RichCompare(j, w, op);

Py_DECREF(j);

return sub_res;

}

else {

equal = 0;

}

}

else if (PyFloat_Check(w)) {

equal = (i.real == PyFloat_AsDouble(w) && i.imag == 0.0);

}

else if (PyComplex_Check(w)) {

Py_complex j;

TO_COMPLEX(w, j);

equal = (i.real == j.real && i.imag == j.imag);

}

else {

goto Unimplemented;

}

if (equal == (op == Py_EQ))

res = Py_True;

else

res = Py_False;

return Py_NewRef(res);

Unimplemented:

Py_RETURN_NOTIMPLEMENTED;

}

static PyObject *

complex_conjugate_impl(PyComplexObject *self)

{

Py_complex c = self->cval;

c.imag = -c.imag;

return PyComplex_FromCComplex(c);

}

static PyObject *

complex___getnewargs___impl(PyComplexObject *self)

{

Py_complex c = self->cval;

return Py_BuildValue("(dd)", c.real, c.imag);

}

static PyObject *

complex___format___impl(PyComplexObject *self, PyObject *format_spec)

{

_PyUnicodeWriter writer;

int ret;

_PyUnicodeWriter_Init(&writer);

ret = _PyComplex_FormatAdvancedWriter(

&writer,

(PyObject *)self,

format_spec, 0, PyUnicode_GET_LENGTH(format_spec));

if (ret == -1) {

_PyUnicodeWriter_Dealloc(&writer);

return NULL;

}

return _PyUnicodeWriter_Finish(&writer);

}

static PyObject *

complex___complex___impl(PyComplexObject *self)

{

if (PyComplex_CheckExact(self)) {

return Py_NewRef(self);

}

else {

return PyComplex_FromCComplex(self->cval);

}

}

static PyObject *

complex_from_string_inner(const char *s, Py_ssize_t len, void *type)

{

double x=0.0, y=0.0, z;

int got_bracket=0;

const char *start;

char *end;

/* position on first nonblank */

start = s;

while (Py_ISSPACE(*s))

s++;

if (*s == '(') {

/* Skip over possible bracket from repr(). */

got_bracket = 1;

s++;

while (Py_ISSPACE(*s))

s++;

}

/* a valid complex string usually takes one of the three forms:

/* first look for forms starting with <float> */

z = PyOS_string_to_double(s, &end, NULL);

if (z == -1.0 && PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_ValueError))

PyErr_Clear();

else

return NULL;

}

if (end != s) {

/* all 4 forms starting with <float> land here */

s = end;

if (*s == '+' || *s == '-') {

/* <float><signed-float>j | <float><sign>j */

x = z;

y = PyOS_string_to_double(s, &end, NULL);

if (y == -1.0 && PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_ValueError))

PyErr_Clear();

else

return NULL;

}

if (end != s)

/* <float><signed-float>j */

s = end;

else {

/* <float><sign>j */

y = *s == '+' ? 1.0 : -1.0;

s++;

}

if (!(*s == 'j' || *s == 'J'))

goto parse_error;

s++;

}

else if (*s == 'j' || *s == 'J') {

/* <float>j */

s++;

y = z;

}

else

/* <float> */

x = z;

}

else {

/* not starting with <float>; must be <sign>j or j */

if (*s == '+' || *s == '-') {

/* <sign>j */

y = *s == '+' ? 1.0 : -1.0;

s++;

}

else

/* j */

y = 1.0;

if (!(*s == 'j' || *s == 'J'))

goto parse_error;

s++;

}

/* trailing whitespace and closing bracket */

while (Py_ISSPACE(*s))

s++;

if (got_bracket) {

/* if there was an opening parenthesis, then the corresponding

if (*s != ')')

goto parse_error;

s++;

while (Py_ISSPACE(*s))

s++;

}

/* we should now be at the end of the string */

if (s-start != len)

goto parse_error;

return complex_subtype_from_doubles(_PyType_CAST(type), x, y);

parse_error:

PyErr_SetString(PyExc_ValueError,

"complex() arg is a malformed string");

return NULL;

}

static PyObject *

complex_subtype_from_string(PyTypeObject *type, PyObject *v)

{

const char *s;

PyObject *s_buffer = NULL, *result = NULL;

Py_ssize_t len;

if (PyUnicode_Check(v)) {

s_buffer = _PyUnicode_TransformDecimalAndSpaceToASCII(v);

if (s_buffer == NULL) {

return NULL;

}

assert(PyUnicode_IS_ASCII(s_buffer));

/* Simply get a pointer to existing ASCII characters. */

s = PyUnicode_AsUTF8AndSize(s_buffer, &len);

assert(s != NULL);

}

else {

PyErr_Format(PyExc_TypeError,

"complex() argument must be a string or a number, not %T",

v);

return NULL;

}

result = _Py_string_to_number_with_underscores(s, len, "complex", v, type,

complex_from_string_inner);

Py_DECREF(s_buffer);

return result;

}

static PyObject *

actual_complex_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

PyObject *res = NULL;

PyNumberMethods *nbr;

if (PyTuple_GET_SIZE(args) > 1 || (kwargs != NULL && PyDict_GET_SIZE(kwargs))) {

return complex_new(type, args, kwargs);

}

if (!PyTuple_GET_SIZE(args)) {

return complex_subtype_from_doubles(type, 0, 0);

}

PyObject *arg = PyTuple_GET_ITEM(args, 0);

/* Special-case for a single argument when type(arg) is complex. */

if (PyComplex_CheckExact(arg) && type == &PyComplex_Type) {

/* Note that we can't know whether it's safe to return

return Py_NewRef(arg);

}

if (PyUnicode_Check(arg)) {

return complex_subtype_from_string(type, arg);

}

PyObject *tmp = try_complex_special_method(arg);

if (tmp) {

Py_complex c = ((PyComplexObject*)tmp)->cval;

res = complex_subtype_from_doubles(type, c.real, c.imag);

Py_DECREF(tmp);

}

else if (PyErr_Occurred()) {

return NULL;

}

else if (PyComplex_Check(arg)) {

/* Note that if arg is of a complex subtype, we're only

Py_complex c = ((PyComplexObject*)arg)->cval;

res = complex_subtype_from_doubles(type, c.real, c.imag);

}

else if ((nbr = Py_TYPE(arg)->tp_as_number) != NULL &&

(nbr->nb_float != NULL || nbr->nb_index != NULL))

{

/* The argument really is entirely real, and contributes

double r = PyFloat_AsDouble(arg);

if (r != -1.0 || !PyErr_Occurred()) {

res = complex_subtype_from_doubles(type, r, 0);

}

}

else {

PyErr_Format(PyExc_TypeError,

"complex() argument must be a string or a number, not %T",

arg);

}

return res;

}

static PyObject *