blob: 364b913b47275631c5b79b91eca89baf02cb82a6 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002/* Float object interface */
3
4/*
Guido van Rossumcaa63801995-01-12 11:45:45 +00005PyFloatObject represents a (double precision) floating point number.
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00006*/
7
Fred Drakeea9cb5a2000-07-09 00:20:36 +00008#ifndef Py_FLOATOBJECT_H
9#define Py_FLOATOBJECT_H
10#ifdef __cplusplus
11extern "C" {
12#endif
13
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000014typedef struct {
Fred Drakeea9cb5a2000-07-09 00:20:36 +000015 PyObject_HEAD
16 double ob_fval;
Guido van Rossumcaa63801995-01-12 11:45:45 +000017} PyFloatObject;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000018
Mark Hammond91a681d2002-08-12 07:21:58 +000019PyAPI_DATA(PyTypeObject) PyFloat_Type;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000020
Guido van Rossumc16fcdf2001-08-29 15:45:32 +000021#define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)
Christian Heimes90aa7642007-12-19 02:45:37 +000022#define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000023
Christian Heimes53876d92008-04-19 00:31:39 +000024#ifdef Py_NAN
25#define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)
26#endif
27
28#define Py_RETURN_INF(sign) do \
29 if (copysign(1., sign) == 1.) { \
30 return PyFloat_FromDouble(Py_HUGE_VAL); \
31 } else { \
32 return PyFloat_FromDouble(-Py_HUGE_VAL); \
33 } while(0)
34
Christian Heimes93852662007-12-01 12:22:32 +000035PyAPI_FUNC(double) PyFloat_GetMax(void);
36PyAPI_FUNC(double) PyFloat_GetMin(void);
37PyAPI_FUNC(PyObject *) PyFloat_GetInfo(void);
38
Georg Brandl428f0642007-03-18 18:35:15 +000039/* Return Python float from string PyObject. */
40PyAPI_FUNC(PyObject *) PyFloat_FromString(PyObject*);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000041
Tim Peters72f98e92001-05-08 15:19:57 +000042/* Return Python float from C double. */
Mark Hammond91a681d2002-08-12 07:21:58 +000043PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double);
Tim Peters72f98e92001-05-08 15:19:57 +000044
45/* Extract C double from Python float. The macro version trades safety for
46 speed. */
Mark Hammond91a681d2002-08-12 07:21:58 +000047PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *);
Guido van Rossum2981bc71997-08-02 02:40:58 +000048#define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)
Guido van Rossuma3309961993-07-28 09:05:47 +000049
Tim Peters9905b942003-03-20 20:53:32 +000050/* _PyFloat_{Pack,Unpack}{4,8}
51 *
52 * The struct and pickle (at least) modules need an efficient platform-
53 * independent way to store floating-point values as byte strings.
54 * The Pack routines produce a string from a C double, and the Unpack
55 * routines produce a C double from such a string. The suffix (4 or 8)
56 * specifies the number of bytes in the string.
57 *
Michael W. Hudsonba283e22005-05-27 15:23:20 +000058 * On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats
59 * these functions work by copying bits. On other platforms, the formats the
60 * 4- byte format is identical to the IEEE-754 single precision format, and
61 * the 8-byte format to the IEEE-754 double precision format, although the
62 * packing of INFs and NaNs (if such things exist on the platform) isn't
63 * handled correctly, and attempting to unpack a string containing an IEEE
64 * INF or NaN will raise an exception.
65 *
66 * On non-IEEE platforms with more precision, or larger dynamic range, than
67 * 754 supports, not all values can be packed; on non-IEEE platforms with less
68 * precision, or smaller dynamic range, not all values can be unpacked. What
69 * happens in such cases is partly accidental (alas).
Tim Peters9905b942003-03-20 20:53:32 +000070 */
71
72/* The pack routines write 4 or 8 bytes, starting at p. le is a bool
73 * argument, true if you want the string in little-endian format (exponent
74 * last, at p+3 or p+7), false if you want big-endian format (exponent
75 * first, at p).
76 * Return value: 0 if all is OK, -1 if error (and an exception is
77 * set, most likely OverflowError).
Michael W. Hudsonba283e22005-05-27 15:23:20 +000078 * There are two problems on non-IEEE platforms:
79 * 1): What this does is undefined if x is a NaN or infinity.
80 * 2): -0.0 and +0.0 produce the same string.
Tim Peters9905b942003-03-20 20:53:32 +000081 */
82PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le);
83PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le);
84
Neal Norwitz545686b2006-12-28 04:45:06 +000085/* Needed for the old way for marshal to store a floating point number.
86 Returns the string length copied into p, -1 on error.
87 */
88PyAPI_FUNC(int) _PyFloat_Repr(double x, char *p, size_t len);
89
Christian Heimes827b35c2007-12-10 22:19:17 +000090/* Used to get the important decimal digits of a double */
91PyAPI_FUNC(int) _PyFloat_Digits(char *buf, double v, int *signum);
92PyAPI_FUNC(void) _PyFloat_DigitsInit(void);
93
Tim Peters9905b942003-03-20 20:53:32 +000094/* The unpack routines read 4 or 8 bytes, starting at p. le is a bool
95 * argument, true if the string is in little-endian format (exponent
96 * last, at p+3 or p+7), false if big-endian (exponent first, at p).
97 * Return value: The unpacked double. On error, this is -1.0 and
98 * PyErr_Occurred() is true (and an exception is set, most likely
Michael W. Hudsonba283e22005-05-27 15:23:20 +000099 * OverflowError). Note that on a non-IEEE platform this will refuse
100 * to unpack a string that represents a NaN or infinity.
Tim Peters9905b942003-03-20 20:53:32 +0000101 */
102PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le);
103PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);
104
Christian Heimes15ebc882008-02-04 18:48:49 +0000105/* free list api */
Georg Brandl2ee470f2008-07-16 12:55:28 +0000106PyAPI_FUNC(int) PyFloat_ClearFreeList(void);
Christian Heimes15ebc882008-02-04 18:48:49 +0000107
Eric Smith4a7d76d2008-05-30 18:10:19 +0000108/* Format the object based on the format_spec, as defined in PEP 3101
109 (Advanced String Formatting). */
110PyAPI_FUNC(PyObject *) _PyFloat_FormatAdvanced(PyObject *obj,
111 Py_UNICODE *format_spec,
112 Py_ssize_t format_spec_len);
113
Guido van Rossuma3309961993-07-28 09:05:47 +0000114#ifdef __cplusplus
115}
116#endif
117#endif /* !Py_FLOATOBJECT_H */