1 /** 2 Mirror _floatobject.h 3 */ 4 module deimos.python.floatobject; 5 6 import deimos.python.pyport; 7 import deimos.python.object; 8 import deimos.python.unicodeobject; 9 import deimos.python.pythonrun; 10 import core.stdc.stdio; 11 12 extern(C): 13 // Python-header-file: Include/floatobject.h: 14 15 /// subclass of PyObject 16 struct PyFloatObject { 17 mixin PyObject_HEAD; 18 /// _ 19 double ob_fval; 20 } 21 22 /// _ 23 mixin(PyAPI_DATA!"PyTypeObject PyFloat_Type"); 24 25 // D translation of C macro: 26 /// _ 27 int PyFloat_Check()(PyObject *op) { 28 return PyObject_TypeCheck(op, &PyFloat_Type); 29 } 30 // D translation of C macro: 31 /// _ 32 int PyFloat_CheckExact()(PyObject *op) { 33 return Py_TYPE(op) == &PyFloat_Type; 34 } 35 36 version(Python_2_6_Or_Later){ 37 /// Availability: >= 2.6 38 double PyFloat_GetMax(); 39 /// Availability: >= 2.6 40 double PyFloat_GetMin(); 41 /// Availability: >= 2.6 42 PyObject* PyFloat_GetInfo(); 43 } 44 45 version(Python_3_0_Or_Later) { 46 /// Availability: 3.* 47 PyObject* PyFloat_FromString(PyObject*); 48 }else{ 49 /** Return Python float from string PyObject. Second argument ignored on 50 input, and, if non-NULL, NULL is stored into *junk (this tried to serve a 51 purpose once but can't be made to work as intended). */ 52 /// Availability: 2.* 53 PyObject* PyFloat_FromString(PyObject*, char** junk); 54 } 55 /** Return Python float from C double. */ 56 PyObject* PyFloat_FromDouble(double); 57 58 /** Extract C double from Python float. The macro version trades safety for 59 speed. */ 60 double PyFloat_AsDouble(PyObject*); 61 /// ditto 62 double PyFloat_AS_DOUBLE()(PyObject* op) { 63 return (cast(PyFloatObject*)op).ob_fval; 64 } 65 version(Python_3_0_Or_Later) { 66 }else{ 67 /** Write repr(v) into the char buffer argument, followed by null byte. The 68 buffer must be "big enough"; >= 100 is very safe. 69 PyFloat_AsReprString(buf, x) strives to print enough digits so that 70 PyFloat_FromString(buf) then reproduces x exactly. */ 71 /// Availability: 2.* 72 void PyFloat_AsReprString(char*, PyFloatObject* v); 73 /** Write str(v) into the char buffer argument, followed by null byte. The 74 buffer must be "big enough"; >= 100 is very safe. Note that it's 75 unusual to be able to get back the float you started with from 76 PyFloat_AsString's result -- use PyFloat_AsReprString() if you want to 77 preserve precision across conversions. */ 78 /// Availability: 2.* 79 void PyFloat_AsString(char*, PyFloatObject* v); 80 } 81 82 /** _PyFloat_{Pack,Unpack}{4,8} 83 * 84 * The struct and pickle (at least) modules need an efficient platform- 85 * independent way to store floating-point values as byte strings. 86 * The Pack routines produce a string from a C double, and the Unpack 87 * routines produce a C double from such a string. The suffix (4 or 8) 88 * specifies the number of bytes in the string. 89 * 90 * On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats 91 * these functions work by copying bits. On other platforms, the formats the 92 * 4- byte format is identical to the IEEE-754 single precision format, and 93 * the 8-byte format to the IEEE-754 double precision format, although the 94 * packing of INFs and NaNs (if such things exist on the platform) isn't 95 * handled correctly, and attempting to unpack a string containing an IEEE 96 * INF or NaN will raise an exception. 97 * 98 * On non-IEEE platforms with more precision, or larger dynamic range, than 99 * 754 supports, not all values can be packed; on non-IEEE platforms with less 100 * precision, or smaller dynamic range, not all values can be unpacked. What 101 * happens in such cases is partly accidental (alas). 102 * 103 * The pack routines write 4 or 8 bytes, starting at p. le is a bool 104 * argument, true if you want the string in little-endian format (exponent 105 * last, at p+3 or p+7), false if you want big-endian format (exponent 106 * first, at p). 107 * Return value: 0 if all is OK, -1 if error (and an exception is 108 * set, most likely OverflowError). 109 * There are two problems on non-IEEE platforms: 110 * 1$(RPAREN): What this does is undefined if x is a NaN or infinity. 111 * 2$(RPAREN): -0.0 and +0.0 produce the same string. 112 */ 113 int _PyFloat_Pack4(double x, ubyte* p, int le); 114 /// ditto 115 int _PyFloat_Pack8(double x, ubyte* p, int le); 116 117 version(Python_3_0_Or_Later) { 118 /// Availability: 3.* 119 int _PyFloat_Repr(double x, char* p, size_t len); 120 } 121 122 version(Python_2_6_Or_Later){ 123 /** Used to get the important decimal digits of a double */ 124 /// Availability: >= 2.6 125 int _PyFloat_Digits(char* buf, double v, int* signum); 126 /// Availability: >= 2.6 127 void _PyFloat_DigitsInit(); 128 /** The unpack routines read 4 or 8 bytes, starting at p. le is a bool 129 * argument, true if the string is in little-endian format (exponent 130 * last, at p+3 or p+7), false if big-endian (exponent first, at p). 131 * Return value: The unpacked double. On error, this is -1.0 and 132 * PyErr_Occurred() is true (and an exception is set, most likely 133 * OverflowError). Note that on a non-IEEE platform this will refuse 134 * to unpack a string that represents a NaN or infinity. 135 */ 136 double _PyFloat_Unpack4(const(ubyte)* p, int le); 137 /// ditto 138 double _PyFloat_Unpack8(const(ubyte)* p, int le); 139 /** free list api */ 140 /// Availability: >= 2.6 141 int PyFloat_ClearFreeList(); 142 } 143 144 version(Python_2_7_Or_Later) { 145 /// Availability: >= 2.7 146 void _PyFloat_DebugMallocStats(FILE* out_); 147 } 148 version(Python_3_0_Or_Later) { 149 /// Availability: 3.* 150 PyObject* _PyFloat_FormatAdvanced(PyObject* obj, 151 Py_UNICODE* format_spec, 152 Py_ssize_t format_spec_len); 153 }else{ 154 version(Python_2_7_Or_Later) { 155 /** Round a C double x to the closest multiple of 10**-ndigits. 156 Returns a Python float on success, or NULL (with an appropriate 157 exception set) on failure. Used in builtin_round in bltinmodule.c. 158 */ 159 /// Availability: >= 2.7 160 PyObject* _Py_double_round(double x, int ndigits); 161 } 162 version(Python_2_6_Or_Later) { 163 /** Format the object based on the format_spec, as defined in PEP 3101 164 (Advanced String Formatting). */ 165 /// Availability: >= 2.6 166 PyObject* _PyFloat_FormatAdvanced(PyObject* obj, 167 char* format_spec, 168 Py_ssize_t format_spec_len); 169 } 170 }