#include "Python.h"

#include "pycore_abstract.h" // _PyNumber_Index()

#include "pycore_dtoa.h" // _Py_dg_dtoa()

#include "pycore_floatobject.h" // _PyFloat_FormatAdvancedWriter()

#include "pycore_freelist.h" // _Py_FREELIST_FREE(), _Py_FREELIST_POP()

#include "pycore_initconfig.h" // _PyStatus_OK()

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

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

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

#include "pycore_pymath.h" // _PY_SHORT_FLOAT_REPR

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#include "pycore_stackref.h" // PyStackRef_AsPyObjectBorrow()

#include "pycore_structseq.h" // _PyStructSequence_FiniBuiltin()

#include <float.h> // DBL_MAX

#include <stdlib.h> // strtol()

#include "clinic/floatobject.c.h"

PyFloat_GetMax(void)

{

return DBL_MAX;

}

PyFloat_GetMin(void)

{

return DBL_MIN;

}

static PyTypeObject FloatInfoType;

PyDoc_STRVAR(floatinfo__doc__,

your system's :file:`float.h` for more information.");

static PyStructSequence_Field floatinfo_fields[] = {

{"max", "DBL_MAX -- maximum representable finite float"},

{"max_exp", "DBL_MAX_EXP -- maximum int e such that radix**(e-1) "

"is representable"},

{"max_10_exp", "DBL_MAX_10_EXP -- maximum int e such that 10**e "

"is representable"},

{"min", "DBL_MIN -- Minimum positive normalized float"},

{"min_exp", "DBL_MIN_EXP -- minimum int e such that radix**(e-1) "

"is a normalized float"},

{"min_10_exp", "DBL_MIN_10_EXP -- minimum int e such that 10**e is "

"a normalized float"},

{"dig", "DBL_DIG -- maximum number of decimal digits that "

"can be faithfully represented in a float"},

{"mant_dig", "DBL_MANT_DIG -- mantissa digits"},

{"epsilon", "DBL_EPSILON -- Difference between 1 and the next "

"representable float"},

{"radix", "FLT_RADIX -- radix of exponent"},

{"rounds", "FLT_ROUNDS -- rounding mode used for arithmetic "

"operations"},

{0}

};

static PyStructSequence_Desc floatinfo_desc = {

"sys.float_info", /* name */

floatinfo__doc__, /* doc */

floatinfo_fields, /* fields */

11

};

PyObject *

PyFloat_GetInfo(void)

{

PyObject* floatinfo;

int pos = 0;

floatinfo = PyStructSequence_New(&FloatInfoType);

if (floatinfo == NULL) {

return NULL;

}

#define SetFlag(CALL) \

do { \

PyObject *flag = (CALL); \

if (flag == NULL) { \

Py_CLEAR(floatinfo); \

return NULL; \

} \

PyStructSequence_SET_ITEM(floatinfo, pos++, flag); \

} while (0)

#define SetIntFlag(FLAG) SetFlag(PyLong_FromLong((FLAG)))

#define SetDblFlag(FLAG) SetFlag(PyFloat_FromDouble((FLAG)))

SetDblFlag(DBL_MAX);

SetIntFlag(DBL_MAX_EXP);

SetIntFlag(DBL_MAX_10_EXP);

SetDblFlag(DBL_MIN);

SetIntFlag(DBL_MIN_EXP);

SetIntFlag(DBL_MIN_10_EXP);

SetIntFlag(DBL_DIG);

SetIntFlag(DBL_MANT_DIG);

SetDblFlag(DBL_EPSILON);

SetIntFlag(FLT_RADIX);

SetIntFlag(FLT_ROUNDS);

#undef SetIntFlag

#undef SetDblFlag

#undef SetFlag

return floatinfo;

}

PyObject *

PyFloat_FromDouble(double fval)

{

PyFloatObject *op = _Py_FREELIST_POP(PyFloatObject, floats);

if (op == NULL) {

op = PyObject_Malloc(sizeof(PyFloatObject));

if (!op) {

return PyErr_NoMemory();

}

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

}

op->ob_fval = fval;

return (PyObject *) op;

}

static PyObject *

float_from_string_inner(const char *s, Py_ssize_t len, void *obj)

{

double x;

const char *end;

const char *last = s + len;

/* strip leading whitespace */

while (s < last && Py_ISSPACE(*s)) {

s++;

}

if (s == last) {

PyErr_Format(PyExc_ValueError,

"could not convert string to float: "

"%R", obj);

return NULL;

}

/* strip trailing whitespace */

while (s < last - 1 && Py_ISSPACE(last[-1])) {

last--;

}

/* We don't care about overflow or underflow. If the platform

x = PyOS_string_to_double(s, (char **)&end, NULL);

if (end != last) {

PyErr_Format(PyExc_ValueError,

"could not convert string to float: "

"%R", obj);

return NULL;

}

else if (x == -1.0 && PyErr_Occurred()) {

return NULL;

}

else {

return PyFloat_FromDouble(x);

}

}

PyObject *

PyFloat_FromString(PyObject *v)

{

const char *s;

PyObject *s_buffer = NULL;

Py_ssize_t len;

Py_buffer view = {NULL, NULL};

PyObject *result = NULL;

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 if (PyBytes_Check(v)) {

s = PyBytes_AS_STRING(v);

len = PyBytes_GET_SIZE(v);

}

else if (PyByteArray_Check(v)) {

s = PyByteArray_AS_STRING(v);

len = PyByteArray_GET_SIZE(v);

}

else if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) == 0) {

s = (const char *)view.buf;

len = view.len;

/* Copy to NUL-terminated buffer. */

s_buffer = PyBytes_FromStringAndSize(s, len);

if (s_buffer == NULL) {

PyBuffer_Release(&view);

return NULL;

}

s = PyBytes_AS_STRING(s_buffer);

}

else {

PyErr_Format(PyExc_TypeError,

"float() argument must be a string or a real number, not '%.200s'",

Py_TYPE(v)->tp_name);

return NULL;

}

result = _Py_string_to_number_with_underscores(s, len, "float", v, v,

float_from_string_inner);

PyBuffer_Release(&view);

Py_XDECREF(s_buffer);

return result;

}

_PyFloat_ExactDealloc(PyObject *obj)

{

assert(PyFloat_CheckExact(obj));

_Py_FREELIST_FREE(floats, obj, PyObject_Free);

}

static void

float_dealloc(PyObject *op)

{

assert(PyFloat_Check(op));

if (PyFloat_CheckExact(op))

_PyFloat_ExactDealloc(op);

else

Py_TYPE(op)->tp_free(op);

}

PyFloat_AsDouble(PyObject *op)

{

PyNumberMethods *nb;

PyObject *res;

double val;

if (op == NULL) {

PyErr_BadArgument();

return -1;

}

if (PyFloat_Check(op)) {

return PyFloat_AS_DOUBLE(op);

}

nb = Py_TYPE(op)->tp_as_number;

if (nb == NULL || nb->nb_float == NULL) {

if (nb && nb->nb_index) {

PyObject *res = _PyNumber_Index(op);

if (!res) {

return -1;

}

double val = PyLong_AsDouble(res);

Py_DECREF(res);

return val;

}

PyErr_Format(PyExc_TypeError, "must be real number, not %.50s",

Py_TYPE(op)->tp_name);

return -1;

}

res = (*nb->nb_float) (op);

if (res == NULL) {

return -1;

}

if (!PyFloat_CheckExact(res)) {

if (!PyFloat_Check(res)) {

PyErr_Format(PyExc_TypeError,

"%T.__float__() must return a float, not %T",

op, res);

Py_DECREF(res);

return -1;

}

if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,

"%T.__float__() must return a float, not %T. "

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

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

op, res)) {

Py_DECREF(res);

return -1;

}

}

val = PyFloat_AS_DOUBLE(res);

Py_DECREF(res);

return val;

}

#define CONVERT_TO_DOUBLE(obj, dbl) \

if (PyFloat_Check(obj)) \

dbl = PyFloat_AS_DOUBLE(obj); \

else if (_Py_convert_int_to_double(&(obj), &(dbl)) < 0) \

return obj;

_Py_convert_int_to_double(PyObject **v, double *dbl)

{

PyObject *obj = *v;

if (PyLong_Check(obj)) {

*dbl = PyLong_AsDouble(obj);

if (*dbl == -1.0 && PyErr_Occurred()) {

*v = NULL;

return -1;

}

}

else {

*v = Py_NewRef(Py_NotImplemented);

return -1;

}

return 0;

}

static PyObject *

float_repr(PyObject *op)

{

PyFloatObject *v = _PyFloat_CAST(op);

PyObject *result;

char *buf;

buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),

'r', 0,

Py_DTSF_ADD_DOT_0,

NULL);

if (!buf)

return PyErr_NoMemory();

result = _PyUnicode_FromASCII(buf, strlen(buf));

PyMem_Free(buf);

return result;

}

static PyObject*

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

{

double i, j;

int r = 0;

assert(PyFloat_Check(v));

i = PyFloat_AS_DOUBLE(v);

/* Switch on the type of w. Set i and j to doubles to be compared,

if (PyFloat_Check(w))

j = PyFloat_AS_DOUBLE(w);

else if (!isfinite(i)) {

if (PyLong_Check(w))

/* If i is an infinity, its magnitude exceeds any

j = 0.0;

else

goto Unimplemented;

}

else if (PyLong_Check(w)) {

int vsign = i == 0.0 ? 0 : i < 0.0 ? -1 : 1;

int wsign;

int exponent;

(void)PyLong_GetSign(w, &wsign);

if (vsign != wsign) {

/* Magnitudes are irrelevant -- the signs alone

i = (double)vsign;

j = (double)wsign;

goto Compare;

}

/* The signs are the same. */

/* Convert w to a double if it fits. In particular, 0 fits. */

int64_t nbits64 = _PyLong_NumBits(w);

assert(nbits64 >= 0);

assert(!PyErr_Occurred());

if (nbits64 > DBL_MAX_EXP) {

/* This Python integer is larger than any finite C double.

i = (double)vsign;

assert(wsign != 0);

j = wsign * 2.0;

goto Compare;

}

int nbits = (int)nbits64;

if (nbits <= 48) {

j = PyLong_AsDouble(w);

/* It's impossible that <= 48 bits overflowed. */

assert(j != -1.0 || ! PyErr_Occurred());

goto Compare;

}

assert(wsign != 0); /* else nbits was 0 */

assert(vsign != 0); /* if vsign were 0, then since wsign is

(void) frexp(i, &exponent);

/* exponent is the # of bits in v before the radix point;

if (exponent < nbits) {

j = i;

i = 0.0;

goto Compare;

}

if (exponent > nbits) {

j = 0.0;

goto Compare;

}

/* v and w have the same number of bits before the radix

{

double fracpart;

double intpart;

PyObject *result = NULL;

PyObject *vv = NULL;

fracpart = modf(i, &intpart);

if (fracpart != 0.0) {

switch (op) {

/* Non-integer float never equals to an int. */

case Py_EQ:

Py_RETURN_FALSE;

case Py_NE:

Py_RETURN_TRUE;

/* For non-integer float, v <= w <=> v < w.

case Py_LT:

case Py_LE:

op = vsign > 0 ? Py_LT : Py_LE;

break;

/* The same as above, but with opposite directions. */

case Py_GT:

case Py_GE:

op = vsign > 0 ? Py_GE : Py_GT;

break;

}

}

vv = PyLong_FromDouble(intpart);

if (vv == NULL)

goto Error;

r = PyObject_RichCompareBool(vv, w, op);

if (r < 0)

goto Error;

result = PyBool_FromLong(r);

Error:

Py_XDECREF(vv);

return result;

}

} /* else if (PyLong_Check(w)) */

else /* w isn't float or int */

goto Unimplemented;

Compare:

switch (op) {

case Py_EQ:

r = i == j;

break;

case Py_NE:

r = i != j;

break;

case Py_LE:

r = i <= j;

break;

case Py_GE:

r = i >= j;

break;

case Py_LT:

r = i < j;

break;

case Py_GT:

r = i > j;

break;

}

return PyBool_FromLong(r);

Unimplemented:

Py_RETURN_NOTIMPLEMENTED;

}

static Py_hash_t

float_hash(PyObject *op)

{

PyFloatObject *v = _PyFloat_CAST(op);

return _Py_HashDouble(op, v->ob_fval);

}

static PyObject *

float_add(PyObject *v, PyObject *w)

{

double a,b;

CONVERT_TO_DOUBLE(v, a);

CONVERT_TO_DOUBLE(w, b);

a = a + b;

return PyFloat_FromDouble(a);

}

static PyObject *

float_sub(PyObject *v, PyObject *w)

{

double a,b;

CONVERT_TO_DOUBLE(v, a);

CONVERT_TO_DOUBLE(w, b);

a = a - b;

return PyFloat_FromDouble(a);

}

static PyObject *

float_mul(PyObject *v, PyObject *w)

{

double a,b;

CONVERT_TO_DOUBLE(v, a);

CONVERT_TO_DOUBLE(w, b);

a = a * b;

return PyFloat_FromDouble(a);

}

static PyObject *

float_div(PyObject *v, PyObject *w)

{

double a,b;

CONVERT_TO_DOUBLE(v, a);

CONVERT_TO_DOUBLE(w, b);

if (b == 0.0) {

PyErr_SetString(PyExc_ZeroDivisionError,

"division by zero");

return NULL;

}

a = a / b;

return PyFloat_FromDouble(a);

}

static PyObject *

float_rem(PyObject *v, PyObject *w)

{

double vx, wx;

double mod;

CONVERT_TO_DOUBLE(v, vx);

CONVERT_TO_DOUBLE(w, wx);

if (wx == 0.0) {

PyErr_SetString(PyExc_ZeroDivisionError,

"division by zero");

return NULL;

}

mod = fmod(vx, wx);

if (mod) {

/* ensure the remainder has the same sign as the denominator */

if ((wx < 0) != (mod < 0)) {

mod += wx;

}

}

else {

/* the remainder is zero, and in the presence of signed zeroes

mod = copysign(0.0, wx);

}

return PyFloat_FromDouble(mod);

}

static void

_float_div_mod(double vx, double wx, double *floordiv, double *mod)

{

double div;

*mod = fmod(vx, wx);

/* fmod is typically exact, so vx-mod is *mathematically* an

div = (vx - *mod) / wx;

if (*mod) {

/* ensure the remainder has the same sign as the denominator */

if ((wx < 0) != (*mod < 0)) {

*mod += wx;

div -= 1.0;

}

}

else {

/* the remainder is zero, and in the presence of signed zeroes

*mod = copysign(0.0, wx);

}

/* snap quotient to nearest integral value */

if (div) {

*floordiv = floor(div);

if (div - *floordiv > 0.5) {

*floordiv += 1.0;

}

}

else {

/* div is zero - get the same sign as the true quotient */

*floordiv = copysign(0.0, vx / wx); /* zero w/ sign of vx/wx */

}

}

static PyObject *

float_divmod(PyObject *v, PyObject *w)

{

double vx, wx;

double mod, floordiv;

CONVERT_TO_DOUBLE(v, vx);

CONVERT_TO_DOUBLE(w, wx);

if (wx == 0.0) {

PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");

return NULL;

}

_float_div_mod(vx, wx, &floordiv, &mod);

return Py_BuildValue("(dd)", floordiv, mod);

}

static PyObject *

float_floor_div(PyObject *v, PyObject *w)

{

double vx, wx;

double mod, floordiv;

CONVERT_TO_DOUBLE(v, vx);

CONVERT_TO_DOUBLE(w, wx);

if (wx == 0.0) {

PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");

return NULL;

}

_float_div_mod(vx, wx, &floordiv, &mod);

return PyFloat_FromDouble(floordiv);

}

#define DOUBLE_IS_ODD_INTEGER(x) (fmod(fabs(x), 2.0) == 1.0)

static PyObject *

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

{

double iv, iw, ix;

int negate_result = 0;

if ((PyObject *)z != Py_None) {

PyErr_SetString(PyExc_TypeError, "pow() 3rd argument not "

"allowed unless all arguments are integers");

return NULL;

}

CONVERT_TO_DOUBLE(v, iv);

CONVERT_TO_DOUBLE(w, iw);

/* Sort out special cases here instead of relying on pow() */

if (iw == 0) { /* v**0 is 1, even 0**0 */

return PyFloat_FromDouble(1.0);

}

if (isnan(iv)) { /* nan**w = nan, unless w == 0 */

return PyFloat_FromDouble(iv);

}

if (isnan(iw)) { /* v**nan = nan, unless v == 1; 1**nan = 1 */

return PyFloat_FromDouble(iv == 1.0 ? 1.0 : iw);

}

if (isinf(iw)) {

/* v**inf is: 0.0 if abs(v) < 1; 1.0 if abs(v) == 1; inf if

iv = fabs(iv);

if (iv == 1.0)

return PyFloat_FromDouble(1.0);

else if ((iw > 0.0) == (iv > 1.0))

return PyFloat_FromDouble(fabs(iw)); /* return inf */

else

return PyFloat_FromDouble(0.0);

}

if (isinf(iv)) {

/* (+-inf)**w is: inf for w positive, 0 for w negative; in

int iw_is_odd = DOUBLE_IS_ODD_INTEGER(iw);

if (iw > 0.0)

return PyFloat_FromDouble(iw_is_odd ? iv : fabs(iv));

else

return PyFloat_FromDouble(iw_is_odd ?

copysign(0.0, iv) : 0.0);

}

if (iv == 0.0) { /* 0**w is: 0 for w positive, 1 for w zero

int iw_is_odd = DOUBLE_IS_ODD_INTEGER(iw);

if (iw < 0.0) {

PyErr_SetString(PyExc_ZeroDivisionError,

"zero to a negative power");

return NULL;

}

/* use correct sign if iw is odd */

return PyFloat_FromDouble(iw_is_odd ? iv : 0.0);

}

if (iv < 0.0) {

/* Whether this is an error is a mess, and bumps into libm

if (iw != floor(iw)) {

/* Negative numbers raised to fractional powers

return PyComplex_Type.tp_as_number->nb_power(v, w, z);

}

/* iw is an exact integer, albeit perhaps a very large

iv = -iv;

negate_result = DOUBLE_IS_ODD_INTEGER(iw);

}

if (iv == 1.0) { /* 1**w is 1, even 1**inf and 1**nan */

/* (-1) ** large_integer also ends up here. Here's an

return PyFloat_FromDouble(negate_result ? -1.0 : 1.0);

}

/* Now iv and iw are finite, iw is nonzero, and iv is

errno = 0;

ix = pow(iv, iw);

_Py_ADJUST_ERANGE1(ix);

if (negate_result)

ix = -ix;

if (errno != 0) {

/* We don't expect any errno value other than ERANGE, but

PyErr_SetFromErrno(errno == ERANGE ? PyExc_OverflowError :

PyExc_ValueError);

return NULL;

}

return PyFloat_FromDouble(ix);

}

#undef DOUBLE_IS_ODD_INTEGER

static PyObject *

float_neg(PyObject *op)

{

PyFloatObject *v = _PyFloat_CAST(op);

return PyFloat_FromDouble(-v->ob_fval);

}

static PyObject *

float_abs(PyObject *op)

{

PyFloatObject *v = _PyFloat_CAST(op);

return PyFloat_FromDouble(fabs(v->ob_fval));

}

static int

float_bool(PyObject *op)

{

PyFloatObject *v = _PyFloat_CAST(op);

return v->ob_fval != 0.0;

}

static PyObject *

float_is_integer_impl(PyObject *self)

{

double x = PyFloat_AsDouble(self);

PyObject *o;

if (x == -1.0 && PyErr_Occurred())

return NULL;

if (!isfinite(x))

Py_RETURN_FALSE;

errno = 0;

o = (floor(x) == x) ? Py_True : Py_False;

if (errno != 0) {

PyErr_SetFromErrno(errno == ERANGE ? PyExc_OverflowError :

PyExc_ValueError);

return NULL;

}

return Py_NewRef(o);

}

static PyObject *

float___trunc___impl(PyObject *self)

{

return PyLong_FromDouble(PyFloat_AS_DOUBLE(self));

}

static PyObject *

float___floor___impl(PyObject *self)

{

double x = PyFloat_AS_DOUBLE(self);

return PyLong_FromDouble(floor(x));

}

static PyObject *

float___ceil___impl(PyObject *self)

{

double x = PyFloat_AS_DOUBLE(self);

return PyLong_FromDouble(ceil(x));

}

#if _PY_SHORT_FLOAT_REPR == 1

static PyObject *

double_round(double x, int ndigits) {

double rounded;

Py_ssize_t buflen, mybuflen=100;

char *buf, *buf_end, shortbuf[100], *mybuf=shortbuf;

int decpt, sign;

PyObject *result = NULL;

_Py_SET_53BIT_PRECISION_HEADER;

/* round to a decimal string */

_Py_SET_53BIT_PRECISION_START;

buf = _Py_dg_dtoa(x, 3, ndigits, &decpt, &sign, &buf_end);

_Py_SET_53BIT_PRECISION_END;

if (buf == NULL) {

PyErr_NoMemory();

return NULL;

}

/* Get new buffer if shortbuf is too small. Space needed <= buf_end -

buflen = buf_end - buf;

if (buflen + 8 > mybuflen) {

mybuflen = buflen+8;

mybuf = (char *)PyMem_Malloc(mybuflen);

if (mybuf == NULL) {

PyErr_NoMemory();

goto exit;

}

}

/* copy buf to mybuf, adding exponent, sign and leading 0 */

PyOS_snprintf(mybuf, mybuflen, "%s0%se%d", (sign ? "-" : ""),

buf, decpt - (int)buflen);

/* and convert the resulting string back to a double */

errno = 0;

_Py_SET_53BIT_PRECISION_START;

rounded = _Py_dg_strtod(mybuf, NULL);

_Py_SET_53BIT_PRECISION_END;

if (errno == ERANGE && fabs(rounded) >= 1.)

PyErr_SetString(PyExc_OverflowError,

"rounded value too large to represent");

else

result = PyFloat_FromDouble(rounded);

/* done computing value; now clean up */

if (mybuf != shortbuf)

PyMem_Free(mybuf);

exit:

_Py_dg_freedtoa(buf);

return result;

}

#else // _PY_SHORT_FLOAT_REPR == 0

static PyObject *

double_round(double x, int ndigits) {

double pow1, pow2, y, z;

if (ndigits >= 0) {

if (ndigits > 22) {

/* pow1 and pow2 are each safe from overflow, but

pow1 = pow(10.0, (double)(ndigits-22));

pow2 = 1e22;

}

else {

pow1 = pow(10.0, (double)ndigits);

pow2 = 1.0;

}

y = (x*pow1)*pow2;

/* if y overflows, then rounded value is exactly x */

if (!isfinite(y))

return PyFloat_FromDouble(x);

}

else {

pow1 = pow(10.0, (double)-ndigits);

pow2 = 1.0; /* unused; silences a gcc compiler warning */

y = x / pow1;

}

z = round(y);

if (fabs(y-z) == 0.5)

/* halfway between two integers; use round-half-even */

z = 2.0*round(y/2.0);

if (ndigits >= 0)

z = (z / pow2) / pow1;

else

z *= pow1;

/* if computation resulted in overflow, raise OverflowError */

if (!isfinite(z)) {

PyErr_SetString(PyExc_OverflowError,

"overflow occurred during round");