1 

     2 /* Float object interface */

     3 

     4 /*

     5 PyFloatObject represents a (double precision) floating point number.

     6 */

     7 

     8 #ifndef Py_FLOATOBJECT_H

     9 #define Py_FLOATOBJECT_H

    10 #ifdef __cplusplus

    11 extern "C" {

    12 #endif

    13 

    14 typedef struct {

    15     PyObject_HEAD

    16     double ob_fval;

    17 } PyFloatObject;

    18 

    19 PyAPI_DATA(PyTypeObject) PyFloat_Type;

    20 

    21 #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)

    22 #define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type)

    23 

    24 #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 

    35 PyAPI_FUNC(double) PyFloat_GetMax(void);

    36 PyAPI_FUNC(double) PyFloat_GetMin(void);

    37 PyAPI_FUNC(PyObject *) PyFloat_GetInfo(void);

    38 

    39 /* Return Python float from string PyObject.  Second argument ignored on

    40    input, and, if non-NULL, NULL is stored into *junk (this tried to serve a

    41    purpose once but can't be made to work as intended). */

    42 PyAPI_FUNC(PyObject *) PyFloat_FromString(PyObject*, char** junk);

    43 

    44 /* Return Python float from C double. */

    45 PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double);

    46 

    47 /* Extract C double from Python float.  The macro version trades safety for

    48    speed. */

    49 PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *);

    50 #define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)

    51 

    52 /* Write repr(v) into the char buffer argument, followed by null byte.  The

    53    buffer must be "big enough"; >= 100 is very safe.

    54    PyFloat_AsReprString(buf, x) strives to print enough digits so that

    55    PyFloat_FromString(buf) then reproduces x exactly. */

    56 PyAPI_FUNC(void) PyFloat_AsReprString(char*, PyFloatObject *v);

    57 

    58 /* Write str(v) into the char buffer argument, followed by null byte.  The

    59    buffer must be "big enough"; >= 100 is very safe.  Note that it's

    60    unusual to be able to get back the float you started with from

    61    PyFloat_AsString's result -- use PyFloat_AsReprString() if you want to

    62    preserve precision across conversions. */

    63 PyAPI_FUNC(void) PyFloat_AsString(char*, PyFloatObject *v);

    64 

    65 /* _PyFloat_{Pack,Unpack}{4,8}

    66  *

    67  * The struct and pickle (at least) modules need an efficient platform-

    68  * independent way to store floating-point values as byte strings.

    69  * The Pack routines produce a string from a C double, and the Unpack

    70  * routines produce a C double from such a string.  The suffix (4 or 8)

    71  * specifies the number of bytes in the string.

    72  *

    73  * On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats

    74  * these functions work by copying bits.  On other platforms, the formats the

    75  * 4- byte format is identical to the IEEE-754 single precision format, and

    76  * the 8-byte format to the IEEE-754 double precision format, although the

    77  * packing of INFs and NaNs (if such things exist on the platform) isn't

    78  * handled correctly, and attempting to unpack a string containing an IEEE

    79  * INF or NaN will raise an exception.

    80  *

    81  * On non-IEEE platforms with more precision, or larger dynamic range, than

    82  * 754 supports, not all values can be packed; on non-IEEE platforms with less

    83  * precision, or smaller dynamic range, not all values can be unpacked.  What

    84  * happens in such cases is partly accidental (alas).

    85  */

    86 

    87 /* The pack routines write 4 or 8 bytes, starting at p.  le is a bool

    88  * argument, true if you want the string in little-endian format (exponent

    89  * last, at p+3 or p+7), false if you want big-endian format (exponent

    90  * first, at p).

    91  * Return value:  0 if all is OK, -1 if error (and an exception is

    92  * set, most likely OverflowError).

    93  * There are two problems on non-IEEE platforms:

    94  * 1):  What this does is undefined if x is a NaN or infinity.

    95  * 2):  -0.0 and +0.0 produce the same string.

    96  */

    97 PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le);

    98 PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le);

    99 

   100 /* Used to get the important decimal digits of a double */

   101 PyAPI_FUNC(int) _PyFloat_Digits(char *buf, double v, int *signum);

   102 PyAPI_FUNC(void) _PyFloat_DigitsInit(void);

   103 

   104 /* The unpack routines read 4 or 8 bytes, starting at p.  le is a bool

   105  * argument, true if the string is in little-endian format (exponent

   106  * last, at p+3 or p+7), false if big-endian (exponent first, at p).

   107  * Return value:  The unpacked double.  On error, this is -1.0 and

   108  * PyErr_Occurred() is true (and an exception is set, most likely

   109  * OverflowError).  Note that on a non-IEEE platform this will refuse

   110  * to unpack a string that represents a NaN or infinity.

   111  */

   112 PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le);

   113 PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);

   114 

   115 /* free list api */

   116 PyAPI_FUNC(int) PyFloat_ClearFreeList(void);

   117 

   118 /* Format the object based on the format_spec, as defined in PEP 3101

   119    (Advanced String Formatting). */

   120 PyAPI_FUNC(PyObject *) _PyFloat_FormatAdvanced(PyObject *obj,

   121 					       char *format_spec,

   122 					       Py_ssize_t format_spec_len);

   123 

   124 #ifdef __cplusplus

   125 }

   126 #endif

   127 #endif /* !Py_FLOATOBJECT_H */