Showing the changes to sys/src/cmd/python/Include/floatobject.h (1 of 3706 files). Show all
Unified · Split
| @@ -0,0 +1,100 @@ | |||
| 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) ((op)->ob_type == &PyFloat_Type) | ||
| 23 | |||
| 24 | /* Return Python float from string PyObject. Second argument ignored on | ||
| 25 | input, and, if non-NULL, NULL is stored into *junk (this tried to serve a | ||
| 26 | purpose once but can't be made to work as intended). */ | ||
| 27 | PyAPI_FUNC(PyObject *) PyFloat_FromString(PyObject*, char** junk); | ||
| 28 | |||
| 29 | /* Return Python float from C double. */ | ||
| 30 | PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double); | ||
| 31 | |||
| 32 | /* Extract C double from Python float. The macro version trades safety for | ||
| 33 | speed. */ | ||
| 34 | PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *); | ||
| 35 | #define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval) | ||
| 36 | |||
| 37 | /* Write repr(v) into the char buffer argument, followed by null byte. The | ||
| 38 | buffer must be "big enough"; >= 100 is very safe. | ||
| 39 | PyFloat_AsReprString(buf, x) strives to print enough digits so that | ||
| 40 | PyFloat_FromString(buf) then reproduces x exactly. */ | ||
| 41 | PyAPI_FUNC(void) PyFloat_AsReprString(char*, PyFloatObject *v); | ||
| 42 | |||
| 43 | /* Write str(v) into the char buffer argument, followed by null byte. The | ||
| 44 | buffer must be "big enough"; >= 100 is very safe. Note that it's | ||
| 45 | unusual to be able to get back the float you started with from | ||
| 46 | PyFloat_AsString's result -- use PyFloat_AsReprString() if you want to | ||
| 47 | preserve precision across conversions. */ | ||
| 48 | PyAPI_FUNC(void) PyFloat_AsString(char*, PyFloatObject *v); | ||
| 49 | |||
| 50 | /* _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 | * | ||
| 58 | * 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). | ||
| 70 | */ | ||
| 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). | ||
| 78 | * 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. | ||
| 81 | */ | ||
| 82 | PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le); | ||
| 83 | PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le); | ||
| 84 | |||
| 85 | /* The unpack routines read 4 or 8 bytes, starting at p. le is a bool | ||
| 86 | * argument, true if the string is in little-endian format (exponent | ||
| 87 | * last, at p+3 or p+7), false if big-endian (exponent first, at p). | ||
| 88 | * Return value: The unpacked double. On error, this is -1.0 and | ||
| 89 | * PyErr_Occurred() is true (and an exception is set, most likely | ||
| 90 | * OverflowError). Note that on a non-IEEE platform this will refuse | ||
| 91 | * to unpack a string that represents a NaN or infinity. | ||
| 92 | */ | ||
| 93 | PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le); | ||
| 94 | PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le); | ||
| 95 | |||
| 96 | |||
| 97 | #ifdef __cplusplus | ||
| 98 | } | ||
| 99 | #endif | ||
| 100 | #endif /* !Py_FLOATOBJECT_H */ | ||