--- /dev/null
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(float_is_integer__doc__,
+"is_integer($self, /)\n"
+"--\n"
+"\n"
+"Return True if the float is an integer.");
+
+#define FLOAT_IS_INTEGER_METHODDEF \
+ {"is_integer", (PyCFunction)float_is_integer, METH_NOARGS, float_is_integer__doc__},
+
+static PyObject *
+float_is_integer_impl(PyObject *self);
+
+static PyObject *
+float_is_integer(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return float_is_integer_impl(self);
+}
+
+PyDoc_STRVAR(float___trunc____doc__,
+"__trunc__($self, /)\n"
+"--\n"
+"\n"
+"Return the Integral closest to x between 0 and x.");
+
+#define FLOAT___TRUNC___METHODDEF \
+ {"__trunc__", (PyCFunction)float___trunc__, METH_NOARGS, float___trunc____doc__},
+
+static PyObject *
+float___trunc___impl(PyObject *self);
+
+static PyObject *
+float___trunc__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return float___trunc___impl(self);
+}
+
+PyDoc_STRVAR(float___round____doc__,
+"__round__($self, ndigits=None, /)\n"
+"--\n"
+"\n"
+"Return the Integral closest to x, rounding half toward even.\n"
+"\n"
+"When an argument is passed, work like built-in round(x, ndigits).");
+
+#define FLOAT___ROUND___METHODDEF \
+ {"__round__", (PyCFunction)float___round__, METH_FASTCALL, float___round____doc__},
+
+static PyObject *
+float___round___impl(PyObject *self, PyObject *o_ndigits);
+
+static PyObject *
+float___round__(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ PyObject *o_ndigits = NULL;
+
+ if (!_PyArg_UnpackStack(args, nargs, "__round__",
+ 0, 1,
+ &o_ndigits)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("__round__", kwnames)) {
+ goto exit;
+ }
+ return_value = float___round___impl(self, o_ndigits);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(float_conjugate__doc__,
+"conjugate($self, /)\n"
+"--\n"
+"\n"
+"Return self, the complex conjugate of any float.");
+
+#define FLOAT_CONJUGATE_METHODDEF \
+ {"conjugate", (PyCFunction)float_conjugate, METH_NOARGS, float_conjugate__doc__},
+
+static PyObject *
+float_conjugate_impl(PyObject *self);
+
+static PyObject *
+float_conjugate(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return float_conjugate_impl(self);
+}
+
+PyDoc_STRVAR(float_hex__doc__,
+"hex($self, /)\n"
+"--\n"
+"\n"
+"Return a hexadecimal representation of a floating-point number.\n"
+"\n"
+">>> (-0.1).hex()\n"
+"\'-0x1.999999999999ap-4\'\n"
+">>> 3.14159.hex()\n"
+"\'0x1.921f9f01b866ep+1\'");
+
+#define FLOAT_HEX_METHODDEF \
+ {"hex", (PyCFunction)float_hex, METH_NOARGS, float_hex__doc__},
+
+static PyObject *
+float_hex_impl(PyObject *self);
+
+static PyObject *
+float_hex(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return float_hex_impl(self);
+}
+
+PyDoc_STRVAR(float_fromhex__doc__,
+"fromhex($type, string, /)\n"
+"--\n"
+"\n"
+"Create a floating-point number from a hexadecimal string.\n"
+"\n"
+">>> float.fromhex(\'0x1.ffffp10\')\n"
+"2047.984375\n"
+">>> float.fromhex(\'-0x1p-1074\')\n"
+"-5e-324");
+
+#define FLOAT_FROMHEX_METHODDEF \
+ {"fromhex", (PyCFunction)float_fromhex, METH_O|METH_CLASS, float_fromhex__doc__},
+
+PyDoc_STRVAR(float_as_integer_ratio__doc__,
+"as_integer_ratio($self, /)\n"
+"--\n"
+"\n"
+"Return integer ratio.\n"
+"\n"
+"Return a pair of integers, whose ratio is exactly equal to the original float\n"
+"and with a positive denominator.\n"
+"\n"
+"Raise OverflowError on infinities and a ValueError on NaNs.\n"
+"\n"
+">>> (10.0).as_integer_ratio()\n"
+"(10, 1)\n"
+">>> (0.0).as_integer_ratio()\n"
+"(0, 1)\n"
+">>> (-.25).as_integer_ratio()\n"
+"(-1, 4)");
+
+#define FLOAT_AS_INTEGER_RATIO_METHODDEF \
+ {"as_integer_ratio", (PyCFunction)float_as_integer_ratio, METH_NOARGS, float_as_integer_ratio__doc__},
+
+static PyObject *
+float_as_integer_ratio_impl(PyObject *self);
+
+static PyObject *
+float_as_integer_ratio(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return float_as_integer_ratio_impl(self);
+}
+
+PyDoc_STRVAR(float___getnewargs____doc__,
+"__getnewargs__($self, /)\n"
+"--\n"
+"\n");
+
+#define FLOAT___GETNEWARGS___METHODDEF \
+ {"__getnewargs__", (PyCFunction)float___getnewargs__, METH_NOARGS, float___getnewargs____doc__},
+
+static PyObject *
+float___getnewargs___impl(PyObject *self);
+
+static PyObject *
+float___getnewargs__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return float___getnewargs___impl(self);
+}
+
+PyDoc_STRVAR(float___getformat____doc__,
+"__getformat__($type, typestr, /)\n"
+"--\n"
+"\n"
+"You probably don\'t want to use this function.\n"
+"\n"
+" typestr\n"
+" Must be \'double\' or \'float\'.\n"
+"\n"
+"It exists mainly to be used in Python\'s test suite.\n"
+"\n"
+"This function returns whichever of \'unknown\', \'IEEE, big-endian\' or \'IEEE,\n"
+"little-endian\' best describes the format of floating point numbers used by the\n"
+"C type named by typestr.");
+
+#define FLOAT___GETFORMAT___METHODDEF \
+ {"__getformat__", (PyCFunction)float___getformat__, METH_O|METH_CLASS, float___getformat____doc__},
+
+static PyObject *
+float___getformat___impl(PyTypeObject *type, const char *typestr);
+
+static PyObject *
+float___getformat__(PyTypeObject *type, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ const char *typestr;
+
+ if (!PyArg_Parse(arg, "s:__getformat__", &typestr)) {
+ goto exit;
+ }
+ return_value = float___getformat___impl(type, typestr);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(float___set_format____doc__,
+"__set_format__($type, typestr, fmt, /)\n"
+"--\n"
+"\n"
+"You probably don\'t want to use this function.\n"
+"\n"
+" typestr\n"
+" Must be \'double\' or \'float\'.\n"
+" fmt\n"
+" Must be one of \'unknown\', \'IEEE, big-endian\' or \'IEEE, little-endian\',\n"
+" and in addition can only be one of the latter two if it appears to\n"
+" match the underlying C reality.\n"
+"\n"
+"It exists mainly to be used in Python\'s test suite.\n"
+"\n"
+"Override the automatic determination of C-level floating point type.\n"
+"This affects how floats are converted to and from binary strings.");
+
+#define FLOAT___SET_FORMAT___METHODDEF \
+ {"__set_format__", (PyCFunction)float___set_format__, METH_FASTCALL|METH_CLASS, float___set_format____doc__},
+
+static PyObject *
+float___set_format___impl(PyTypeObject *type, const char *typestr,
+ const char *fmt);
+
+static PyObject *
+float___set_format__(PyTypeObject *type, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ const char *typestr;
+ const char *fmt;
+
+ if (!_PyArg_ParseStack(args, nargs, "ss:__set_format__",
+ &typestr, &fmt)) {
+ goto exit;
+ }
+
+ if (!_PyArg_NoStackKeywords("__set_format__", kwnames)) {
+ goto exit;
+ }
+ return_value = float___set_format___impl(type, typestr, fmt);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(float___format____doc__,
+"__format__($self, format_spec, /)\n"
+"--\n"
+"\n"
+"Formats the float according to format_spec.");
+
+#define FLOAT___FORMAT___METHODDEF \
+ {"__format__", (PyCFunction)float___format__, METH_O, float___format____doc__},
+
+static PyObject *
+float___format___impl(PyObject *self, PyObject *format_spec);
+
+static PyObject *
+float___format__(PyObject *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *format_spec;
+
+ if (!PyArg_Parse(arg, "U:__format__", &format_spec)) {
+ goto exit;
+ }
+ return_value = float___format___impl(self, format_spec);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=9257442b321d6a8b input=a9049054013a1b77]*/
#include <ctype.h>
#include <float.h>
+/*[clinic input]
+class float "PyObject *" "&PyFloat_Type"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=dd0003f68f144284]*/
+
+#include "clinic/floatobject.c.h"
/* Special free list
free_list is a singly-linked list of available PyFloatObjects, linked
return v->ob_fval != 0.0;
}
+/*[clinic input]
+float.is_integer
+
+Return True if the float is an integer.
+[clinic start generated code]*/
+
static PyObject *
-float_is_integer(PyObject *v)
+float_is_integer_impl(PyObject *self)
+/*[clinic end generated code: output=7112acf95a4d31ea input=311810d3f777e10d]*/
{
- double x = PyFloat_AsDouble(v);
+ double x = PyFloat_AsDouble(self);
PyObject *o;
if (x == -1.0 && PyErr_Occurred())
}
#endif
+/*[clinic input]
+float.__trunc__
+
+Return the Integral closest to x between 0 and x.
+[clinic start generated code]*/
+
static PyObject *
-float_trunc(PyObject *v)
+float___trunc___impl(PyObject *self)
+/*[clinic end generated code: output=dd3e289dd4c6b538 input=591b9ba0d650fdff]*/
{
- double x = PyFloat_AsDouble(v);
+ double x = PyFloat_AsDouble(self);
double wholepart; /* integral portion of x, rounded toward 0 */
(void)modf(x, &wholepart);
/* round a Python float v to the closest multiple of 10**-ndigits */
+/*[clinic input]
+float.__round__
+
+ ndigits as o_ndigits: object = NULL
+ /
+
+Return the Integral closest to x, rounding half toward even.
+
+When an argument is passed, work like built-in round(x, ndigits).
+[clinic start generated code]*/
+
static PyObject *
-float_round(PyObject *v, PyObject *args)
+float___round___impl(PyObject *self, PyObject *o_ndigits)
+/*[clinic end generated code: output=374c36aaa0f13980 input=1ca2316b510293b8]*/
{
double x, rounded;
- PyObject *o_ndigits = NULL;
Py_ssize_t ndigits;
- x = PyFloat_AsDouble(v);
- if (!PyArg_ParseTuple(args, "|O", &o_ndigits))
- return NULL;
+ x = PyFloat_AsDouble(self);
if (o_ndigits == NULL || o_ndigits == Py_None) {
/* single-argument round or with None ndigits:
* round to nearest integer */
return v;
}
+/*[clinic input]
+float.conjugate
+
+Return self, the complex conjugate of any float.
+[clinic start generated code]*/
+
+static PyObject *
+float_conjugate_impl(PyObject *self)
+/*[clinic end generated code: output=8ca292c2479194af input=82ba6f37a9ff91dd]*/
+{
+ return float_float(self);
+}
+
/* turn ASCII hex characters into integer values and vice versa */
static char
of the form 4k+1. */
#define TOHEX_NBITS DBL_MANT_DIG + 3 - (DBL_MANT_DIG+2)%4
+/*[clinic input]
+float.hex
+
+Return a hexadecimal representation of a floating-point number.
+
+>>> (-0.1).hex()
+'-0x1.999999999999ap-4'
+>>> 3.14159.hex()
+'0x1.921f9f01b866ep+1'
+[clinic start generated code]*/
+
static PyObject *
-float_hex(PyObject *v)
+float_hex_impl(PyObject *self)
+/*[clinic end generated code: output=0ebc9836e4d302d4 input=bec1271a33d47e67]*/
{
double x, m;
int e, shift, i, si, esign;
trailing NUL byte. */
char s[(TOHEX_NBITS-1)/4+3];
- CONVERT_TO_DOUBLE(v, x);
+ CONVERT_TO_DOUBLE(self, x);
if (Py_IS_NAN(x) || Py_IS_INFINITY(x))
- return float_repr((PyFloatObject *)v);
+ return float_repr((PyFloatObject *)self);
if (x == 0.0) {
if (copysign(1.0, x) == -1.0)
return PyUnicode_FromFormat("0x%sp%c%d", s, esign, e);
}
-PyDoc_STRVAR(float_hex_doc,
-"float.hex() -> string\n\
-\n\
-Return a hexadecimal representation of a floating-point number.\n\
->>> (-0.1).hex()\n\
-'-0x1.999999999999ap-4'\n\
->>> 3.14159.hex()\n\
-'0x1.921f9f01b866ep+1'");
-
/* Convert a hexadecimal string to a float. */
+/*[clinic input]
+@classmethod
+float.fromhex
+
+ string: object
+ /
+
+Create a floating-point number from a hexadecimal string.
+
+>>> float.fromhex('0x1.ffffp10')
+2047.984375
+>>> float.fromhex('-0x1p-1074')
+-5e-324
+[clinic start generated code]*/
+
static PyObject *
-float_fromhex(PyObject *cls, PyObject *arg)
+float_fromhex(PyTypeObject *type, PyObject *string)
+/*[clinic end generated code: output=46c0274d22b78e82 input=0407bebd354bca89]*/
{
PyObject *result;
double x;
* exp+4*ndigits and exp-4*ndigits are within the range of a long.
*/
- s = PyUnicode_AsUTF8AndSize(arg, &length);
+ s = PyUnicode_AsUTF8AndSize(string, &length);
if (s == NULL)
return NULL;
s_end = s + length;
if (s != s_end)
goto parse_error;
result = PyFloat_FromDouble(negate ? -x : x);
- if (cls != (PyObject *)&PyFloat_Type && result != NULL) {
- Py_SETREF(result, PyObject_CallFunctionObjArgs(cls, result, NULL));
+ if (type != &PyFloat_Type && result != NULL) {
+ Py_SETREF(result, PyObject_CallFunctionObjArgs((PyObject *)type, result, NULL));
}
return result;
return NULL;
}
-PyDoc_STRVAR(float_fromhex_doc,
-"float.fromhex(string) -> float\n\
-\n\
-Create a floating-point number from a hexadecimal string.\n\
->>> float.fromhex('0x1.ffffp10')\n\
-2047.984375\n\
->>> float.fromhex('-0x1p-1074')\n\
--5e-324");
+/*[clinic input]
+float.as_integer_ratio
+Return integer ratio.
+
+Return a pair of integers, whose ratio is exactly equal to the original float
+and with a positive denominator.
+
+Raise OverflowError on infinities and a ValueError on NaNs.
+
+>>> (10.0).as_integer_ratio()
+(10, 1)
+>>> (0.0).as_integer_ratio()
+(0, 1)
+>>> (-.25).as_integer_ratio()
+(-1, 4)
+[clinic start generated code]*/
static PyObject *
-float_as_integer_ratio(PyObject *v, PyObject *unused)
+float_as_integer_ratio_impl(PyObject *self)
+/*[clinic end generated code: output=65f25f0d8d30a712 input=e21d08b4630c2e44]*/
{
- double self;
+ double self_double;
double float_part;
int exponent;
int i;
PyObject *result_pair = NULL;
PyNumberMethods *long_methods = PyLong_Type.tp_as_number;
- CONVERT_TO_DOUBLE(v, self);
+ CONVERT_TO_DOUBLE(self, self_double);
- if (Py_IS_INFINITY(self)) {
+ if (Py_IS_INFINITY(self_double)) {
PyErr_SetString(PyExc_OverflowError,
"cannot convert Infinity to integer ratio");
return NULL;
}
- if (Py_IS_NAN(self)) {
+ if (Py_IS_NAN(self_double)) {
PyErr_SetString(PyExc_ValueError,
"cannot convert NaN to integer ratio");
return NULL;
}
PyFPE_START_PROTECT("as_integer_ratio", goto error);
- float_part = frexp(self, &exponent); /* self == float_part * 2**exponent exactly */
+ float_part = frexp(self_double, &exponent); /* self_double == float_part * 2**exponent exactly */
PyFPE_END_PROTECT(float_part);
for (i=0; i<300 && float_part != floor(float_part) ; i++) {
return result_pair;
}
-PyDoc_STRVAR(float_as_integer_ratio_doc,
-"float.as_integer_ratio() -> (int, int)\n"
-"\n"
-"Return a pair of integers, whose ratio is exactly equal to the original\n"
-"float and with a positive denominator.\n"
-"Raise OverflowError on infinities and a ValueError on NaNs.\n"
-"\n"
-">>> (10.0).as_integer_ratio()\n"
-"(10, 1)\n"
-">>> (0.0).as_integer_ratio()\n"
-"(0, 1)\n"
-">>> (-.25).as_integer_ratio()\n"
-"(-1, 4)");
-
-
static PyObject *
float_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
return newobj;
}
+/*[clinic input]
+float.__getnewargs__
+[clinic start generated code]*/
+
static PyObject *
-float_getnewargs(PyFloatObject *v)
+float___getnewargs___impl(PyObject *self)
+/*[clinic end generated code: output=873258c9d206b088 input=002279d1d77891e6]*/
{
- return Py_BuildValue("(d)", v->ob_fval);
+ return Py_BuildValue("(d)", ((PyFloatObject *)self)->ob_fval);
}
/* this is for the benefit of the pack/unpack routines below */
static float_format_type double_format, float_format;
static float_format_type detected_double_format, detected_float_format;
+/*[clinic input]
+@classmethod
+float.__getformat__
+
+ typestr: str
+ Must be 'double' or 'float'.
+ /
+
+You probably don't want to use this function.
+
+It exists mainly to be used in Python's test suite.
+
+This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
+little-endian' best describes the format of floating point numbers used by the
+C type named by typestr.
+[clinic start generated code]*/
+
static PyObject *
-float_getformat(PyTypeObject *v, PyObject* arg)
+float___getformat___impl(PyTypeObject *type, const char *typestr)
+/*[clinic end generated code: output=2bfb987228cc9628 input=d5a52600f835ad67]*/
{
- const char *s;
float_format_type r;
- if (!PyUnicode_Check(arg)) {
- PyErr_Format(PyExc_TypeError,
- "__getformat__() argument must be string, not %.500s",
- Py_TYPE(arg)->tp_name);
- return NULL;
- }
- s = PyUnicode_AsUTF8(arg);
- if (s == NULL)
- return NULL;
- if (strcmp(s, "double") == 0) {
+ if (strcmp(typestr, "double") == 0) {
r = double_format;
}
- else if (strcmp(s, "float") == 0) {
+ else if (strcmp(typestr, "float") == 0) {
r = float_format;
}
else {
}
}
-PyDoc_STRVAR(float_getformat_doc,
-"float.__getformat__(typestr) -> string\n"
-"\n"
-"You probably don't want to use this function. It exists mainly to be\n"
-"used in Python's test suite.\n"
-"\n"
-"typestr must be 'double' or 'float'. This function returns whichever of\n"
-"'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the\n"
-"format of floating point numbers used by the C type named by typestr.");
+/*[clinic input]
+@classmethod
+float.__set_format__
+
+ typestr: str
+ Must be 'double' or 'float'.
+ fmt: str
+ Must be one of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian',
+ and in addition can only be one of the latter two if it appears to
+ match the underlying C reality.
+ /
+
+You probably don't want to use this function.
+
+It exists mainly to be used in Python's test suite.
+
+Override the automatic determination of C-level floating point type.
+This affects how floats are converted to and from binary strings.
+[clinic start generated code]*/
static PyObject *
-float_setformat(PyTypeObject *v, PyObject* args)
+float___set_format___impl(PyTypeObject *type, const char *typestr,
+ const char *fmt)
+/*[clinic end generated code: output=504460f5dc85acbd input=5306fa2b81a997e4]*/
{
- char* typestr;
- char* format;
float_format_type f;
float_format_type detected;
float_format_type *p;
- if (!PyArg_ParseTuple(args, "ss:__setformat__", &typestr, &format))
- return NULL;
-
if (strcmp(typestr, "double") == 0) {
p = &double_format;
detected = detected_double_format;
return NULL;
}
- if (strcmp(format, "unknown") == 0) {
+ if (strcmp(fmt, "unknown") == 0) {
f = unknown_format;
}
- else if (strcmp(format, "IEEE, little-endian") == 0) {
+ else if (strcmp(fmt, "IEEE, little-endian") == 0) {
f = ieee_little_endian_format;
}
- else if (strcmp(format, "IEEE, big-endian") == 0) {
+ else if (strcmp(fmt, "IEEE, big-endian") == 0) {
f = ieee_big_endian_format;
}
else {
Py_RETURN_NONE;
}
-PyDoc_STRVAR(float_setformat_doc,
-"float.__setformat__(typestr, fmt) -> None\n"
-"\n"
-"You probably don't want to use this function. It exists mainly to be\n"
-"used in Python's test suite.\n"
-"\n"
-"typestr must be 'double' or 'float'. fmt must be one of 'unknown',\n"
-"'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be\n"
-"one of the latter two if it appears to match the underlying C reality.\n"
-"\n"
-"Override the automatic determination of C-level floating point type.\n"
-"This affects how floats are converted to and from binary strings.");
+static PyObject *
+float_getreal(PyObject *v, void *closure)
+{
+ return float_float(v);
+}
static PyObject *
-float_getzero(PyObject *v, void *closure)
+float_getimag(PyObject *v, void *closure)
{
return PyFloat_FromDouble(0.0);
}
+/*[clinic input]
+float.__format__
+
+ format_spec: unicode
+ /
+
+Formats the float according to format_spec.
+[clinic start generated code]*/
+
static PyObject *
-float__format__(PyObject *self, PyObject *args)
+float___format___impl(PyObject *self, PyObject *format_spec)
+/*[clinic end generated code: output=b260e52a47eade56 input=2ece1052211fd0e6]*/
{
- PyObject *format_spec;
_PyUnicodeWriter writer;
int ret;
- if (!PyArg_ParseTuple(args, "U:__format__", &format_spec))
- return NULL;
-
_PyUnicodeWriter_Init(&writer);
ret = _PyFloat_FormatAdvancedWriter(
&writer,
return _PyUnicodeWriter_Finish(&writer);
}
-PyDoc_STRVAR(float__format__doc,
-"float.__format__(format_spec) -> string\n"
-"\n"
-"Formats the float according to format_spec.");
-
-
static PyMethodDef float_methods[] = {
- {"conjugate", (PyCFunction)float_float, METH_NOARGS,
- "Return self, the complex conjugate of any float."},
- {"__trunc__", (PyCFunction)float_trunc, METH_NOARGS,
- "Return the Integral closest to x between 0 and x."},
- {"__round__", (PyCFunction)float_round, METH_VARARGS,
- "Return the Integral closest to x, rounding half toward even.\n"
- "When an argument is passed, work like built-in round(x, ndigits)."},
- {"as_integer_ratio", (PyCFunction)float_as_integer_ratio, METH_NOARGS,
- float_as_integer_ratio_doc},
- {"fromhex", (PyCFunction)float_fromhex,
- METH_O|METH_CLASS, float_fromhex_doc},
- {"hex", (PyCFunction)float_hex,
- METH_NOARGS, float_hex_doc},
- {"is_integer", (PyCFunction)float_is_integer, METH_NOARGS,
- "Return True if the float is an integer."},
+ FLOAT_CONJUGATE_METHODDEF
+ FLOAT___TRUNC___METHODDEF
+ FLOAT___ROUND___METHODDEF
+ FLOAT_AS_INTEGER_RATIO_METHODDEF
+ FLOAT_FROMHEX_METHODDEF
+ FLOAT_HEX_METHODDEF
+ FLOAT_IS_INTEGER_METHODDEF
#if 0
{"is_inf", (PyCFunction)float_is_inf, METH_NOARGS,
"Return True if the float is positive or negative infinite."},
{"is_nan", (PyCFunction)float_is_nan, METH_NOARGS,
"Return True if the float is not a number (NaN)."},
#endif
- {"__getnewargs__", (PyCFunction)float_getnewargs, METH_NOARGS},
- {"__getformat__", (PyCFunction)float_getformat,
- METH_O|METH_CLASS, float_getformat_doc},
- {"__setformat__", (PyCFunction)float_setformat,
- METH_VARARGS|METH_CLASS, float_setformat_doc},
- {"__format__", (PyCFunction)float__format__,
- METH_VARARGS, float__format__doc},
+ FLOAT___GETNEWARGS___METHODDEF
+ FLOAT___GETFORMAT___METHODDEF
+ FLOAT___SET_FORMAT___METHODDEF
+ FLOAT___FORMAT___METHODDEF
{NULL, NULL} /* sentinel */
};
static PyGetSetDef float_getset[] = {
{"real",
- (getter)float_float, (setter)NULL,
+ float_getreal, (setter)NULL,
"the real part of a complex number",
NULL},
{"imag",
- (getter)float_getzero, (setter)NULL,
+ float_getimag, (setter)NULL,
"the imaginary part of a complex number",
NULL},
{NULL} /* Sentinel */
static PyNumberMethods float_as_number = {
- float_add, /*nb_add*/
- float_sub, /*nb_subtract*/
- float_mul, /*nb_multiply*/
- float_rem, /*nb_remainder*/
- float_divmod, /*nb_divmod*/
- float_pow, /*nb_power*/
- (unaryfunc)float_neg, /*nb_negative*/
- (unaryfunc)float_float, /*nb_positive*/
- (unaryfunc)float_abs, /*nb_absolute*/
- (inquiry)float_bool, /*nb_bool*/
- 0, /*nb_invert*/
- 0, /*nb_lshift*/
- 0, /*nb_rshift*/
- 0, /*nb_and*/
- 0, /*nb_xor*/
- 0, /*nb_or*/
- float_trunc, /*nb_int*/
- 0, /*nb_reserved*/
- float_float, /*nb_float*/
+ float_add, /* nb_add */
+ float_sub, /* nb_subtract */
+ float_mul, /* nb_multiply */
+ float_rem, /* nb_remainder */
+ float_divmod, /* nb_divmod */
+ float_pow, /* nb_power */
+ (unaryfunc)float_neg, /* nb_negative */
+ float_float, /* nb_positive */
+ (unaryfunc)float_abs, /* nb_absolute */
+ (inquiry)float_bool, /* nb_bool */
+ 0, /* nb_invert */
+ 0, /* nb_lshift */
+ 0, /* nb_rshift */
+ 0, /* nb_and */
+ 0, /* nb_xor */
+ 0, /* nb_or */
+ float___trunc___impl, /* nb_int */
+ 0, /* nb_reserved */
+ float_float, /* nb_float */
0, /* nb_inplace_add */
0, /* nb_inplace_subtract */
0, /* nb_inplace_multiply */
0, /* nb_inplace_and */
0, /* nb_inplace_xor */
0, /* nb_inplace_or */
- float_floor_div, /* nb_floor_divide */
+ float_floor_div, /* nb_floor_divide */
float_div, /* nb_true_divide */
0, /* nb_inplace_floor_divide */
0, /* nb_inplace_true_divide */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
float_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
projects / python / commitdiff