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 */ | |