#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# include "pycore_gc.h" // PyGC_Head

# include "pycore_runtime.h" // _Py_ID()

#include "pycore_modsupport.h" // _PyArg_CheckPositional()

PyDoc_STRVAR(cmath_acos__doc__,

"Return the arc cosine of z.");

#define CMATH_ACOS_METHODDEF \

{"acos", (PyCFunction)cmath_acos, METH_O, cmath_acos__doc__},

static Py_complex

cmath_acos_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_acos(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_acos_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_acosh__doc__,

"Return the inverse hyperbolic cosine of z.");

#define CMATH_ACOSH_METHODDEF \

{"acosh", (PyCFunction)cmath_acosh, METH_O, cmath_acosh__doc__},

static Py_complex

cmath_acosh_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_acosh(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_acosh_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_asin__doc__,

"Return the arc sine of z.");

#define CMATH_ASIN_METHODDEF \

{"asin", (PyCFunction)cmath_asin, METH_O, cmath_asin__doc__},

static Py_complex

cmath_asin_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_asin(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_asin_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_asinh__doc__,

"Return the inverse hyperbolic sine of z.");

#define CMATH_ASINH_METHODDEF \

{"asinh", (PyCFunction)cmath_asinh, METH_O, cmath_asinh__doc__},

static Py_complex

cmath_asinh_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_asinh(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_asinh_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_atan__doc__,

"Return the arc tangent of z.");

#define CMATH_ATAN_METHODDEF \

{"atan", (PyCFunction)cmath_atan, METH_O, cmath_atan__doc__},

static Py_complex

cmath_atan_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_atan(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_atan_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_atanh__doc__,

"Return the inverse hyperbolic tangent of z.");

#define CMATH_ATANH_METHODDEF \

{"atanh", (PyCFunction)cmath_atanh, METH_O, cmath_atanh__doc__},

static Py_complex

cmath_atanh_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_atanh(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_atanh_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_cos__doc__,

"Return the cosine of z.");

#define CMATH_COS_METHODDEF \

{"cos", (PyCFunction)cmath_cos, METH_O, cmath_cos__doc__},

static Py_complex

cmath_cos_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_cos(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_cos_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_cosh__doc__,

"Return the hyperbolic cosine of z.");

#define CMATH_COSH_METHODDEF \

{"cosh", (PyCFunction)cmath_cosh, METH_O, cmath_cosh__doc__},

static Py_complex

cmath_cosh_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_cosh(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_cosh_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_exp__doc__,

"Return the exponential value e**z.");

#define CMATH_EXP_METHODDEF \

{"exp", (PyCFunction)cmath_exp, METH_O, cmath_exp__doc__},

static Py_complex

cmath_exp_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_exp(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_exp_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_log10__doc__,

"Return the base-10 logarithm of z.");

#define CMATH_LOG10_METHODDEF \

{"log10", (PyCFunction)cmath_log10, METH_O, cmath_log10__doc__},

static Py_complex

cmath_log10_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_log10(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_log10_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_sin__doc__,

"Return the sine of z.");

#define CMATH_SIN_METHODDEF \

{"sin", (PyCFunction)cmath_sin, METH_O, cmath_sin__doc__},

static Py_complex

cmath_sin_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_sin(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_sin_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_sinh__doc__,

"Return the hyperbolic sine of z.");

#define CMATH_SINH_METHODDEF \

{"sinh", (PyCFunction)cmath_sinh, METH_O, cmath_sinh__doc__},

static Py_complex

cmath_sinh_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_sinh(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_sinh_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_sqrt__doc__,

"Return the square root of z.");

#define CMATH_SQRT_METHODDEF \

{"sqrt", (PyCFunction)cmath_sqrt, METH_O, cmath_sqrt__doc__},

static Py_complex

cmath_sqrt_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_sqrt(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_sqrt_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_tan__doc__,

"Return the tangent of z.");

#define CMATH_TAN_METHODDEF \

{"tan", (PyCFunction)cmath_tan, METH_O, cmath_tan__doc__},

static Py_complex

cmath_tan_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_tan(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_tan_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_tanh__doc__,

"Return the hyperbolic tangent of z.");

#define CMATH_TANH_METHODDEF \

{"tanh", (PyCFunction)cmath_tanh, METH_O, cmath_tanh__doc__},

static Py_complex

cmath_tanh_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_tanh(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

Py_complex _return_value;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

/* modifications for z */

errno = 0;

_return_value = cmath_tanh_impl(module, z);

if (errno == EDOM) {

PyErr_SetString(PyExc_ValueError, "math domain error");

goto exit;

}

else if (errno == ERANGE) {

PyErr_SetString(PyExc_OverflowError, "math range error");

goto exit;

}

else {

return_value = PyComplex_FromCComplex(_return_value);

}

exit:

return return_value;

}

PyDoc_STRVAR(cmath_log__doc__,

"If the base is not specified, returns the natural logarithm (base e) of z.");

#define CMATH_LOG_METHODDEF \

{"log", _PyCFunction_CAST(cmath_log), METH_FASTCALL, cmath_log__doc__},

static PyObject *

cmath_log_impl(PyObject *module, Py_complex x, PyObject *y_obj);

static PyObject *

cmath_log(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

Py_complex x;

PyObject *y_obj = NULL;

if (!_PyArg_CheckPositional("log", nargs, 1, 2)) {

goto exit;

}

x = PyComplex_AsCComplex(args[0]);

if (PyErr_Occurred()) {

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

y_obj = args[1];

skip_optional:

return_value = cmath_log_impl(module, x, y_obj);

exit:

return return_value;

}

PyDoc_STRVAR(cmath_phase__doc__,

"Return argument, also known as the phase angle, of a complex.");

#define CMATH_PHASE_METHODDEF \

{"phase", (PyCFunction)cmath_phase, METH_O, cmath_phase__doc__},

static PyObject *

cmath_phase_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_phase(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

return_value = cmath_phase_impl(module, z);

exit:

return return_value;

}

PyDoc_STRVAR(cmath_polar__doc__,

"r is the distance from 0 and phi the phase angle.");

#define CMATH_POLAR_METHODDEF \

{"polar", (PyCFunction)cmath_polar, METH_O, cmath_polar__doc__},

static PyObject *

cmath_polar_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_polar(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

return_value = cmath_polar_impl(module, z);

exit:

return return_value;

}

PyDoc_STRVAR(cmath_rect__doc__,

"Convert from polar coordinates to rectangular coordinates.");

#define CMATH_RECT_METHODDEF \

{"rect", _PyCFunction_CAST(cmath_rect), METH_FASTCALL, cmath_rect__doc__},

static PyObject *

cmath_rect_impl(PyObject *module, double r, double phi);

static PyObject *

cmath_rect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

double r;

double phi;

if (!_PyArg_CheckPositional("rect", nargs, 2, 2)) {

goto exit;

}

if (PyFloat_CheckExact(args[0])) {

r = PyFloat_AS_DOUBLE(args[0]);

}

else

{

r = PyFloat_AsDouble(args[0]);

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

goto exit;

}

}

if (PyFloat_CheckExact(args[1])) {

phi = PyFloat_AS_DOUBLE(args[1]);

}

else

{

phi = PyFloat_AsDouble(args[1]);

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

goto exit;

}

}

return_value = cmath_rect_impl(module, r, phi);

exit:

return return_value;

}

PyDoc_STRVAR(cmath_isfinite__doc__,

"Return True if both the real and imaginary parts of z are finite, else False.");

#define CMATH_ISFINITE_METHODDEF \

{"isfinite", (PyCFunction)cmath_isfinite, METH_O, cmath_isfinite__doc__},

static PyObject *

cmath_isfinite_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_isfinite(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

return_value = cmath_isfinite_impl(module, z);

exit:

return return_value;

}

PyDoc_STRVAR(cmath_isnan__doc__,

"Checks if the real or imaginary part of z not a number (NaN).");

#define CMATH_ISNAN_METHODDEF \

{"isnan", (PyCFunction)cmath_isnan, METH_O, cmath_isnan__doc__},

static PyObject *

cmath_isnan_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_isnan(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

return_value = cmath_isnan_impl(module, z);

exit:

return return_value;

}

PyDoc_STRVAR(cmath_isinf__doc__,

"Checks if the real or imaginary part of z is infinite.");

#define CMATH_ISINF_METHODDEF \

{"isinf", (PyCFunction)cmath_isinf, METH_O, cmath_isinf__doc__},

static PyObject *

cmath_isinf_impl(PyObject *module, Py_complex z);

static PyObject *

cmath_isinf(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_complex z;

z = PyComplex_AsCComplex(arg);

if (PyErr_Occurred()) {

goto exit;

}

return_value = cmath_isinf_impl(module, z);

exit:

return return_value;

}

PyDoc_STRVAR(cmath_isclose__doc__,

"not close to anything, even itself. inf and -inf are only close to themselves.");

#define CMATH_ISCLOSE_METHODDEF \

{"isclose", _PyCFunction_CAST(cmath_isclose), METH_FASTCALL|METH_KEYWORDS, cmath_isclose__doc__},

static int

cmath_isclose_impl(PyObject *module, Py_complex a, Py_complex b,

double rel_tol, double abs_tol);

static PyObject *

cmath_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 4

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(rel_tol), &_Py_ID(abs_tol), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"a", "b", "rel_tol", "abs_tol", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "isclose",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[4];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;

Py_complex a;

Py_complex b;

double rel_tol = 1e-09;

double abs_tol = 0.0;

int _return_value;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);

if (!args) {

goto exit;

}

a = PyComplex_AsCComplex(args[0]);

if (PyErr_Occurred()) {

goto exit;

}

b = PyComplex_AsCComplex(args[1]);

if (PyErr_Occurred()) {

goto exit;

}

if (!noptargs) {

goto skip_optional_kwonly;

}

if (args[2]) {

if (PyFloat_CheckExact(args[2])) {

rel_tol = PyFloat_AS_DOUBLE(args[2]);

}

else

{

rel_tol = PyFloat_AsDouble(args[2]);

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

goto exit;

}

}

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (PyFloat_CheckExact(args[3])) {

abs_tol = PyFloat_AS_DOUBLE(args[3]);

}

else

{

abs_tol = PyFloat_AsDouble(args[3]);

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

goto exit;

}

}

skip_optional_kwonly:

_return_value = cmath_isclose_impl(module, a, b, rel_tol, abs_tol);

if ((_return_value == -1) && PyErr_Occurred()) {

goto exit;

}

return_value = PyBool_FromLong((long)_return_value);

exit:

return return_value;

}