Branch data Line data Source code
1 : : /* Float object implementation */
2 : :
3 : : /* XXX There should be overflow checks here, but it's hard to check
4 : : for any kind of float exception without losing portability. */
5 : :
6 : : #include "Python.h"
7 : : #include "pycore_dtoa.h" // _Py_dg_dtoa()
8 : : #include "pycore_floatobject.h" // _PyFloat_FormatAdvancedWriter()
9 : : #include "pycore_initconfig.h" // _PyStatus_OK()
10 : : #include "pycore_interp.h" // _PyInterpreterState.float_state
11 : : #include "pycore_long.h" // _PyLong_GetOne()
12 : : #include "pycore_object.h" // _PyObject_Init()
13 : : #include "pycore_pymath.h" // _PY_SHORT_FLOAT_REPR
14 : : #include "pycore_pystate.h" // _PyInterpreterState_GET()
15 : : #include "pycore_structseq.h" // _PyStructSequence_FiniType()
16 : :
17 : : #include <ctype.h>
18 : : #include <float.h>
19 : : #include <stdlib.h> // strtol()
20 : :
21 : : /*[clinic input]
22 : : class float "PyObject *" "&PyFloat_Type"
23 : : [clinic start generated code]*/
24 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=dd0003f68f144284]*/
25 : :
26 : : #include "clinic/floatobject.c.h"
27 : :
28 : : #ifndef PyFloat_MAXFREELIST
29 : : # define PyFloat_MAXFREELIST 100
30 : : #endif
31 : :
32 : :
33 : : #if PyFloat_MAXFREELIST > 0
34 : : static struct _Py_float_state *
35 : 209863882 : get_float_state(void)
36 : : {
37 : 209863882 : PyInterpreterState *interp = _PyInterpreterState_GET();
38 : 209863882 : return &interp->float_state;
39 : : }
40 : : #endif
41 : :
42 : :
43 : : double
44 : 0 : PyFloat_GetMax(void)
45 : : {
46 : 0 : return DBL_MAX;
47 : : }
48 : :
49 : : double
50 : 0 : PyFloat_GetMin(void)
51 : : {
52 : 0 : return DBL_MIN;
53 : : }
54 : :
55 : : static PyTypeObject FloatInfoType;
56 : :
57 : : PyDoc_STRVAR(floatinfo__doc__,
58 : : "sys.float_info\n\
59 : : \n\
60 : : A named tuple holding information about the float type. It contains low level\n\
61 : : information about the precision and internal representation. Please study\n\
62 : : your system's :file:`float.h` for more information.");
63 : :
64 : : static PyStructSequence_Field floatinfo_fields[] = {
65 : : {"max", "DBL_MAX -- maximum representable finite float"},
66 : : {"max_exp", "DBL_MAX_EXP -- maximum int e such that radix**(e-1) "
67 : : "is representable"},
68 : : {"max_10_exp", "DBL_MAX_10_EXP -- maximum int e such that 10**e "
69 : : "is representable"},
70 : : {"min", "DBL_MIN -- Minimum positive normalized float"},
71 : : {"min_exp", "DBL_MIN_EXP -- minimum int e such that radix**(e-1) "
72 : : "is a normalized float"},
73 : : {"min_10_exp", "DBL_MIN_10_EXP -- minimum int e such that 10**e is "
74 : : "a normalized float"},
75 : : {"dig", "DBL_DIG -- maximum number of decimal digits that "
76 : : "can be faithfully represented in a float"},
77 : : {"mant_dig", "DBL_MANT_DIG -- mantissa digits"},
78 : : {"epsilon", "DBL_EPSILON -- Difference between 1 and the next "
79 : : "representable float"},
80 : : {"radix", "FLT_RADIX -- radix of exponent"},
81 : : {"rounds", "FLT_ROUNDS -- rounding mode used for arithmetic "
82 : : "operations"},
83 : : {0}
84 : : };
85 : :
86 : : static PyStructSequence_Desc floatinfo_desc = {
87 : : "sys.float_info", /* name */
88 : : floatinfo__doc__, /* doc */
89 : : floatinfo_fields, /* fields */
90 : : 11
91 : : };
92 : :
93 : : PyObject *
94 : 3138 : PyFloat_GetInfo(void)
95 : : {
96 : : PyObject* floatinfo;
97 : 3138 : int pos = 0;
98 : :
99 : 3138 : floatinfo = PyStructSequence_New(&FloatInfoType);
100 [ - + ]: 3138 : if (floatinfo == NULL) {
101 : 0 : return NULL;
102 : : }
103 : :
104 : : #define SetIntFlag(flag) \
105 : : PyStructSequence_SET_ITEM(floatinfo, pos++, PyLong_FromLong(flag))
106 : : #define SetDblFlag(flag) \
107 : : PyStructSequence_SET_ITEM(floatinfo, pos++, PyFloat_FromDouble(flag))
108 : :
109 : 3138 : SetDblFlag(DBL_MAX);
110 : 3138 : SetIntFlag(DBL_MAX_EXP);
111 : 3138 : SetIntFlag(DBL_MAX_10_EXP);
112 : 3138 : SetDblFlag(DBL_MIN);
113 : 3138 : SetIntFlag(DBL_MIN_EXP);
114 : 3138 : SetIntFlag(DBL_MIN_10_EXP);
115 : 3138 : SetIntFlag(DBL_DIG);
116 : 3138 : SetIntFlag(DBL_MANT_DIG);
117 : 3138 : SetDblFlag(DBL_EPSILON);
118 : 3138 : SetIntFlag(FLT_RADIX);
119 : 3138 : SetIntFlag(FLT_ROUNDS);
120 : : #undef SetIntFlag
121 : : #undef SetDblFlag
122 : :
123 [ - + ]: 3138 : if (PyErr_Occurred()) {
124 [ # # ]: 0 : Py_CLEAR(floatinfo);
125 : 0 : return NULL;
126 : : }
127 : 3138 : return floatinfo;
128 : : }
129 : :
130 : : PyObject *
131 : 104932118 : PyFloat_FromDouble(double fval)
132 : : {
133 : : PyFloatObject *op;
134 : : #if PyFloat_MAXFREELIST > 0
135 : 104932118 : struct _Py_float_state *state = get_float_state();
136 : 104932118 : op = state->free_list;
137 [ + + ]: 104932118 : if (op != NULL) {
138 : : #ifdef Py_DEBUG
139 : : // PyFloat_FromDouble() must not be called after _PyFloat_Fini()
140 : : assert(state->numfree != -1);
141 : : #endif
142 : 102895155 : state->free_list = (PyFloatObject *) Py_TYPE(op);
143 : 102895155 : state->numfree--;
144 : : OBJECT_STAT_INC(from_freelist);
145 : : }
146 : : else
147 : : #endif
148 : : {
149 : 2036963 : op = PyObject_Malloc(sizeof(PyFloatObject));
150 [ - + ]: 2036963 : if (!op) {
151 : : return PyErr_NoMemory();
152 : : }
153 : : }
154 : 104932118 : _PyObject_Init((PyObject*)op, &PyFloat_Type);
155 : 104932118 : op->ob_fval = fval;
156 : 104932118 : return (PyObject *) op;
157 : : }
158 : :
159 : : static PyObject *
160 : 56724 : float_from_string_inner(const char *s, Py_ssize_t len, void *obj)
161 : : {
162 : : double x;
163 : : const char *end;
164 : 56724 : const char *last = s + len;
165 : : /* strip space */
166 [ + + + + ]: 56829 : while (s < last && Py_ISSPACE(*s)) {
167 : 105 : s++;
168 : : }
169 : :
170 [ + + + + ]: 56785 : while (s < last - 1 && Py_ISSPACE(last[-1])) {
171 : 61 : last--;
172 : : }
173 : :
174 : : /* We don't care about overflow or underflow. If the platform
175 : : * supports them, infinities and signed zeroes (on underflow) are
176 : : * fine. */
177 : 56724 : x = PyOS_string_to_double(s, (char **)&end, NULL);
178 [ + + ]: 56724 : if (end != last) {
179 : 1104 : PyErr_Format(PyExc_ValueError,
180 : : "could not convert string to float: "
181 : : "%R", obj);
182 : 1104 : return NULL;
183 : : }
184 [ + + + + ]: 55620 : else if (x == -1.0 && PyErr_Occurred()) {
185 : 180 : return NULL;
186 : : }
187 : : else {
188 : 55440 : return PyFloat_FromDouble(x);
189 : : }
190 : : }
191 : :
192 : : PyObject *
193 : 56751 : PyFloat_FromString(PyObject *v)
194 : : {
195 : : const char *s;
196 : 56751 : PyObject *s_buffer = NULL;
197 : : Py_ssize_t len;
198 : 56751 : Py_buffer view = {NULL, NULL};
199 : 56751 : PyObject *result = NULL;
200 : :
201 [ + + ]: 56751 : if (PyUnicode_Check(v)) {
202 : 56061 : s_buffer = _PyUnicode_TransformDecimalAndSpaceToASCII(v);
203 [ - + ]: 56061 : if (s_buffer == NULL)
204 : 0 : return NULL;
205 : : assert(PyUnicode_IS_ASCII(s_buffer));
206 : : /* Simply get a pointer to existing ASCII characters. */
207 : 56061 : s = PyUnicode_AsUTF8AndSize(s_buffer, &len);
208 : : assert(s != NULL);
209 : : }
210 [ + + ]: 690 : else if (PyBytes_Check(v)) {
211 : 671 : s = PyBytes_AS_STRING(v);
212 : 671 : len = PyBytes_GET_SIZE(v);
213 : : }
214 [ + + ]: 19 : else if (PyByteArray_Check(v)) {
215 : 4 : s = PyByteArray_AS_STRING(v);
216 : 4 : len = PyByteArray_GET_SIZE(v);
217 : : }
218 [ + + ]: 15 : else if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) == 0) {
219 : 9 : s = (const char *)view.buf;
220 : 9 : len = view.len;
221 : : /* Copy to NUL-terminated buffer. */
222 : 9 : s_buffer = PyBytes_FromStringAndSize(s, len);
223 [ - + ]: 9 : if (s_buffer == NULL) {
224 : 0 : PyBuffer_Release(&view);
225 : 0 : return NULL;
226 : : }
227 : 9 : s = PyBytes_AS_STRING(s_buffer);
228 : : }
229 : : else {
230 : 6 : PyErr_Format(PyExc_TypeError,
231 : : "float() argument must be a string or a real number, not '%.200s'",
232 : 6 : Py_TYPE(v)->tp_name);
233 : 6 : return NULL;
234 : : }
235 : 56745 : result = _Py_string_to_number_with_underscores(s, len, "float", v, v,
236 : : float_from_string_inner);
237 : 56745 : PyBuffer_Release(&view);
238 : 56745 : Py_XDECREF(s_buffer);
239 : 56745 : return result;
240 : : }
241 : :
242 : : void
243 : 104931763 : _PyFloat_ExactDealloc(PyObject *obj)
244 : : {
245 : : assert(PyFloat_CheckExact(obj));
246 : 104931763 : PyFloatObject *op = (PyFloatObject *)obj;
247 : : #if PyFloat_MAXFREELIST > 0
248 : 104931763 : struct _Py_float_state *state = get_float_state();
249 : : #ifdef Py_DEBUG
250 : : // float_dealloc() must not be called after _PyFloat_Fini()
251 : : assert(state->numfree != -1);
252 : : #endif
253 [ + + ]: 104931763 : if (state->numfree >= PyFloat_MAXFREELIST) {
254 : 1860353 : PyObject_Free(op);
255 : 1860353 : return;
256 : : }
257 : 103071410 : state->numfree++;
258 : 103071410 : Py_SET_TYPE(op, (PyTypeObject *)state->free_list);
259 : 103071410 : state->free_list = op;
260 : : OBJECT_STAT_INC(to_freelist);
261 : : #else
262 : : PyObject_Free(op);
263 : : #endif
264 : : }
265 : :
266 : : static void
267 : 56738591 : float_dealloc(PyObject *op)
268 : : {
269 : : assert(PyFloat_Check(op));
270 : : #if PyFloat_MAXFREELIST > 0
271 [ + + ]: 56738591 : if (PyFloat_CheckExact(op)) {
272 : 56737614 : _PyFloat_ExactDealloc(op);
273 : : }
274 : : else
275 : : #endif
276 : : {
277 : 977 : Py_TYPE(op)->tp_free(op);
278 : : }
279 : 56738591 : }
280 : :
281 : : double
282 : 12288509 : PyFloat_AsDouble(PyObject *op)
283 : : {
284 : : PyNumberMethods *nb;
285 : : PyObject *res;
286 : : double val;
287 : :
288 [ - + ]: 12288509 : if (op == NULL) {
289 : 0 : PyErr_BadArgument();
290 : 0 : return -1;
291 : : }
292 : :
293 [ + + ]: 12288509 : if (PyFloat_Check(op)) {
294 : 11859939 : return PyFloat_AS_DOUBLE(op);
295 : : }
296 : :
297 : 428570 : nb = Py_TYPE(op)->tp_as_number;
298 [ + + + + ]: 428570 : if (nb == NULL || nb->nb_float == NULL) {
299 [ + + + + ]: 368 : if (nb && nb->nb_index) {
300 : 29 : PyObject *res = _PyNumber_Index(op);
301 [ - + ]: 29 : if (!res) {
302 : 0 : return -1;
303 : : }
304 : 29 : double val = PyLong_AsDouble(res);
305 : 29 : Py_DECREF(res);
306 : 29 : return val;
307 : : }
308 : 339 : PyErr_Format(PyExc_TypeError, "must be real number, not %.50s",
309 : 339 : Py_TYPE(op)->tp_name);
310 : 339 : return -1;
311 : : }
312 : :
313 : 428202 : res = (*nb->nb_float) (op);
314 [ + + ]: 428202 : if (res == NULL) {
315 : 17 : return -1;
316 : : }
317 [ + + ]: 428185 : if (!PyFloat_CheckExact(res)) {
318 [ + + ]: 4 : if (!PyFloat_Check(res)) {
319 : 2 : PyErr_Format(PyExc_TypeError,
320 : : "%.50s.__float__ returned non-float (type %.50s)",
321 : 2 : Py_TYPE(op)->tp_name, Py_TYPE(res)->tp_name);
322 : 2 : Py_DECREF(res);
323 : 2 : return -1;
324 : : }
325 [ - + ]: 2 : if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
326 : : "%.50s.__float__ returned non-float (type %.50s). "
327 : : "The ability to return an instance of a strict subclass of float "
328 : : "is deprecated, and may be removed in a future version of Python.",
329 : 2 : Py_TYPE(op)->tp_name, Py_TYPE(res)->tp_name)) {
330 : 0 : Py_DECREF(res);
331 : 0 : return -1;
332 : : }
333 : : }
334 : :
335 : 428183 : val = PyFloat_AS_DOUBLE(res);
336 : 428183 : Py_DECREF(res);
337 : 428183 : return val;
338 : : }
339 : :
340 : : /* Macro and helper that convert PyObject obj to a C double and store
341 : : the value in dbl. If conversion to double raises an exception, obj is
342 : : set to NULL, and the function invoking this macro returns NULL. If
343 : : obj is not of float or int type, Py_NotImplemented is incref'ed,
344 : : stored in obj, and returned from the function invoking this macro.
345 : : */
346 : : #define CONVERT_TO_DOUBLE(obj, dbl) \
347 : : if (PyFloat_Check(obj)) \
348 : : dbl = PyFloat_AS_DOUBLE(obj); \
349 : : else if (convert_to_double(&(obj), &(dbl)) < 0) \
350 : : return obj;
351 : :
352 : : /* Methods */
353 : :
354 : : static int
355 : 2312028 : convert_to_double(PyObject **v, double *dbl)
356 : : {
357 : 2312028 : PyObject *obj = *v;
358 : :
359 [ + + ]: 2312028 : if (PyLong_Check(obj)) {
360 : 2310577 : *dbl = PyLong_AsDouble(obj);
361 [ + + + + ]: 2310577 : if (*dbl == -1.0 && PyErr_Occurred()) {
362 : 24 : *v = NULL;
363 : 24 : return -1;
364 : : }
365 : : }
366 : : else {
367 : 1451 : Py_INCREF(Py_NotImplemented);
368 : 1451 : *v = Py_NotImplemented;
369 : 1451 : return -1;
370 : : }
371 : 2310553 : return 0;
372 : : }
373 : :
374 : : static PyObject *
375 : 156863 : float_repr(PyFloatObject *v)
376 : : {
377 : : PyObject *result;
378 : : char *buf;
379 : :
380 : 156863 : buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),
381 : : 'r', 0,
382 : : Py_DTSF_ADD_DOT_0,
383 : : NULL);
384 [ - + ]: 156863 : if (!buf)
385 : : return PyErr_NoMemory();
386 : 156863 : result = _PyUnicode_FromASCII(buf, strlen(buf));
387 : 156863 : PyMem_Free(buf);
388 : 156863 : return result;
389 : : }
390 : :
391 : : /* Comparison is pretty much a nightmare. When comparing float to float,
392 : : * we do it as straightforwardly (and long-windedly) as conceivable, so
393 : : * that, e.g., Python x == y delivers the same result as the platform
394 : : * C x == y when x and/or y is a NaN.
395 : : * When mixing float with an integer type, there's no good *uniform* approach.
396 : : * Converting the double to an integer obviously doesn't work, since we
397 : : * may lose info from fractional bits. Converting the integer to a double
398 : : * also has two failure modes: (1) an int may trigger overflow (too
399 : : * large to fit in the dynamic range of a C double); (2) even a C long may have
400 : : * more bits than fit in a C double (e.g., on a 64-bit box long may have
401 : : * 63 bits of precision, but a C double probably has only 53), and then
402 : : * we can falsely claim equality when low-order integer bits are lost by
403 : : * coercion to double. So this part is painful too.
404 : : */
405 : :
406 : : static PyObject*
407 : 3823689 : float_richcompare(PyObject *v, PyObject *w, int op)
408 : : {
409 : : double i, j;
410 : 3823689 : int r = 0;
411 : :
412 : : assert(PyFloat_Check(v));
413 : 3823689 : i = PyFloat_AS_DOUBLE(v);
414 : :
415 : : /* Switch on the type of w. Set i and j to doubles to be compared,
416 : : * and op to the richcomp to use.
417 : : */
418 [ + + ]: 3823689 : if (PyFloat_Check(w))
419 : 1737532 : j = PyFloat_AS_DOUBLE(w);
420 : :
421 [ + + ]: 2086157 : else if (!Py_IS_FINITE(i)) {
422 [ + + ]: 84 : if (PyLong_Check(w))
423 : : /* If i is an infinity, its magnitude exceeds any
424 : : * finite integer, so it doesn't matter which int we
425 : : * compare i with. If i is a NaN, similarly.
426 : : */
427 : 38 : j = 0.0;
428 : : else
429 : 46 : goto Unimplemented;
430 : : }
431 : :
432 [ + + ]: 2086073 : else if (PyLong_Check(w)) {
433 [ + + + + ]: 2068211 : int vsign = i == 0.0 ? 0 : i < 0.0 ? -1 : 1;
434 : 2068211 : int wsign = _PyLong_Sign(w);
435 : : size_t nbits;
436 : : int exponent;
437 : :
438 [ + + ]: 2068211 : if (vsign != wsign) {
439 : : /* Magnitudes are irrelevant -- the signs alone
440 : : * determine the outcome.
441 : : */
442 : 414177 : i = (double)vsign;
443 : 414177 : j = (double)wsign;
444 : 2065221 : goto Compare;
445 : : }
446 : : /* The signs are the same. */
447 : : /* Convert w to a double if it fits. In particular, 0 fits. */
448 : 1654034 : nbits = _PyLong_NumBits(w);
449 [ - + - - ]: 1654034 : if (nbits == (size_t)-1 && PyErr_Occurred()) {
450 : : /* This long is so large that size_t isn't big enough
451 : : * to hold the # of bits. Replace with little doubles
452 : : * that give the same outcome -- w is so large that
453 : : * its magnitude must exceed the magnitude of any
454 : : * finite float.
455 : : */
456 : 0 : PyErr_Clear();
457 : 0 : i = (double)vsign;
458 : : assert(wsign != 0);
459 : 0 : j = wsign * 2.0;
460 : 0 : goto Compare;
461 : : }
462 [ + + ]: 1654034 : if (nbits <= 48) {
463 : 1638499 : j = PyLong_AsDouble(w);
464 : : /* It's impossible that <= 48 bits overflowed. */
465 : : assert(j != -1.0 || ! PyErr_Occurred());
466 : 1638499 : goto Compare;
467 : : }
468 : : assert(wsign != 0); /* else nbits was 0 */
469 : : assert(vsign != 0); /* if vsign were 0, then since wsign is
470 : : * not 0, we would have taken the
471 : : * vsign != wsign branch at the start */
472 : : /* We want to work with non-negative numbers. */
473 [ + + ]: 15535 : if (vsign < 0) {
474 : : /* "Multiply both sides" by -1; this also swaps the
475 : : * comparator.
476 : : */
477 : 5079 : i = -i;
478 : 5079 : op = _Py_SwappedOp[op];
479 : : }
480 : : assert(i > 0.0);
481 : 15535 : (void) frexp(i, &exponent);
482 : : /* exponent is the # of bits in v before the radix point;
483 : : * we know that nbits (the # of bits in w) > 48 at this point
484 : : */
485 [ + + + + ]: 15535 : if (exponent < 0 || (size_t)exponent < nbits) {
486 : 6999 : i = 1.0;
487 : 6999 : j = 2.0;
488 : 6999 : goto Compare;
489 : : }
490 [ + + ]: 8536 : if ((size_t)exponent > nbits) {
491 : 5546 : i = 2.0;
492 : 5546 : j = 1.0;
493 : 5546 : goto Compare;
494 : : }
495 : : /* v and w have the same number of bits before the radix
496 : : * point. Construct two ints that have the same comparison
497 : : * outcome.
498 : : */
499 : : {
500 : : double fracpart;
501 : : double intpart;
502 : 2990 : PyObject *result = NULL;
503 : 2990 : PyObject *vv = NULL;
504 : 2990 : PyObject *ww = w;
505 : :
506 [ + + ]: 2990 : if (wsign < 0) {
507 : 487 : ww = PyNumber_Negative(w);
508 [ - + ]: 487 : if (ww == NULL)
509 : 0 : goto Error;
510 : : }
511 : : else
512 : 2503 : Py_INCREF(ww);
513 : :
514 : 2990 : fracpart = modf(i, &intpart);
515 : 2990 : vv = PyLong_FromDouble(intpart);
516 [ - + ]: 2990 : if (vv == NULL)
517 : 0 : goto Error;
518 : :
519 [ + + ]: 2990 : if (fracpart != 0.0) {
520 : : /* Shift left, and or a 1 bit into vv
521 : : * to represent the lost fraction.
522 : : */
523 : : PyObject *temp;
524 : :
525 : 160 : temp = _PyLong_Lshift(ww, 1);
526 [ - + ]: 160 : if (temp == NULL)
527 : 0 : goto Error;
528 : 160 : Py_DECREF(ww);
529 : 160 : ww = temp;
530 : :
531 : 160 : temp = _PyLong_Lshift(vv, 1);
532 [ - + ]: 160 : if (temp == NULL)
533 : 0 : goto Error;
534 : 160 : Py_DECREF(vv);
535 : 160 : vv = temp;
536 : :
537 : 160 : temp = PyNumber_Or(vv, _PyLong_GetOne());
538 [ - + ]: 160 : if (temp == NULL)
539 : 0 : goto Error;
540 : 160 : Py_DECREF(vv);
541 : 160 : vv = temp;
542 : : }
543 : :
544 : 2990 : r = PyObject_RichCompareBool(vv, ww, op);
545 [ - + ]: 2990 : if (r < 0)
546 : 0 : goto Error;
547 : 2990 : result = PyBool_FromLong(r);
548 : 2990 : Error:
549 : 2990 : Py_XDECREF(vv);
550 : 2990 : Py_XDECREF(ww);
551 : 2990 : return result;
552 : : }
553 : : } /* else if (PyLong_Check(w)) */
554 : :
555 : : else /* w isn't float or int */
556 : 17862 : goto Unimplemented;
557 : :
558 : 3802791 : Compare:
559 [ + + + + : 3802791 : switch (op) {
+ + - ]
560 : 1681526 : case Py_EQ:
561 : 1681526 : r = i == j;
562 : 1681526 : break;
563 : 58312 : case Py_NE:
564 : 58312 : r = i != j;
565 : 58312 : break;
566 : 215382 : case Py_LE:
567 : 215382 : r = i <= j;
568 : 215382 : break;
569 : 17787 : case Py_GE:
570 : 17787 : r = i >= j;
571 : 17787 : break;
572 : 1692588 : case Py_LT:
573 : 1692588 : r = i < j;
574 : 1692588 : break;
575 : 137196 : case Py_GT:
576 : 137196 : r = i > j;
577 : 137196 : break;
578 : : }
579 : 3802791 : return PyBool_FromLong(r);
580 : :
581 : 17908 : Unimplemented:
582 : 17908 : Py_RETURN_NOTIMPLEMENTED;
583 : : }
584 : :
585 : : static Py_hash_t
586 : 185674 : float_hash(PyFloatObject *v)
587 : : {
588 : 185674 : return _Py_HashDouble((PyObject *)v, v->ob_fval);
589 : : }
590 : :
591 : : static PyObject *
592 : 371232 : float_add(PyObject *v, PyObject *w)
593 : : {
594 : : double a,b;
595 [ + + + + ]: 371232 : CONVERT_TO_DOUBLE(v, a);
596 [ + + + + ]: 371216 : CONVERT_TO_DOUBLE(w, b);
597 : 370697 : a = a + b;
598 : 370697 : return PyFloat_FromDouble(a);
599 : : }
600 : :
601 : : static PyObject *
602 : 25106 : float_sub(PyObject *v, PyObject *w)
603 : : {
604 : : double a,b;
605 [ + + + + ]: 25106 : CONVERT_TO_DOUBLE(v, a);
606 [ + + + + ]: 25092 : CONVERT_TO_DOUBLE(w, b);
607 : 24916 : a = a - b;
608 : 24916 : return PyFloat_FromDouble(a);
609 : : }
610 : :
611 : : static PyObject *
612 : 1631389 : float_mul(PyObject *v, PyObject *w)
613 : : {
614 : : double a,b;
615 [ + + + + ]: 1631389 : CONVERT_TO_DOUBLE(v, a);
616 [ + + + + ]: 1631383 : CONVERT_TO_DOUBLE(w, b);
617 : 1630675 : a = a * b;
618 : 1630675 : return PyFloat_FromDouble(a);
619 : : }
620 : :
621 : : static PyObject *
622 : 6061197 : float_div(PyObject *v, PyObject *w)
623 : : {
624 : : double a,b;
625 [ + + + + ]: 6061197 : CONVERT_TO_DOUBLE(v, a);
626 [ + + + + ]: 6061195 : CONVERT_TO_DOUBLE(w, b);
627 [ + + ]: 6061190 : if (b == 0.0) {
628 : 111 : PyErr_SetString(PyExc_ZeroDivisionError,
629 : : "float division by zero");
630 : 111 : return NULL;
631 : : }
632 : 6061079 : a = a / b;
633 : 6061079 : return PyFloat_FromDouble(a);
634 : : }
635 : :
636 : : static PyObject *
637 : 2451 : float_rem(PyObject *v, PyObject *w)
638 : : {
639 : : double vx, wx;
640 : : double mod;
641 [ + + + + ]: 2451 : CONVERT_TO_DOUBLE(v, vx);
642 [ + + + + ]: 2448 : CONVERT_TO_DOUBLE(w, wx);
643 [ + + ]: 2444 : if (wx == 0.0) {
644 : 2 : PyErr_SetString(PyExc_ZeroDivisionError,
645 : : "float modulo");
646 : 2 : return NULL;
647 : : }
648 : 2442 : mod = fmod(vx, wx);
649 [ + + ]: 2442 : if (mod) {
650 : : /* ensure the remainder has the same sign as the denominator */
651 [ + + ]: 2263 : if ((wx < 0) != (mod < 0)) {
652 : 324 : mod += wx;
653 : : }
654 : : }
655 : : else {
656 : : /* the remainder is zero, and in the presence of signed zeroes
657 : : fmod returns different results across platforms; ensure
658 : : it has the same sign as the denominator. */
659 : 179 : mod = copysign(0.0, wx);
660 : : }
661 : 2442 : return PyFloat_FromDouble(mod);
662 : : }
663 : :
664 : : static void
665 : 92 : _float_div_mod(double vx, double wx, double *floordiv, double *mod)
666 : : {
667 : : double div;
668 : 92 : *mod = fmod(vx, wx);
669 : : /* fmod is typically exact, so vx-mod is *mathematically* an
670 : : exact multiple of wx. But this is fp arithmetic, and fp
671 : : vx - mod is an approximation; the result is that div may
672 : : not be an exact integral value after the division, although
673 : : it will always be very close to one.
674 : : */
675 : 92 : div = (vx - *mod) / wx;
676 [ + + ]: 92 : if (*mod) {
677 : : /* ensure the remainder has the same sign as the denominator */
678 [ + + ]: 88 : if ((wx < 0) != (*mod < 0)) {
679 : 6 : *mod += wx;
680 : 6 : div -= 1.0;
681 : : }
682 : : }
683 : : else {
684 : : /* the remainder is zero, and in the presence of signed zeroes
685 : : fmod returns different results across platforms; ensure
686 : : it has the same sign as the denominator. */
687 : 4 : *mod = copysign(0.0, wx);
688 : : }
689 : : /* snap quotient to nearest integral value */
690 [ + + ]: 92 : if (div) {
691 : 69 : *floordiv = floor(div);
692 [ - + ]: 69 : if (div - *floordiv > 0.5) {
693 : 0 : *floordiv += 1.0;
694 : : }
695 : : }
696 : : else {
697 : : /* div is zero - get the same sign as the true quotient */
698 : 23 : *floordiv = copysign(0.0, vx / wx); /* zero w/ sign of vx/wx */
699 : : }
700 : 92 : }
701 : :
702 : : static PyObject *
703 : 77 : float_divmod(PyObject *v, PyObject *w)
704 : : {
705 : : double vx, wx;
706 : : double mod, floordiv;
707 [ + + + - ]: 77 : CONVERT_TO_DOUBLE(v, vx);
708 [ + + + + ]: 75 : CONVERT_TO_DOUBLE(w, wx);
709 [ - + ]: 72 : if (wx == 0.0) {
710 : 0 : PyErr_SetString(PyExc_ZeroDivisionError, "float divmod()");
711 : 0 : return NULL;
712 : : }
713 : 72 : _float_div_mod(vx, wx, &floordiv, &mod);
714 : 72 : return Py_BuildValue("(dd)", floordiv, mod);
715 : : }
716 : :
717 : : static PyObject *
718 : 33 : float_floor_div(PyObject *v, PyObject *w)
719 : : {
720 : : double vx, wx;
721 : : double mod, floordiv;
722 [ + + + - ]: 33 : CONVERT_TO_DOUBLE(v, vx);
723 [ + + + + ]: 28 : CONVERT_TO_DOUBLE(w, wx);
724 [ + + ]: 22 : if (wx == 0.0) {
725 : 2 : PyErr_SetString(PyExc_ZeroDivisionError, "float floor division by zero");
726 : 2 : return NULL;
727 : : }
728 : 20 : _float_div_mod(vx, wx, &floordiv, &mod);
729 : 20 : return PyFloat_FromDouble(floordiv);
730 : : }
731 : :
732 : : /* determine whether x is an odd integer or not; assumes that
733 : : x is not an infinity or nan. */
734 : : #define DOUBLE_IS_ODD_INTEGER(x) (fmod(fabs(x), 2.0) == 1.0)
735 : :
736 : : static PyObject *
737 : 261436 : float_pow(PyObject *v, PyObject *w, PyObject *z)
738 : : {
739 : : double iv, iw, ix;
740 : 261436 : int negate_result = 0;
741 : :
742 [ + + ]: 261436 : if ((PyObject *)z != Py_None) {
743 : 4407 : PyErr_SetString(PyExc_TypeError, "pow() 3rd argument not "
744 : : "allowed unless all arguments are integers");
745 : 4407 : return NULL;
746 : : }
747 : :
748 [ + + + + ]: 257029 : CONVERT_TO_DOUBLE(v, iv);
749 [ + + + + ]: 257027 : CONVERT_TO_DOUBLE(w, iw);
750 : :
751 : : /* Sort out special cases here instead of relying on pow() */
752 [ + + ]: 257023 : if (iw == 0) { /* v**0 is 1, even 0**0 */
753 : 273 : return PyFloat_FromDouble(1.0);
754 : : }
755 [ + + ]: 256750 : if (Py_IS_NAN(iv)) { /* nan**w = nan, unless w == 0 */
756 : 18 : return PyFloat_FromDouble(iv);
757 : : }
758 [ + + ]: 256732 : if (Py_IS_NAN(iw)) { /* v**nan = nan, unless v == 1; 1**nan = 1 */
759 [ + + ]: 22 : return PyFloat_FromDouble(iv == 1.0 ? 1.0 : iw);
760 : : }
761 [ + + + + ]: 256710 : if (Py_IS_INFINITY(iw)) {
762 : : /* v**inf is: 0.0 if abs(v) < 1; 1.0 if abs(v) == 1; inf if
763 : : * abs(v) > 1 (including case where v infinite)
764 : : *
765 : : * v**-inf is: inf if abs(v) < 1; 1.0 if abs(v) == 1; 0.0 if
766 : : * abs(v) > 1 (including case where v infinite)
767 : : */
768 : 40 : iv = fabs(iv);
769 [ + + ]: 40 : if (iv == 1.0)
770 : 8 : return PyFloat_FromDouble(1.0);
771 [ + + ]: 32 : else if ((iw > 0.0) == (iv > 1.0))
772 : 16 : return PyFloat_FromDouble(fabs(iw)); /* return inf */
773 : : else
774 : 16 : return PyFloat_FromDouble(0.0);
775 : : }
776 [ + + + + ]: 256670 : if (Py_IS_INFINITY(iv)) {
777 : : /* (+-inf)**w is: inf for w positive, 0 for w negative; in
778 : : * both cases, we need to add the appropriate sign if w is
779 : : * an odd integer.
780 : : */
781 : 24 : int iw_is_odd = DOUBLE_IS_ODD_INTEGER(iw);
782 [ + + ]: 24 : if (iw > 0.0)
783 [ + + ]: 12 : return PyFloat_FromDouble(iw_is_odd ? iv : fabs(iv));
784 : : else
785 [ + + ]: 16 : return PyFloat_FromDouble(iw_is_odd ?
786 : 4 : copysign(0.0, iv) : 0.0);
787 : : }
788 [ + + ]: 256646 : if (iv == 0.0) { /* 0**w is: 0 for w positive, 1 for w zero
789 : : (already dealt with above), and an error
790 : : if w is negative. */
791 : 446 : int iw_is_odd = DOUBLE_IS_ODD_INTEGER(iw);
792 [ + + ]: 446 : if (iw < 0.0) {
793 : 392 : PyErr_SetString(PyExc_ZeroDivisionError,
794 : : "0.0 cannot be raised to a "
795 : : "negative power");
796 : 392 : return NULL;
797 : : }
798 : : /* use correct sign if iw is odd */
799 [ + + ]: 54 : return PyFloat_FromDouble(iw_is_odd ? iv : 0.0);
800 : : }
801 : :
802 [ + + ]: 256200 : if (iv < 0.0) {
803 : : /* Whether this is an error is a mess, and bumps into libm
804 : : * bugs so we have to figure it out ourselves.
805 : : */
806 [ + + ]: 118619 : if (iw != floor(iw)) {
807 : : /* Negative numbers raised to fractional powers
808 : : * become complex.
809 : : */
810 : 20 : return PyComplex_Type.tp_as_number->nb_power(v, w, z);
811 : : }
812 : : /* iw is an exact integer, albeit perhaps a very large
813 : : * one. Replace iv by its absolute value and remember
814 : : * to negate the pow result if iw is odd.
815 : : */
816 : 118599 : iv = -iv;
817 : 118599 : negate_result = DOUBLE_IS_ODD_INTEGER(iw);
818 : : }
819 : :
820 [ + + ]: 256180 : if (iv == 1.0) { /* 1**w is 1, even 1**inf and 1**nan */
821 : : /* (-1) ** large_integer also ends up here. Here's an
822 : : * extract from the comments for the previous
823 : : * implementation explaining why this special case is
824 : : * necessary:
825 : : *
826 : : * -1 raised to an exact integer should never be exceptional.
827 : : * Alas, some libms (chiefly glibc as of early 2003) return
828 : : * NaN and set EDOM on pow(-1, large_int) if the int doesn't
829 : : * happen to be representable in a *C* integer. That's a
830 : : * bug.
831 : : */
832 [ + + ]: 1348 : return PyFloat_FromDouble(negate_result ? -1.0 : 1.0);
833 : : }
834 : :
835 : : /* Now iv and iw are finite, iw is nonzero, and iv is
836 : : * positive and not equal to 1.0. We finally allow
837 : : * the platform pow to step in and do the rest.
838 : : */
839 : 254832 : errno = 0;
840 : 254832 : ix = pow(iv, iw);
841 : 254832 : _Py_ADJUST_ERANGE1(ix);
842 [ + + ]: 254832 : if (negate_result)
843 : 100140 : ix = -ix;
844 : :
845 [ - + ]: 254832 : if (errno != 0) {
846 : : /* We don't expect any errno value other than ERANGE, but
847 : : * the range of libm bugs appears unbounded.
848 : : */
849 [ # # ]: 0 : PyErr_SetFromErrno(errno == ERANGE ? PyExc_OverflowError :
850 : : PyExc_ValueError);
851 : 0 : return NULL;
852 : : }
853 : 254832 : return PyFloat_FromDouble(ix);
854 : : }
855 : :
856 : : #undef DOUBLE_IS_ODD_INTEGER
857 : :
858 : : static PyObject *
859 : 383657 : float_neg(PyFloatObject *v)
860 : : {
861 : 383657 : return PyFloat_FromDouble(-v->ob_fval);
862 : : }
863 : :
864 : : static PyObject *
865 : 1837345 : float_abs(PyFloatObject *v)
866 : : {
867 : 1837345 : return PyFloat_FromDouble(fabs(v->ob_fval));
868 : : }
869 : :
870 : : static int
871 : 3132717 : float_bool(PyFloatObject *v)
872 : : {
873 : 3132717 : return v->ob_fval != 0.0;
874 : : }
875 : :
876 : : /*[clinic input]
877 : : float.is_integer
878 : :
879 : : Return True if the float is an integer.
880 : : [clinic start generated code]*/
881 : :
882 : : static PyObject *
883 : 4 : float_is_integer_impl(PyObject *self)
884 : : /*[clinic end generated code: output=7112acf95a4d31ea input=311810d3f777e10d]*/
885 : : {
886 : 4 : double x = PyFloat_AsDouble(self);
887 : : PyObject *o;
888 : :
889 [ - + - - ]: 4 : if (x == -1.0 && PyErr_Occurred())
890 : 0 : return NULL;
891 [ + + ]: 4 : if (!Py_IS_FINITE(x))
892 : 2 : Py_RETURN_FALSE;
893 : 2 : errno = 0;
894 [ + + ]: 2 : o = (floor(x) == x) ? Py_True : Py_False;
895 [ - + ]: 2 : if (errno != 0) {
896 [ # # ]: 0 : PyErr_SetFromErrno(errno == ERANGE ? PyExc_OverflowError :
897 : : PyExc_ValueError);
898 : 0 : return NULL;
899 : : }
900 : 2 : Py_INCREF(o);
901 : 2 : return o;
902 : : }
903 : :
904 : : /*[clinic input]
905 : : float.__trunc__
906 : :
907 : : Return the Integral closest to x between 0 and x.
908 : : [clinic start generated code]*/
909 : :
910 : : static PyObject *
911 : 926426 : float___trunc___impl(PyObject *self)
912 : : /*[clinic end generated code: output=dd3e289dd4c6b538 input=591b9ba0d650fdff]*/
913 : : {
914 : 926426 : return PyLong_FromDouble(PyFloat_AS_DOUBLE(self));
915 : : }
916 : :
917 : : /*[clinic input]
918 : : float.__floor__
919 : :
920 : : Return the floor as an Integral.
921 : : [clinic start generated code]*/
922 : :
923 : : static PyObject *
924 : 12 : float___floor___impl(PyObject *self)
925 : : /*[clinic end generated code: output=e0551dbaea8c01d1 input=77bb13eb12e268df]*/
926 : : {
927 : 12 : double x = PyFloat_AS_DOUBLE(self);
928 : 12 : return PyLong_FromDouble(floor(x));
929 : : }
930 : :
931 : : /*[clinic input]
932 : : float.__ceil__
933 : :
934 : : Return the ceiling as an Integral.
935 : : [clinic start generated code]*/
936 : :
937 : : static PyObject *
938 : 12 : float___ceil___impl(PyObject *self)
939 : : /*[clinic end generated code: output=a2fd8858f73736f9 input=79e41ae94aa0a516]*/
940 : : {
941 : 12 : double x = PyFloat_AS_DOUBLE(self);
942 : 12 : return PyLong_FromDouble(ceil(x));
943 : : }
944 : :
945 : : /* double_round: rounds a finite double to the closest multiple of
946 : : 10**-ndigits; here ndigits is within reasonable bounds (typically, -308 <=
947 : : ndigits <= 323). Returns a Python float, or sets a Python error and
948 : : returns NULL on failure (OverflowError and memory errors are possible). */
949 : :
950 : : #if _PY_SHORT_FLOAT_REPR == 1
951 : : /* version of double_round that uses the correctly-rounded string<->double
952 : : conversions from Python/dtoa.c */
953 : :
954 : : static PyObject *
955 : 1217029 : double_round(double x, int ndigits) {
956 : :
957 : : double rounded;
958 : 1217029 : Py_ssize_t buflen, mybuflen=100;
959 : 1217029 : char *buf, *buf_end, shortbuf[100], *mybuf=shortbuf;
960 : : int decpt, sign;
961 : 1217029 : PyObject *result = NULL;
962 : : _Py_SET_53BIT_PRECISION_HEADER;
963 : :
964 : : /* round to a decimal string */
965 [ + - ]: 1217029 : _Py_SET_53BIT_PRECISION_START;
966 : 1217029 : buf = _Py_dg_dtoa(x, 3, ndigits, &decpt, &sign, &buf_end);
967 [ + - ]: 1217029 : _Py_SET_53BIT_PRECISION_END;
968 [ - + ]: 1217029 : if (buf == NULL) {
969 : : PyErr_NoMemory();
970 : 0 : return NULL;
971 : : }
972 : :
973 : : /* Get new buffer if shortbuf is too small. Space needed <= buf_end -
974 : : buf + 8: (1 extra for '0', 1 for sign, 5 for exp, 1 for '\0'). */
975 : 1217029 : buflen = buf_end - buf;
976 [ + + ]: 1217029 : if (buflen + 8 > mybuflen) {
977 : 3 : mybuflen = buflen+8;
978 : 3 : mybuf = (char *)PyMem_Malloc(mybuflen);
979 [ - + ]: 3 : if (mybuf == NULL) {
980 : : PyErr_NoMemory();
981 : 0 : goto exit;
982 : : }
983 : : }
984 : : /* copy buf to mybuf, adding exponent, sign and leading 0 */
985 : 1217029 : PyOS_snprintf(mybuf, mybuflen, "%s0%se%d", (sign ? "-" : ""),
986 [ + + ]: 1217029 : buf, decpt - (int)buflen);
987 : :
988 : : /* and convert the resulting string back to a double */
989 : 1217029 : errno = 0;
990 [ + - ]: 1217029 : _Py_SET_53BIT_PRECISION_START;
991 : 1217029 : rounded = _Py_dg_strtod(mybuf, NULL);
992 [ + - ]: 1217029 : _Py_SET_53BIT_PRECISION_END;
993 [ + + + - ]: 1217029 : if (errno == ERANGE && fabs(rounded) >= 1.)
994 : 2 : PyErr_SetString(PyExc_OverflowError,
995 : : "rounded value too large to represent");
996 : : else
997 : 1217027 : result = PyFloat_FromDouble(rounded);
998 : :
999 : : /* done computing value; now clean up */
1000 [ + + ]: 1217029 : if (mybuf != shortbuf)
1001 : 3 : PyMem_Free(mybuf);
1002 : 1217026 : exit:
1003 : 1217029 : _Py_dg_freedtoa(buf);
1004 : 1217029 : return result;
1005 : : }
1006 : :
1007 : : #else // _PY_SHORT_FLOAT_REPR == 0
1008 : :
1009 : : /* fallback version, to be used when correctly rounded binary<->decimal
1010 : : conversions aren't available */
1011 : :
1012 : : static PyObject *
1013 : : double_round(double x, int ndigits) {
1014 : : double pow1, pow2, y, z;
1015 : : if (ndigits >= 0) {
1016 : : if (ndigits > 22) {
1017 : : /* pow1 and pow2 are each safe from overflow, but
1018 : : pow1*pow2 ~= pow(10.0, ndigits) might overflow */
1019 : : pow1 = pow(10.0, (double)(ndigits-22));
1020 : : pow2 = 1e22;
1021 : : }
1022 : : else {
1023 : : pow1 = pow(10.0, (double)ndigits);
1024 : : pow2 = 1.0;
1025 : : }
1026 : : y = (x*pow1)*pow2;
1027 : : /* if y overflows, then rounded value is exactly x */
1028 : : if (!Py_IS_FINITE(y))
1029 : : return PyFloat_FromDouble(x);
1030 : : }
1031 : : else {
1032 : : pow1 = pow(10.0, (double)-ndigits);
1033 : : pow2 = 1.0; /* unused; silences a gcc compiler warning */
1034 : : y = x / pow1;
1035 : : }
1036 : :
1037 : : z = round(y);
1038 : : if (fabs(y-z) == 0.5)
1039 : : /* halfway between two integers; use round-half-even */
1040 : : z = 2.0*round(y/2.0);
1041 : :
1042 : : if (ndigits >= 0)
1043 : : z = (z / pow2) / pow1;
1044 : : else
1045 : : z *= pow1;
1046 : :
1047 : : /* if computation resulted in overflow, raise OverflowError */
1048 : : if (!Py_IS_FINITE(z)) {
1049 : : PyErr_SetString(PyExc_OverflowError,
1050 : : "overflow occurred during round");
1051 : : return NULL;
1052 : : }
1053 : :
1054 : : return PyFloat_FromDouble(z);
1055 : : }
1056 : :
1057 : : #endif // _PY_SHORT_FLOAT_REPR == 0
1058 : :
1059 : : /* round a Python float v to the closest multiple of 10**-ndigits */
1060 : :
1061 : : /*[clinic input]
1062 : : float.__round__
1063 : :
1064 : : ndigits as o_ndigits: object = None
1065 : : /
1066 : :
1067 : : Return the Integral closest to x, rounding half toward even.
1068 : :
1069 : : When an argument is passed, work like built-in round(x, ndigits).
1070 : : [clinic start generated code]*/
1071 : :
1072 : : static PyObject *
1073 : 1301775 : float___round___impl(PyObject *self, PyObject *o_ndigits)
1074 : : /*[clinic end generated code: output=374c36aaa0f13980 input=fc0fe25924fbc9ed]*/
1075 : : {
1076 : : double x, rounded;
1077 : : Py_ssize_t ndigits;
1078 : :
1079 : 1301775 : x = PyFloat_AsDouble(self);
1080 [ + + ]: 1301775 : if (o_ndigits == Py_None) {
1081 : : /* single-argument round or with None ndigits:
1082 : : * round to nearest integer */
1083 : 84687 : rounded = round(x);
1084 [ + + ]: 84687 : if (fabs(x-rounded) == 0.5)
1085 : : /* halfway case: round to even */
1086 : 26 : rounded = 2.0*round(x/2.0);
1087 : 84687 : return PyLong_FromDouble(rounded);
1088 : : }
1089 : :
1090 : : /* interpret second argument as a Py_ssize_t; clips on overflow */
1091 : 1217088 : ndigits = PyNumber_AsSsize_t(o_ndigits, NULL);
1092 [ + + + + ]: 1217088 : if (ndigits == -1 && PyErr_Occurred())
1093 : 4 : return NULL;
1094 : :
1095 : : /* nans and infinities round to themselves */
1096 [ + + ]: 1217084 : if (!Py_IS_FINITE(x))
1097 : 3 : return PyFloat_FromDouble(x);
1098 : :
1099 : : /* Deal with extreme values for ndigits. For ndigits > NDIGITS_MAX, x
1100 : : always rounds to itself. For ndigits < NDIGITS_MIN, x always
1101 : : rounds to +-0.0. Here 0.30103 is an upper bound for log10(2). */
1102 : : #define NDIGITS_MAX ((int)((DBL_MANT_DIG-DBL_MIN_EXP) * 0.30103))
1103 : : #define NDIGITS_MIN (-(int)((DBL_MAX_EXP + 1) * 0.30103))
1104 [ + + ]: 1217081 : if (ndigits > NDIGITS_MAX)
1105 : : /* return x */
1106 : 28 : return PyFloat_FromDouble(x);
1107 [ + + ]: 1217053 : else if (ndigits < NDIGITS_MIN)
1108 : : /* return 0.0, but with sign of x */
1109 : 24 : return PyFloat_FromDouble(0.0*x);
1110 : : else
1111 : : /* finite x, and ndigits is not unreasonably large */
1112 : 1217029 : return double_round(x, (int)ndigits);
1113 : : #undef NDIGITS_MAX
1114 : : #undef NDIGITS_MIN
1115 : : }
1116 : :
1117 : : static PyObject *
1118 : 1857 : float_float(PyObject *v)
1119 : : {
1120 [ + + ]: 1857 : if (PyFloat_CheckExact(v))
1121 : 1679 : Py_INCREF(v);
1122 : : else
1123 : 178 : v = PyFloat_FromDouble(((PyFloatObject *)v)->ob_fval);
1124 : 1857 : return v;
1125 : : }
1126 : :
1127 : : /*[clinic input]
1128 : : float.conjugate
1129 : :
1130 : : Return self, the complex conjugate of any float.
1131 : : [clinic start generated code]*/
1132 : :
1133 : : static PyObject *
1134 : 2 : float_conjugate_impl(PyObject *self)
1135 : : /*[clinic end generated code: output=8ca292c2479194af input=82ba6f37a9ff91dd]*/
1136 : : {
1137 : 2 : return float_float(self);
1138 : : }
1139 : :
1140 : : /* turn ASCII hex characters into integer values and vice versa */
1141 : :
1142 : : static char
1143 : 380576 : char_from_hex(int x)
1144 : : {
1145 : : assert(0 <= x && x < 16);
1146 : 380576 : return Py_hexdigits[x];
1147 : : }
1148 : :
1149 : : static int
1150 : 296354 : hex_from_char(char c) {
1151 : : int x;
1152 [ + + + + : 296354 : switch(c) {
+ + + + +
+ + + + +
+ + + ]
1153 : 23882 : case '0':
1154 : 23882 : x = 0;
1155 : 23882 : break;
1156 : 50320 : case '1':
1157 : 50320 : x = 1;
1158 : 50320 : break;
1159 : 14799 : case '2':
1160 : 14799 : x = 2;
1161 : 14799 : break;
1162 : 13588 : case '3':
1163 : 13588 : x = 3;
1164 : 13588 : break;
1165 : 15278 : case '4':
1166 : 15278 : x = 4;
1167 : 15278 : break;
1168 : 13918 : case '5':
1169 : 13918 : x = 5;
1170 : 13918 : break;
1171 : 14342 : case '6':
1172 : 14342 : x = 6;
1173 : 14342 : break;
1174 : 13824 : case '7':
1175 : 13824 : x = 7;
1176 : 13824 : break;
1177 : 15884 : case '8':
1178 : 15884 : x = 8;
1179 : 15884 : break;
1180 : 13954 : case '9':
1181 : 13954 : x = 9;
1182 : 13954 : break;
1183 : 14556 : case 'a':
1184 : : case 'A':
1185 : 14556 : x = 10;
1186 : 14556 : break;
1187 : 13884 : case 'b':
1188 : : case 'B':
1189 : 13884 : x = 11;
1190 : 13884 : break;
1191 : 14610 : case 'c':
1192 : : case 'C':
1193 : 14610 : x = 12;
1194 : 14610 : break;
1195 : 13649 : case 'd':
1196 : : case 'D':
1197 : 13649 : x = 13;
1198 : 13649 : break;
1199 : 14563 : case 'e':
1200 : : case 'E':
1201 : 14563 : x = 14;
1202 : 14563 : break;
1203 : 15373 : case 'f':
1204 : : case 'F':
1205 : 15373 : x = 15;
1206 : 15373 : break;
1207 : 19930 : default:
1208 : 19930 : x = -1;
1209 : 19930 : break;
1210 : : }
1211 : 296354 : return x;
1212 : : }
1213 : :
1214 : : /* convert a float to a hexadecimal string */
1215 : :
1216 : : /* TOHEX_NBITS is DBL_MANT_DIG rounded up to the next integer
1217 : : of the form 4k+1. */
1218 : : #define TOHEX_NBITS DBL_MANT_DIG + 3 - (DBL_MANT_DIG+2)%4
1219 : :
1220 : : /*[clinic input]
1221 : : float.hex
1222 : :
1223 : : Return a hexadecimal representation of a floating-point number.
1224 : :
1225 : : >>> (-0.1).hex()
1226 : : '-0x1.999999999999ap-4'
1227 : : >>> 3.14159.hex()
1228 : : '0x1.921f9f01b866ep+1'
1229 : : [clinic start generated code]*/
1230 : :
1231 : : static PyObject *
1232 : 30734 : float_hex_impl(PyObject *self)
1233 : : /*[clinic end generated code: output=0ebc9836e4d302d4 input=bec1271a33d47e67]*/
1234 : : {
1235 : : double x, m;
1236 : : int e, shift, i, si, esign;
1237 : : /* Space for 1+(TOHEX_NBITS-1)/4 digits, a decimal point, and the
1238 : : trailing NUL byte. */
1239 : : char s[(TOHEX_NBITS-1)/4+3];
1240 : :
1241 [ + - - - ]: 30734 : CONVERT_TO_DOUBLE(self, x);
1242 : :
1243 [ + + + + ]: 30734 : if (Py_IS_NAN(x) || Py_IS_INFINITY(x))
1244 : 1170 : return float_repr((PyFloatObject *)self);
1245 : :
1246 [ + + ]: 29564 : if (x == 0.0) {
1247 [ + + ]: 2380 : if (copysign(1.0, x) == -1.0)
1248 : 789 : return PyUnicode_FromString("-0x0.0p+0");
1249 : : else
1250 : 1591 : return PyUnicode_FromString("0x0.0p+0");
1251 : : }
1252 : :
1253 : 27184 : m = frexp(fabs(x), &e);
1254 : 27184 : shift = 1 - Py_MAX(DBL_MIN_EXP - e, 0);
1255 : 27184 : m = ldexp(m, shift);
1256 : 27184 : e -= shift;
1257 : :
1258 : 27184 : si = 0;
1259 : 27184 : s[si] = char_from_hex((int)m);
1260 : 27184 : si++;
1261 : 27184 : m -= (int)m;
1262 : 27184 : s[si] = '.';
1263 : 27184 : si++;
1264 [ + + ]: 380576 : for (i=0; i < (TOHEX_NBITS-1)/4; i++) {
1265 : 353392 : m *= 16.0;
1266 : 353392 : s[si] = char_from_hex((int)m);
1267 : 353392 : si++;
1268 : 353392 : m -= (int)m;
1269 : : }
1270 : 27184 : s[si] = '\0';
1271 : :
1272 [ + + ]: 27184 : if (e < 0) {
1273 : 9705 : esign = (int)'-';
1274 : 9705 : e = -e;
1275 : : }
1276 : : else
1277 : 17479 : esign = (int)'+';
1278 : :
1279 [ + + ]: 27184 : if (x < 0.0)
1280 : 7385 : return PyUnicode_FromFormat("-0x%sp%c%d", s, esign, e);
1281 : : else
1282 : 19799 : return PyUnicode_FromFormat("0x%sp%c%d", s, esign, e);
1283 : : }
1284 : :
1285 : : /* Convert a hexadecimal string to a float. */
1286 : :
1287 : : /*[clinic input]
1288 : : @classmethod
1289 : : float.fromhex
1290 : :
1291 : : string: object
1292 : : /
1293 : :
1294 : : Create a floating-point number from a hexadecimal string.
1295 : :
1296 : : >>> float.fromhex('0x1.ffffp10')
1297 : : 2047.984375
1298 : : >>> float.fromhex('-0x1p-1074')
1299 : : -5e-324
1300 : : [clinic start generated code]*/
1301 : :
1302 : : static PyObject *
1303 : 10257 : float_fromhex(PyTypeObject *type, PyObject *string)
1304 : : /*[clinic end generated code: output=46c0274d22b78e82 input=0407bebd354bca89]*/
1305 : : {
1306 : : PyObject *result;
1307 : : double x;
1308 : : long exp, top_exp, lsb, key_digit;
1309 : : const char *s, *coeff_start, *s_store, *coeff_end, *exp_start, *s_end;
1310 : 10257 : int half_eps, digit, round_up, negate=0;
1311 : : Py_ssize_t length, ndigits, fdigits, i;
1312 : :
1313 : : /*
1314 : : * For the sake of simplicity and correctness, we impose an artificial
1315 : : * limit on ndigits, the total number of hex digits in the coefficient
1316 : : * The limit is chosen to ensure that, writing exp for the exponent,
1317 : : *
1318 : : * (1) if exp > LONG_MAX/2 then the value of the hex string is
1319 : : * guaranteed to overflow (provided it's nonzero)
1320 : : *
1321 : : * (2) if exp < LONG_MIN/2 then the value of the hex string is
1322 : : * guaranteed to underflow to 0.
1323 : : *
1324 : : * (3) if LONG_MIN/2 <= exp <= LONG_MAX/2 then there's no danger of
1325 : : * overflow in the calculation of exp and top_exp below.
1326 : : *
1327 : : * More specifically, ndigits is assumed to satisfy the following
1328 : : * inequalities:
1329 : : *
1330 : : * 4*ndigits <= DBL_MIN_EXP - DBL_MANT_DIG - LONG_MIN/2
1331 : : * 4*ndigits <= LONG_MAX/2 + 1 - DBL_MAX_EXP
1332 : : *
1333 : : * If either of these inequalities is not satisfied, a ValueError is
1334 : : * raised. Otherwise, write x for the value of the hex string, and
1335 : : * assume x is nonzero. Then
1336 : : *
1337 : : * 2**(exp-4*ndigits) <= |x| < 2**(exp+4*ndigits).
1338 : : *
1339 : : * Now if exp > LONG_MAX/2 then:
1340 : : *
1341 : : * exp - 4*ndigits >= LONG_MAX/2 + 1 - (LONG_MAX/2 + 1 - DBL_MAX_EXP)
1342 : : * = DBL_MAX_EXP
1343 : : *
1344 : : * so |x| >= 2**DBL_MAX_EXP, which is too large to be stored in C
1345 : : * double, so overflows. If exp < LONG_MIN/2, then
1346 : : *
1347 : : * exp + 4*ndigits <= LONG_MIN/2 - 1 + (
1348 : : * DBL_MIN_EXP - DBL_MANT_DIG - LONG_MIN/2)
1349 : : * = DBL_MIN_EXP - DBL_MANT_DIG - 1
1350 : : *
1351 : : * and so |x| < 2**(DBL_MIN_EXP-DBL_MANT_DIG-1), hence underflows to 0
1352 : : * when converted to a C double.
1353 : : *
1354 : : * It's easy to show that if LONG_MIN/2 <= exp <= LONG_MAX/2 then both
1355 : : * exp+4*ndigits and exp-4*ndigits are within the range of a long.
1356 : : */
1357 : :
1358 : 10257 : s = PyUnicode_AsUTF8AndSize(string, &length);
1359 [ - + ]: 10257 : if (s == NULL)
1360 : 0 : return NULL;
1361 : 10257 : s_end = s + length;
1362 : :
1363 : : /********************
1364 : : * Parse the string *
1365 : : ********************/
1366 : :
1367 : : /* leading whitespace */
1368 [ + + ]: 10693 : while (Py_ISSPACE(*s))
1369 : 436 : s++;
1370 : :
1371 : : /* infinities and nans */
1372 : 10257 : x = _Py_parse_inf_or_nan(s, (char **)&coeff_end);
1373 [ + + ]: 10257 : if (coeff_end != s) {
1374 : 211 : s = coeff_end;
1375 : 211 : goto finished;
1376 : : }
1377 : :
1378 : : /* optional sign */
1379 [ + + ]: 10046 : if (*s == '-') {
1380 : 4922 : s++;
1381 : 4922 : negate = 1;
1382 : : }
1383 [ + + ]: 5124 : else if (*s == '+')
1384 : 19 : s++;
1385 : :
1386 : : /* [0x] */
1387 : 10046 : s_store = s;
1388 [ + + ]: 10046 : if (*s == '0') {
1389 : 9911 : s++;
1390 [ + + + + ]: 9911 : if (*s == 'x' || *s == 'X')
1391 : 9806 : s++;
1392 : : else
1393 : 105 : s = s_store;
1394 : : }
1395 : :
1396 : : /* coefficient: <integer> [. <fraction>] */
1397 : 10046 : coeff_start = s;
1398 [ + + ]: 20167 : while (hex_from_char(*s) >= 0)
1399 : 10121 : s++;
1400 : 10046 : s_store = s;
1401 [ + + ]: 10046 : if (*s == '.') {
1402 : 9884 : s++;
1403 [ + + ]: 128652 : while (hex_from_char(*s) >= 0)
1404 : 118768 : s++;
1405 : 9884 : coeff_end = s-1;
1406 : : }
1407 : : else
1408 : 162 : coeff_end = s;
1409 : :
1410 : : /* ndigits = total # of hex digits; fdigits = # after point */
1411 : 10046 : ndigits = coeff_end - coeff_start;
1412 : 10046 : fdigits = coeff_end - s_store;
1413 [ + + ]: 10046 : if (ndigits == 0)
1414 : 25 : goto parse_error;
1415 [ - + ]: 10021 : if (ndigits > Py_MIN(DBL_MIN_EXP - DBL_MANT_DIG - LONG_MIN/2,
1416 : : LONG_MAX/2 + 1 - DBL_MAX_EXP)/4)
1417 : 0 : goto insane_length_error;
1418 : :
1419 : : /* [p <exponent>] */
1420 [ + + + + ]: 10021 : if (*s == 'p' || *s == 'P') {
1421 : 9731 : s++;
1422 : 9731 : exp_start = s;
1423 [ + + + + ]: 9731 : if (*s == '-' || *s == '+')
1424 : 9607 : s++;
1425 [ + + + + ]: 9731 : if (!('0' <= *s && *s <= '9'))
1426 : 11 : goto parse_error;
1427 : 9720 : s++;
1428 [ + + + - ]: 27374 : while ('0' <= *s && *s <= '9')
1429 : 17654 : s++;
1430 : 9720 : exp = strtol(exp_start, NULL, 10);
1431 : : }
1432 : : else
1433 : 290 : exp = 0;
1434 : :
1435 : : /* for 0 <= j < ndigits, HEX_DIGIT(j) gives the jth most significant digit */
1436 : : #define HEX_DIGIT(j) hex_from_char(*((j) < fdigits ? \
1437 : : coeff_end-(j) : \
1438 : : coeff_end-1-(j)))
1439 : :
1440 : : /*******************************************
1441 : : * Compute rounded value of the hex string *
1442 : : *******************************************/
1443 : :
1444 : : /* Discard leading zeros, and catch extreme overflow and underflow */
1445 [ + + + + : 12882 : while (ndigits > 0 && HEX_DIGIT(ndigits-1) == 0)
+ + ]
1446 : 2872 : ndigits--;
1447 [ + + - + ]: 10010 : if (ndigits == 0 || exp < LONG_MIN/2) {
1448 : 621 : x = 0.0;
1449 : 621 : goto finished;
1450 : : }
1451 [ - + ]: 9389 : if (exp > LONG_MAX/2)
1452 : 0 : goto overflow_error;
1453 : :
1454 : : /* Adjust exponent for fractional part. */
1455 : 9389 : exp = exp - 4*((long)fdigits);
1456 : :
1457 : : /* top_exp = 1 more than exponent of most sig. bit of coefficient */
1458 : 9389 : top_exp = exp + 4*((long)ndigits - 1);
1459 [ + + + + ]: 19550 : for (digit = HEX_DIGIT(ndigits-1); digit != 0; digit /= 2)
1460 : 10161 : top_exp++;
1461 : :
1462 : : /* catch almost all nonextreme cases of overflow and underflow here */
1463 [ + + ]: 9389 : if (top_exp < DBL_MIN_EXP - DBL_MANT_DIG) {
1464 : 3 : x = 0.0;
1465 : 3 : goto finished;
1466 : : }
1467 [ + + ]: 9386 : if (top_exp > DBL_MAX_EXP)
1468 : 13 : goto overflow_error;
1469 : :
1470 : : /* lsb = exponent of least significant bit of the *rounded* value.
1471 : : This is top_exp - DBL_MANT_DIG unless result is subnormal. */
1472 : 9373 : lsb = Py_MAX(top_exp, (long)DBL_MIN_EXP) - DBL_MANT_DIG;
1473 : :
1474 : 9373 : x = 0.0;
1475 [ + + ]: 9373 : if (exp >= lsb) {
1476 : : /* no rounding required */
1477 [ + + ]: 133553 : for (i = ndigits-1; i >= 0; i--)
1478 [ + + ]: 124327 : x = 16.0*x + HEX_DIGIT(i);
1479 : 9226 : x = ldexp(x, (int)(exp));
1480 : 9226 : goto finished;
1481 : : }
1482 : : /* rounding required. key_digit is the index of the hex digit
1483 : : containing the first bit to be rounded away. */
1484 : 147 : half_eps = 1 << (int)((lsb - exp - 1) % 4);
1485 : 147 : key_digit = (lsb - exp - 1) / 4;
1486 [ + + ]: 1505 : for (i = ndigits-1; i > key_digit; i--)
1487 [ + + ]: 1358 : x = 16.0*x + HEX_DIGIT(i);
1488 [ + + ]: 147 : digit = HEX_DIGIT(key_digit);
1489 : 147 : x = 16.0*x + (double)(digit & (16-2*half_eps));
1490 : :
1491 : : /* round-half-even: round up if bit lsb-1 is 1 and at least one of
1492 : : bits lsb, lsb-2, lsb-3, lsb-4, ... is 1. */
1493 [ + + ]: 147 : if ((digit & half_eps) != 0) {
1494 : 82 : round_up = 0;
1495 [ + + + + ]: 82 : if ((digit & (3*half_eps-1)) != 0 || (half_eps == 8 &&
1496 [ + + + - : 22 : key_digit+1 < ndigits && (HEX_DIGIT(key_digit+1) & 1) != 0))
+ + ]
1497 : 56 : round_up = 1;
1498 : : else
1499 [ + + ]: 62 : for (i = key_digit-1; i >= 0; i--)
1500 [ + + + + ]: 43 : if (HEX_DIGIT(i) != 0) {
1501 : 7 : round_up = 1;
1502 : 7 : break;
1503 : : }
1504 [ + + ]: 82 : if (round_up) {
1505 : 63 : x += 2*half_eps;
1506 [ + + ]: 63 : if (top_exp == DBL_MAX_EXP &&
1507 [ + - ]: 6 : x == ldexp((double)(2*half_eps), DBL_MANT_DIG))
1508 : : /* overflow corner case: pre-rounded value <
1509 : : 2**DBL_MAX_EXP; rounded=2**DBL_MAX_EXP. */
1510 : 6 : goto overflow_error;
1511 : : }
1512 : : }
1513 : 141 : x = ldexp(x, (int)(exp+4*key_digit));
1514 : :
1515 : 10202 : finished:
1516 : : /* optional trailing whitespace leading to the end of the string */
1517 [ + + ]: 10646 : while (Py_ISSPACE(*s))
1518 : 444 : s++;
1519 [ + + ]: 10202 : if (s != s_end)
1520 : 15 : goto parse_error;
1521 [ + + ]: 10187 : result = PyFloat_FromDouble(negate ? -x : x);
1522 [ + + + - ]: 10187 : if (type != &PyFloat_Type && result != NULL) {
1523 : 4 : Py_SETREF(result, PyObject_CallOneArg((PyObject *)type, result));
1524 : : }
1525 : 10187 : return result;
1526 : :
1527 : 19 : overflow_error:
1528 : 19 : PyErr_SetString(PyExc_OverflowError,
1529 : : "hexadecimal value too large to represent as a float");
1530 : 19 : return NULL;
1531 : :
1532 : 51 : parse_error:
1533 : 51 : PyErr_SetString(PyExc_ValueError,
1534 : : "invalid hexadecimal floating-point string");
1535 : 51 : return NULL;
1536 : :
1537 : 0 : insane_length_error:
1538 : 0 : PyErr_SetString(PyExc_ValueError,
1539 : : "hexadecimal string too long to convert");
1540 : 0 : return NULL;
1541 : : }
1542 : :
1543 : : /*[clinic input]
1544 : : float.as_integer_ratio
1545 : :
1546 : : Return integer ratio.
1547 : :
1548 : : Return a pair of integers, whose ratio is exactly equal to the original float
1549 : : and with a positive denominator.
1550 : :
1551 : : Raise OverflowError on infinities and a ValueError on NaNs.
1552 : :
1553 : : >>> (10.0).as_integer_ratio()
1554 : : (10, 1)
1555 : : >>> (0.0).as_integer_ratio()
1556 : : (0, 1)
1557 : : >>> (-.25).as_integer_ratio()
1558 : : (-1, 4)
1559 : : [clinic start generated code]*/
1560 : :
1561 : : static PyObject *
1562 : 358972 : float_as_integer_ratio_impl(PyObject *self)
1563 : : /*[clinic end generated code: output=65f25f0d8d30a712 input=e21d08b4630c2e44]*/
1564 : : {
1565 : : double self_double;
1566 : : double float_part;
1567 : : int exponent;
1568 : : int i;
1569 : :
1570 : 358972 : PyObject *py_exponent = NULL;
1571 : 358972 : PyObject *numerator = NULL;
1572 : 358972 : PyObject *denominator = NULL;
1573 : 358972 : PyObject *result_pair = NULL;
1574 : 358972 : PyNumberMethods *long_methods = PyLong_Type.tp_as_number;
1575 : :
1576 [ + - - - ]: 358972 : CONVERT_TO_DOUBLE(self, self_double);
1577 : :
1578 [ + + + + ]: 358972 : if (Py_IS_INFINITY(self_double)) {
1579 : 22 : PyErr_SetString(PyExc_OverflowError,
1580 : : "cannot convert Infinity to integer ratio");
1581 : 22 : return NULL;
1582 : : }
1583 [ + + ]: 358950 : if (Py_IS_NAN(self_double)) {
1584 : 12 : PyErr_SetString(PyExc_ValueError,
1585 : : "cannot convert NaN to integer ratio");
1586 : 12 : return NULL;
1587 : : }
1588 : :
1589 : 358938 : float_part = frexp(self_double, &exponent); /* self_double == float_part * 2**exponent exactly */
1590 : :
1591 [ + - + + ]: 17300377 : for (i=0; i<300 && float_part != floor(float_part) ; i++) {
1592 : 16941439 : float_part *= 2.0;
1593 : 16941439 : exponent--;
1594 : : }
1595 : : /* self == float_part * 2**exponent exactly and float_part is integral.
1596 : : If FLT_RADIX != 2, the 300 steps may leave a tiny fractional part
1597 : : to be truncated by PyLong_FromDouble(). */
1598 : :
1599 : 358938 : numerator = PyLong_FromDouble(float_part);
1600 [ - + ]: 358938 : if (numerator == NULL)
1601 : 0 : goto error;
1602 : 358938 : denominator = PyLong_FromLong(1);
1603 [ - + ]: 358938 : if (denominator == NULL)
1604 : 0 : goto error;
1605 : 358938 : py_exponent = PyLong_FromLong(Py_ABS(exponent));
1606 [ - + ]: 358938 : if (py_exponent == NULL)
1607 : 0 : goto error;
1608 : :
1609 : : /* fold in 2**exponent */
1610 [ + + ]: 358938 : if (exponent > 0) {
1611 : 62285 : Py_SETREF(numerator,
1612 : : long_methods->nb_lshift(numerator, py_exponent));
1613 [ - + ]: 62285 : if (numerator == NULL)
1614 : 0 : goto error;
1615 : : }
1616 : : else {
1617 : 296653 : Py_SETREF(denominator,
1618 : : long_methods->nb_lshift(denominator, py_exponent));
1619 [ - + ]: 296653 : if (denominator == NULL)
1620 : 0 : goto error;
1621 : : }
1622 : :
1623 : 358938 : result_pair = PyTuple_Pack(2, numerator, denominator);
1624 : :
1625 : 358938 : error:
1626 : 358938 : Py_XDECREF(py_exponent);
1627 : 358938 : Py_XDECREF(denominator);
1628 : 358938 : Py_XDECREF(numerator);
1629 : 358938 : return result_pair;
1630 : : }
1631 : :
1632 : : static PyObject *
1633 : : float_subtype_new(PyTypeObject *type, PyObject *x);
1634 : :
1635 : : /*[clinic input]
1636 : : @classmethod
1637 : : float.__new__ as float_new
1638 : : x: object(c_default="NULL") = 0
1639 : : /
1640 : :
1641 : : Convert a string or number to a floating point number, if possible.
1642 : : [clinic start generated code]*/
1643 : :
1644 : : static PyObject *
1645 : 112309 : float_new_impl(PyTypeObject *type, PyObject *x)
1646 : : /*[clinic end generated code: output=ccf1e8dc460ba6ba input=f43661b7de03e9d8]*/
1647 : : {
1648 [ + + ]: 112309 : if (type != &PyFloat_Type) {
1649 [ + + ]: 977 : if (x == NULL) {
1650 : 23 : x = _PyLong_GetZero();
1651 : : }
1652 : 977 : return float_subtype_new(type, x); /* Wimp out */
1653 : : }
1654 : :
1655 [ + + ]: 111332 : if (x == NULL) {
1656 : 10 : return PyFloat_FromDouble(0.0);
1657 : : }
1658 : : /* If it's a string, but not a string subclass, use
1659 : : PyFloat_FromString. */
1660 [ + + ]: 111322 : if (PyUnicode_CheckExact(x))
1661 : 54570 : return PyFloat_FromString(x);
1662 : 56752 : return PyNumber_Float(x);
1663 : : }
1664 : :
1665 : : /* Wimpy, slow approach to tp_new calls for subtypes of float:
1666 : : first create a regular float from whatever arguments we got,
1667 : : then allocate a subtype instance and initialize its ob_fval
1668 : : from the regular float. The regular float is then thrown away.
1669 : : */
1670 : : static PyObject *
1671 : 977 : float_subtype_new(PyTypeObject *type, PyObject *x)
1672 : : {
1673 : : PyObject *tmp, *newobj;
1674 : :
1675 : : assert(PyType_IsSubtype(type, &PyFloat_Type));
1676 : 977 : tmp = float_new_impl(&PyFloat_Type, x);
1677 [ - + ]: 977 : if (tmp == NULL)
1678 : 0 : return NULL;
1679 : : assert(PyFloat_Check(tmp));
1680 : 977 : newobj = type->tp_alloc(type, 0);
1681 [ - + ]: 977 : if (newobj == NULL) {
1682 : 0 : Py_DECREF(tmp);
1683 : 0 : return NULL;
1684 : : }
1685 : 977 : ((PyFloatObject *)newobj)->ob_fval = ((PyFloatObject *)tmp)->ob_fval;
1686 : 977 : Py_DECREF(tmp);
1687 : 977 : return newobj;
1688 : : }
1689 : :
1690 : : static PyObject *
1691 : 110358 : float_vectorcall(PyObject *type, PyObject * const*args,
1692 : : size_t nargsf, PyObject *kwnames)
1693 : : {
1694 [ + + + - ]: 110358 : if (!_PyArg_NoKwnames("float", kwnames)) {
1695 : 3 : return NULL;
1696 : : }
1697 : :
1698 : 110355 : Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
1699 [ + - - + : 110355 : if (!_PyArg_CheckPositional("float", nargs, 0, 1)) {
- - ]
1700 : 0 : return NULL;
1701 : : }
1702 : :
1703 [ + + ]: 110355 : PyObject *x = nargs >= 1 ? args[0] : NULL;
1704 : 110355 : return float_new_impl(_PyType_CAST(type), x);
1705 : : }
1706 : :
1707 : :
1708 : : /*[clinic input]
1709 : : float.__getnewargs__
1710 : : [clinic start generated code]*/
1711 : :
1712 : : static PyObject *
1713 : 48 : float___getnewargs___impl(PyObject *self)
1714 : : /*[clinic end generated code: output=873258c9d206b088 input=002279d1d77891e6]*/
1715 : : {
1716 : 48 : return Py_BuildValue("(d)", ((PyFloatObject *)self)->ob_fval);
1717 : : }
1718 : :
1719 : : /* this is for the benefit of the pack/unpack routines below */
1720 : :
1721 : : typedef enum {
1722 : : unknown_format, ieee_big_endian_format, ieee_little_endian_format
1723 : : } float_format_type;
1724 : :
1725 : : static float_format_type double_format, float_format;
1726 : :
1727 : : /*[clinic input]
1728 : : @classmethod
1729 : : float.__getformat__
1730 : :
1731 : : typestr: str
1732 : : Must be 'double' or 'float'.
1733 : : /
1734 : :
1735 : : You probably don't want to use this function.
1736 : :
1737 : : It exists mainly to be used in Python's test suite.
1738 : :
1739 : : This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
1740 : : little-endian' best describes the format of floating point numbers used by the
1741 : : C type named by typestr.
1742 : : [clinic start generated code]*/
1743 : :
1744 : : static PyObject *
1745 : 1140 : float___getformat___impl(PyTypeObject *type, const char *typestr)
1746 : : /*[clinic end generated code: output=2bfb987228cc9628 input=d5a52600f835ad67]*/
1747 : : {
1748 : : float_format_type r;
1749 : :
1750 [ + + ]: 1140 : if (strcmp(typestr, "double") == 0) {
1751 : 1138 : r = double_format;
1752 : : }
1753 [ + + ]: 2 : else if (strcmp(typestr, "float") == 0) {
1754 : 1 : r = float_format;
1755 : : }
1756 : : else {
1757 : 1 : PyErr_SetString(PyExc_ValueError,
1758 : : "__getformat__() argument 1 must be "
1759 : : "'double' or 'float'");
1760 : 1 : return NULL;
1761 : : }
1762 : :
1763 [ - + - - ]: 1139 : switch (r) {
1764 : 0 : case unknown_format:
1765 : 0 : return PyUnicode_FromString("unknown");
1766 : 1139 : case ieee_little_endian_format:
1767 : 1139 : return PyUnicode_FromString("IEEE, little-endian");
1768 : 0 : case ieee_big_endian_format:
1769 : 0 : return PyUnicode_FromString("IEEE, big-endian");
1770 : 0 : default:
1771 : 0 : PyErr_SetString(PyExc_RuntimeError,
1772 : : "insane float_format or double_format");
1773 : 0 : return NULL;
1774 : : }
1775 : : }
1776 : :
1777 : :
1778 : : static PyObject *
1779 : 1137 : float_getreal(PyObject *v, void *closure)
1780 : : {
1781 : 1137 : return float_float(v);
1782 : : }
1783 : :
1784 : : static PyObject *
1785 : 1137 : float_getimag(PyObject *v, void *closure)
1786 : : {
1787 : 1137 : return PyFloat_FromDouble(0.0);
1788 : : }
1789 : :
1790 : : /*[clinic input]
1791 : : float.__format__
1792 : :
1793 : : format_spec: unicode
1794 : : /
1795 : :
1796 : : Formats the float according to format_spec.
1797 : : [clinic start generated code]*/
1798 : :
1799 : : static PyObject *
1800 : 9537 : float___format___impl(PyObject *self, PyObject *format_spec)
1801 : : /*[clinic end generated code: output=b260e52a47eade56 input=2ece1052211fd0e6]*/
1802 : : {
1803 : : _PyUnicodeWriter writer;
1804 : : int ret;
1805 : :
1806 : 9537 : _PyUnicodeWriter_Init(&writer);
1807 : 9537 : ret = _PyFloat_FormatAdvancedWriter(
1808 : : &writer,
1809 : : self,
1810 : : format_spec, 0, PyUnicode_GET_LENGTH(format_spec));
1811 [ + + ]: 9537 : if (ret == -1) {
1812 : 105 : _PyUnicodeWriter_Dealloc(&writer);
1813 : 105 : return NULL;
1814 : : }
1815 : 9432 : return _PyUnicodeWriter_Finish(&writer);
1816 : : }
1817 : :
1818 : : static PyMethodDef float_methods[] = {
1819 : : FLOAT_CONJUGATE_METHODDEF
1820 : : FLOAT___TRUNC___METHODDEF
1821 : : FLOAT___FLOOR___METHODDEF
1822 : : FLOAT___CEIL___METHODDEF
1823 : : FLOAT___ROUND___METHODDEF
1824 : : FLOAT_AS_INTEGER_RATIO_METHODDEF
1825 : : FLOAT_FROMHEX_METHODDEF
1826 : : FLOAT_HEX_METHODDEF
1827 : : FLOAT_IS_INTEGER_METHODDEF
1828 : : FLOAT___GETNEWARGS___METHODDEF
1829 : : FLOAT___GETFORMAT___METHODDEF
1830 : : FLOAT___FORMAT___METHODDEF
1831 : : {NULL, NULL} /* sentinel */
1832 : : };
1833 : :
1834 : : static PyGetSetDef float_getset[] = {
1835 : : {"real",
1836 : : float_getreal, (setter)NULL,
1837 : : "the real part of a complex number",
1838 : : NULL},
1839 : : {"imag",
1840 : : float_getimag, (setter)NULL,
1841 : : "the imaginary part of a complex number",
1842 : : NULL},
1843 : : {NULL} /* Sentinel */
1844 : : };
1845 : :
1846 : :
1847 : : static PyNumberMethods float_as_number = {
1848 : : float_add, /* nb_add */
1849 : : float_sub, /* nb_subtract */
1850 : : float_mul, /* nb_multiply */
1851 : : float_rem, /* nb_remainder */
1852 : : float_divmod, /* nb_divmod */
1853 : : float_pow, /* nb_power */
1854 : : (unaryfunc)float_neg, /* nb_negative */
1855 : : float_float, /* nb_positive */
1856 : : (unaryfunc)float_abs, /* nb_absolute */
1857 : : (inquiry)float_bool, /* nb_bool */
1858 : : 0, /* nb_invert */
1859 : : 0, /* nb_lshift */
1860 : : 0, /* nb_rshift */
1861 : : 0, /* nb_and */
1862 : : 0, /* nb_xor */
1863 : : 0, /* nb_or */
1864 : : float___trunc___impl, /* nb_int */
1865 : : 0, /* nb_reserved */
1866 : : float_float, /* nb_float */
1867 : : 0, /* nb_inplace_add */
1868 : : 0, /* nb_inplace_subtract */
1869 : : 0, /* nb_inplace_multiply */
1870 : : 0, /* nb_inplace_remainder */
1871 : : 0, /* nb_inplace_power */
1872 : : 0, /* nb_inplace_lshift */
1873 : : 0, /* nb_inplace_rshift */
1874 : : 0, /* nb_inplace_and */
1875 : : 0, /* nb_inplace_xor */
1876 : : 0, /* nb_inplace_or */
1877 : : float_floor_div, /* nb_floor_divide */
1878 : : float_div, /* nb_true_divide */
1879 : : 0, /* nb_inplace_floor_divide */
1880 : : 0, /* nb_inplace_true_divide */
1881 : : };
1882 : :
1883 : : PyTypeObject PyFloat_Type = {
1884 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
1885 : : "float",
1886 : : sizeof(PyFloatObject),
1887 : : 0,
1888 : : (destructor)float_dealloc, /* tp_dealloc */
1889 : : 0, /* tp_vectorcall_offset */
1890 : : 0, /* tp_getattr */
1891 : : 0, /* tp_setattr */
1892 : : 0, /* tp_as_async */
1893 : : (reprfunc)float_repr, /* tp_repr */
1894 : : &float_as_number, /* tp_as_number */
1895 : : 0, /* tp_as_sequence */
1896 : : 0, /* tp_as_mapping */
1897 : : (hashfunc)float_hash, /* tp_hash */
1898 : : 0, /* tp_call */
1899 : : 0, /* tp_str */
1900 : : PyObject_GenericGetAttr, /* tp_getattro */
1901 : : 0, /* tp_setattro */
1902 : : 0, /* tp_as_buffer */
1903 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
1904 : : _Py_TPFLAGS_MATCH_SELF, /* tp_flags */
1905 : : float_new__doc__, /* tp_doc */
1906 : : 0, /* tp_traverse */
1907 : : 0, /* tp_clear */
1908 : : float_richcompare, /* tp_richcompare */
1909 : : 0, /* tp_weaklistoffset */
1910 : : 0, /* tp_iter */
1911 : : 0, /* tp_iternext */
1912 : : float_methods, /* tp_methods */
1913 : : 0, /* tp_members */
1914 : : float_getset, /* tp_getset */
1915 : : 0, /* tp_base */
1916 : : 0, /* tp_dict */
1917 : : 0, /* tp_descr_get */
1918 : : 0, /* tp_descr_set */
1919 : : 0, /* tp_dictoffset */
1920 : : 0, /* tp_init */
1921 : : 0, /* tp_alloc */
1922 : : float_new, /* tp_new */
1923 : : .tp_vectorcall = (vectorcallfunc)float_vectorcall,
1924 : : };
1925 : :
1926 : : void
1927 : 3138 : _PyFloat_InitState(PyInterpreterState *interp)
1928 : : {
1929 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
1930 : 171 : return;
1931 : : }
1932 : :
1933 : : float_format_type detected_double_format, detected_float_format;
1934 : :
1935 : : /* We attempt to determine if this machine is using IEEE
1936 : : floating point formats by peering at the bits of some
1937 : : carefully chosen values. If it looks like we are on an
1938 : : IEEE platform, the float packing/unpacking routines can
1939 : : just copy bits, if not they resort to arithmetic & shifts
1940 : : and masks. The shifts & masks approach works on all finite
1941 : : values, but what happens to infinities, NaNs and signed
1942 : : zeroes on packing is an accident, and attempting to unpack
1943 : : a NaN or an infinity will raise an exception.
1944 : :
1945 : : Note that if we're on some whacked-out platform which uses
1946 : : IEEE formats but isn't strictly little-endian or big-
1947 : : endian, we will fall back to the portable shifts & masks
1948 : : method. */
1949 : :
1950 : : #if SIZEOF_DOUBLE == 8
1951 : : {
1952 : 2967 : double x = 9006104071832581.0;
1953 [ - + ]: 2967 : if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
1954 : 0 : detected_double_format = ieee_big_endian_format;
1955 [ + - ]: 2967 : else if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
1956 : 2967 : detected_double_format = ieee_little_endian_format;
1957 : : else
1958 : 0 : detected_double_format = unknown_format;
1959 : : }
1960 : : #else
1961 : : detected_double_format = unknown_format;
1962 : : #endif
1963 : :
1964 : : #if SIZEOF_FLOAT == 4
1965 : : {
1966 : 2967 : float y = 16711938.0;
1967 [ - + ]: 2967 : if (memcmp(&y, "\x4b\x7f\x01\x02", 4) == 0)
1968 : 0 : detected_float_format = ieee_big_endian_format;
1969 [ + - ]: 2967 : else if (memcmp(&y, "\x02\x01\x7f\x4b", 4) == 0)
1970 : 2967 : detected_float_format = ieee_little_endian_format;
1971 : : else
1972 : 0 : detected_float_format = unknown_format;
1973 : : }
1974 : : #else
1975 : : detected_float_format = unknown_format;
1976 : : #endif
1977 : :
1978 : 2967 : double_format = detected_double_format;
1979 : 2967 : float_format = detected_float_format;
1980 : : }
1981 : :
1982 : : PyStatus
1983 : 3138 : _PyFloat_InitTypes(PyInterpreterState *interp)
1984 : : {
1985 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
1986 : 171 : return _PyStatus_OK();
1987 : : }
1988 : :
1989 [ - + ]: 2967 : if (PyType_Ready(&PyFloat_Type) < 0) {
1990 : 0 : return _PyStatus_ERR("Can't initialize float type");
1991 : : }
1992 : :
1993 : : /* Init float info */
1994 [ + - ]: 2967 : if (FloatInfoType.tp_name == NULL) {
1995 [ - + ]: 2967 : if (PyStructSequence_InitType2(&FloatInfoType, &floatinfo_desc) < 0) {
1996 : 0 : return _PyStatus_ERR("can't init float info type");
1997 : : }
1998 : : }
1999 : :
2000 : 2967 : return _PyStatus_OK();
2001 : : }
2002 : :
2003 : : void
2004 : 29824 : _PyFloat_ClearFreeList(PyInterpreterState *interp)
2005 : : {
2006 : : #if PyFloat_MAXFREELIST > 0
2007 : 29824 : struct _Py_float_state *state = &interp->float_state;
2008 : 29824 : PyFloatObject *f = state->free_list;
2009 [ + + ]: 206042 : while (f != NULL) {
2010 : 176218 : PyFloatObject *next = (PyFloatObject*) Py_TYPE(f);
2011 : 176218 : PyObject_Free(f);
2012 : 176218 : f = next;
2013 : : }
2014 : 29824 : state->free_list = NULL;
2015 : 29824 : state->numfree = 0;
2016 : : #endif
2017 : 29824 : }
2018 : :
2019 : : void
2020 : 3125 : _PyFloat_Fini(PyInterpreterState *interp)
2021 : : {
2022 : 3125 : _PyFloat_ClearFreeList(interp);
2023 : : #if defined(Py_DEBUG) && PyFloat_MAXFREELIST > 0
2024 : : struct _Py_float_state *state = &interp->float_state;
2025 : : state->numfree = -1;
2026 : : #endif
2027 : 3125 : }
2028 : :
2029 : : void
2030 : 3125 : _PyFloat_FiniType(PyInterpreterState *interp)
2031 : : {
2032 [ + + ]: 3125 : if (_Py_IsMainInterpreter(interp)) {
2033 : 2956 : _PyStructSequence_FiniType(&FloatInfoType);
2034 : : }
2035 : 3125 : }
2036 : :
2037 : : /* Print summary info about the state of the optimized allocator */
2038 : : void
2039 : 1 : _PyFloat_DebugMallocStats(FILE *out)
2040 : : {
2041 : : #if PyFloat_MAXFREELIST > 0
2042 : 1 : struct _Py_float_state *state = get_float_state();
2043 : 1 : _PyDebugAllocatorStats(out,
2044 : : "free PyFloatObject",
2045 : : state->numfree, sizeof(PyFloatObject));
2046 : : #endif
2047 : 1 : }
2048 : :
2049 : :
2050 : : /*----------------------------------------------------------------------------
2051 : : * PyFloat_{Pack,Unpack}{2,4,8}. See floatobject.h.
2052 : : * To match the NPY_HALF_ROUND_TIES_TO_EVEN behavior in:
2053 : : * https://github.com/numpy/numpy/blob/master/numpy/core/src/npymath/halffloat.c
2054 : : * We use:
2055 : : * bits = (unsigned short)f; Note the truncation
2056 : : * if ((f - bits > 0.5) || (f - bits == 0.5 && bits % 2)) {
2057 : : * bits++;
2058 : : * }
2059 : : */
2060 : :
2061 : : int
2062 : 78 : PyFloat_Pack2(double x, char *data, int le)
2063 : : {
2064 : 78 : unsigned char *p = (unsigned char *)data;
2065 : : unsigned char sign;
2066 : : int e;
2067 : : double f;
2068 : : unsigned short bits;
2069 : 78 : int incr = 1;
2070 : :
2071 [ + + ]: 78 : if (x == 0.0) {
2072 : 6 : sign = (copysign(1.0, x) == -1.0);
2073 : 6 : e = 0;
2074 : 6 : bits = 0;
2075 : : }
2076 [ + + ]: 72 : else if (Py_IS_INFINITY(x)) {
2077 : 8 : sign = (x < 0.0);
2078 : 8 : e = 0x1f;
2079 : 8 : bits = 0;
2080 : : }
2081 [ + + ]: 64 : else if (Py_IS_NAN(x)) {
2082 : : /* There are 2046 distinct half-precision NaNs (1022 signaling and
2083 : : 1024 quiet), but there are only two quiet NaNs that don't arise by
2084 : : quieting a signaling NaN; we get those by setting the topmost bit
2085 : : of the fraction field and clearing all other fraction bits. We
2086 : : choose the one with the appropriate sign. */
2087 : 4 : sign = (copysign(1.0, x) == -1.0);
2088 : 4 : e = 0x1f;
2089 : 4 : bits = 512;
2090 : : }
2091 : : else {
2092 : 60 : sign = (x < 0.0);
2093 [ + + ]: 60 : if (sign) {
2094 : 16 : x = -x;
2095 : : }
2096 : :
2097 : 60 : f = frexp(x, &e);
2098 [ + - - + ]: 60 : if (f < 0.5 || f >= 1.0) {
2099 : 0 : PyErr_SetString(PyExc_SystemError,
2100 : : "frexp() result out of range");
2101 : 0 : return -1;
2102 : : }
2103 : :
2104 : : /* Normalize f to be in the range [1.0, 2.0) */
2105 : 60 : f *= 2.0;
2106 : 60 : e--;
2107 : :
2108 [ + + ]: 60 : if (e >= 16) {
2109 : 8 : goto Overflow;
2110 : : }
2111 [ + + ]: 52 : else if (e < -25) {
2112 : : /* |x| < 2**-25. Underflow to zero. */
2113 : 2 : f = 0.0;
2114 : 2 : e = 0;
2115 : : }
2116 [ + + ]: 50 : else if (e < -14) {
2117 : : /* |x| < 2**-14. Gradual underflow */
2118 : 10 : f = ldexp(f, 14 + e);
2119 : 10 : e = 0;
2120 : : }
2121 : : else /* if (!(e == 0 && f == 0.0)) */ {
2122 : 40 : e += 15;
2123 : 40 : f -= 1.0; /* Get rid of leading 1 */
2124 : : }
2125 : :
2126 : 52 : f *= 1024.0; /* 2**10 */
2127 : : /* Round to even */
2128 : 52 : bits = (unsigned short)f; /* Note the truncation */
2129 : : assert(bits < 1024);
2130 : : assert(e < 31);
2131 [ + + + + : 52 : if ((f - bits > 0.5) || ((f - bits == 0.5) && (bits % 2 == 1))) {
+ + ]
2132 : 9 : ++bits;
2133 [ + + ]: 9 : if (bits == 1024) {
2134 : : /* The carry propagated out of a string of 10 1 bits. */
2135 : 5 : bits = 0;
2136 : 5 : ++e;
2137 [ + + ]: 5 : if (e == 31)
2138 : 4 : goto Overflow;
2139 : : }
2140 : : }
2141 : : }
2142 : :
2143 : 66 : bits |= (e << 10) | (sign << 15);
2144 : :
2145 : : /* Write out result. */
2146 [ + + ]: 66 : if (le) {
2147 : 29 : p += 1;
2148 : 29 : incr = -1;
2149 : : }
2150 : :
2151 : : /* First byte */
2152 : 66 : *p = (unsigned char)((bits >> 8) & 0xFF);
2153 : 66 : p += incr;
2154 : :
2155 : : /* Second byte */
2156 : 66 : *p = (unsigned char)(bits & 0xFF);
2157 : :
2158 : 66 : return 0;
2159 : :
2160 : 12 : Overflow:
2161 : 12 : PyErr_SetString(PyExc_OverflowError,
2162 : : "float too large to pack with e format");
2163 : 12 : return -1;
2164 : : }
2165 : :
2166 : : int
2167 : 213595 : PyFloat_Pack4(double x, char *data, int le)
2168 : : {
2169 : 213595 : unsigned char *p = (unsigned char *)data;
2170 [ - + ]: 213595 : if (float_format == unknown_format) {
2171 : : unsigned char sign;
2172 : : int e;
2173 : : double f;
2174 : : unsigned int fbits;
2175 : 0 : int incr = 1;
2176 : :
2177 [ # # ]: 0 : if (le) {
2178 : 0 : p += 3;
2179 : 0 : incr = -1;
2180 : : }
2181 : :
2182 [ # # ]: 0 : if (x < 0) {
2183 : 0 : sign = 1;
2184 : 0 : x = -x;
2185 : : }
2186 : : else
2187 : 0 : sign = 0;
2188 : :
2189 : 0 : f = frexp(x, &e);
2190 : :
2191 : : /* Normalize f to be in the range [1.0, 2.0) */
2192 [ # # # # ]: 0 : if (0.5 <= f && f < 1.0) {
2193 : 0 : f *= 2.0;
2194 : 0 : e--;
2195 : : }
2196 [ # # ]: 0 : else if (f == 0.0)
2197 : 0 : e = 0;
2198 : : else {
2199 : 0 : PyErr_SetString(PyExc_SystemError,
2200 : : "frexp() result out of range");
2201 : 0 : return -1;
2202 : : }
2203 : :
2204 [ # # ]: 0 : if (e >= 128)
2205 : 0 : goto Overflow;
2206 [ # # ]: 0 : else if (e < -126) {
2207 : : /* Gradual underflow */
2208 : 0 : f = ldexp(f, 126 + e);
2209 : 0 : e = 0;
2210 : : }
2211 [ # # # # ]: 0 : else if (!(e == 0 && f == 0.0)) {
2212 : 0 : e += 127;
2213 : 0 : f -= 1.0; /* Get rid of leading 1 */
2214 : : }
2215 : :
2216 : 0 : f *= 8388608.0; /* 2**23 */
2217 : 0 : fbits = (unsigned int)(f + 0.5); /* Round */
2218 : : assert(fbits <= 8388608);
2219 [ # # ]: 0 : if (fbits >> 23) {
2220 : : /* The carry propagated out of a string of 23 1 bits. */
2221 : 0 : fbits = 0;
2222 : 0 : ++e;
2223 [ # # ]: 0 : if (e >= 255)
2224 : 0 : goto Overflow;
2225 : : }
2226 : :
2227 : : /* First byte */
2228 : 0 : *p = (sign << 7) | (e >> 1);
2229 : 0 : p += incr;
2230 : :
2231 : : /* Second byte */
2232 : 0 : *p = (char) (((e & 1) << 7) | (fbits >> 16));
2233 : 0 : p += incr;
2234 : :
2235 : : /* Third byte */
2236 : 0 : *p = (fbits >> 8) & 0xFF;
2237 : 0 : p += incr;
2238 : :
2239 : : /* Fourth byte */
2240 : 0 : *p = fbits & 0xFF;
2241 : :
2242 : : /* Done */
2243 : 0 : return 0;
2244 : :
2245 : : }
2246 : : else {
2247 : 213595 : float y = (float)x;
2248 : 213595 : int i, incr = 1;
2249 : :
2250 [ + + + + ]: 213595 : if (Py_IS_INFINITY(y) && !Py_IS_INFINITY(x))
2251 : 1 : goto Overflow;
2252 : :
2253 : : unsigned char s[sizeof(float)];
2254 : 213594 : memcpy(s, &y, sizeof(float));
2255 : :
2256 [ + - + + ]: 213594 : if ((float_format == ieee_little_endian_format && !le)
2257 [ - + - - ]: 205417 : || (float_format == ieee_big_endian_format && le)) {
2258 : 8177 : p += 3;
2259 : 8177 : incr = -1;
2260 : : }
2261 : :
2262 [ + + ]: 1067970 : for (i = 0; i < 4; i++) {
2263 : 854376 : *p = s[i];
2264 : 854376 : p += incr;
2265 : : }
2266 : 213594 : return 0;
2267 : : }
2268 : 1 : Overflow:
2269 : 1 : PyErr_SetString(PyExc_OverflowError,
2270 : : "float too large to pack with f format");
2271 : 1 : return -1;
2272 : : }
2273 : :
2274 : : int
2275 : 78652 : PyFloat_Pack8(double x, char *data, int le)
2276 : : {
2277 : 78652 : unsigned char *p = (unsigned char *)data;
2278 [ - + ]: 78652 : if (double_format == unknown_format) {
2279 : : unsigned char sign;
2280 : : int e;
2281 : : double f;
2282 : : unsigned int fhi, flo;
2283 : 0 : int incr = 1;
2284 : :
2285 [ # # ]: 0 : if (le) {
2286 : 0 : p += 7;
2287 : 0 : incr = -1;
2288 : : }
2289 : :
2290 [ # # ]: 0 : if (x < 0) {
2291 : 0 : sign = 1;
2292 : 0 : x = -x;
2293 : : }
2294 : : else
2295 : 0 : sign = 0;
2296 : :
2297 : 0 : f = frexp(x, &e);
2298 : :
2299 : : /* Normalize f to be in the range [1.0, 2.0) */
2300 [ # # # # ]: 0 : if (0.5 <= f && f < 1.0) {
2301 : 0 : f *= 2.0;
2302 : 0 : e--;
2303 : : }
2304 [ # # ]: 0 : else if (f == 0.0)
2305 : 0 : e = 0;
2306 : : else {
2307 : 0 : PyErr_SetString(PyExc_SystemError,
2308 : : "frexp() result out of range");
2309 : 0 : return -1;
2310 : : }
2311 : :
2312 [ # # ]: 0 : if (e >= 1024)
2313 : 0 : goto Overflow;
2314 [ # # ]: 0 : else if (e < -1022) {
2315 : : /* Gradual underflow */
2316 : 0 : f = ldexp(f, 1022 + e);
2317 : 0 : e = 0;
2318 : : }
2319 [ # # # # ]: 0 : else if (!(e == 0 && f == 0.0)) {
2320 : 0 : e += 1023;
2321 : 0 : f -= 1.0; /* Get rid of leading 1 */
2322 : : }
2323 : :
2324 : : /* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */
2325 : 0 : f *= 268435456.0; /* 2**28 */
2326 : 0 : fhi = (unsigned int)f; /* Truncate */
2327 : : assert(fhi < 268435456);
2328 : :
2329 : 0 : f -= (double)fhi;
2330 : 0 : f *= 16777216.0; /* 2**24 */
2331 : 0 : flo = (unsigned int)(f + 0.5); /* Round */
2332 : : assert(flo <= 16777216);
2333 [ # # ]: 0 : if (flo >> 24) {
2334 : : /* The carry propagated out of a string of 24 1 bits. */
2335 : 0 : flo = 0;
2336 : 0 : ++fhi;
2337 [ # # ]: 0 : if (fhi >> 28) {
2338 : : /* And it also propagated out of the next 28 bits. */
2339 : 0 : fhi = 0;
2340 : 0 : ++e;
2341 [ # # ]: 0 : if (e >= 2047)
2342 : 0 : goto Overflow;
2343 : : }
2344 : : }
2345 : :
2346 : : /* First byte */
2347 : 0 : *p = (sign << 7) | (e >> 4);
2348 : 0 : p += incr;
2349 : :
2350 : : /* Second byte */
2351 : 0 : *p = (unsigned char) (((e & 0xF) << 4) | (fhi >> 24));
2352 : 0 : p += incr;
2353 : :
2354 : : /* Third byte */
2355 : 0 : *p = (fhi >> 16) & 0xFF;
2356 : 0 : p += incr;
2357 : :
2358 : : /* Fourth byte */
2359 : 0 : *p = (fhi >> 8) & 0xFF;
2360 : 0 : p += incr;
2361 : :
2362 : : /* Fifth byte */
2363 : 0 : *p = fhi & 0xFF;
2364 : 0 : p += incr;
2365 : :
2366 : : /* Sixth byte */
2367 : 0 : *p = (flo >> 16) & 0xFF;
2368 : 0 : p += incr;
2369 : :
2370 : : /* Seventh byte */
2371 : 0 : *p = (flo >> 8) & 0xFF;
2372 : 0 : p += incr;
2373 : :
2374 : : /* Eighth byte */
2375 : 0 : *p = flo & 0xFF;
2376 : : /* p += incr; */
2377 : :
2378 : : /* Done */
2379 : 0 : return 0;
2380 : :
2381 : 0 : Overflow:
2382 : 0 : PyErr_SetString(PyExc_OverflowError,
2383 : : "float too large to pack with d format");
2384 : 0 : return -1;
2385 : : }
2386 : : else {
2387 : 78652 : const unsigned char *s = (unsigned char*)&x;
2388 : 78652 : int i, incr = 1;
2389 : :
2390 [ + - + + ]: 78652 : if ((double_format == ieee_little_endian_format && !le)
2391 [ - + - - ]: 22908 : || (double_format == ieee_big_endian_format && le)) {
2392 : 55744 : p += 7;
2393 : 55744 : incr = -1;
2394 : : }
2395 : :
2396 [ + + ]: 707868 : for (i = 0; i < 8; i++) {
2397 : 629216 : *p = *s++;
2398 : 629216 : p += incr;
2399 : : }
2400 : 78652 : return 0;
2401 : : }
2402 : : }
2403 : :
2404 : : double
2405 : 56 : PyFloat_Unpack2(const char *data, int le)
2406 : : {
2407 : 56 : unsigned char *p = (unsigned char *)data;
2408 : : unsigned char sign;
2409 : : int e;
2410 : : unsigned int f;
2411 : : double x;
2412 : 56 : int incr = 1;
2413 : :
2414 [ + + ]: 56 : if (le) {
2415 : 33 : p += 1;
2416 : 33 : incr = -1;
2417 : : }
2418 : :
2419 : : /* First byte */
2420 : 56 : sign = (*p >> 7) & 1;
2421 : 56 : e = (*p & 0x7C) >> 2;
2422 : 56 : f = (*p & 0x03) << 8;
2423 : 56 : p += incr;
2424 : :
2425 : : /* Second byte */
2426 : 56 : f |= *p;
2427 : :
2428 [ + + ]: 56 : if (e == 0x1f) {
2429 : : #if _PY_SHORT_FLOAT_REPR == 0
2430 : : if (f == 0) {
2431 : : /* Infinity */
2432 : : return sign ? -Py_HUGE_VAL : Py_HUGE_VAL;
2433 : : }
2434 : : else {
2435 : : /* NaN */
2436 : : return sign ? -Py_NAN : Py_NAN;
2437 : : }
2438 : : #else // _PY_SHORT_FLOAT_REPR == 1
2439 [ + + ]: 22 : if (f == 0) {
2440 : : /* Infinity */
2441 : 8 : return _Py_dg_infinity(sign);
2442 : : }
2443 : : else {
2444 : : /* NaN */
2445 : 14 : return _Py_dg_stdnan(sign);
2446 : : }
2447 : : #endif // _PY_SHORT_FLOAT_REPR == 1
2448 : : }
2449 : :
2450 : 34 : x = (double)f / 1024.0;
2451 : :
2452 [ + + ]: 34 : if (e == 0) {
2453 : 9 : e = -14;
2454 : : }
2455 : : else {
2456 : 25 : x += 1.0;
2457 : 25 : e -= 15;
2458 : : }
2459 : 34 : x = ldexp(x, e);
2460 : :
2461 [ + + ]: 34 : if (sign)
2462 : 6 : x = -x;
2463 : :
2464 : 34 : return x;
2465 : : }
2466 : :
2467 : : double
2468 : 46473 : PyFloat_Unpack4(const char *data, int le)
2469 : : {
2470 : 46473 : unsigned char *p = (unsigned char *)data;
2471 [ - + ]: 46473 : if (float_format == unknown_format) {
2472 : : unsigned char sign;
2473 : : int e;
2474 : : unsigned int f;
2475 : : double x;
2476 : 0 : int incr = 1;
2477 : :
2478 [ # # ]: 0 : if (le) {
2479 : 0 : p += 3;
2480 : 0 : incr = -1;
2481 : : }
2482 : :
2483 : : /* First byte */
2484 : 0 : sign = (*p >> 7) & 1;
2485 : 0 : e = (*p & 0x7F) << 1;
2486 : 0 : p += incr;
2487 : :
2488 : : /* Second byte */
2489 : 0 : e |= (*p >> 7) & 1;
2490 : 0 : f = (*p & 0x7F) << 16;
2491 : 0 : p += incr;
2492 : :
2493 [ # # ]: 0 : if (e == 255) {
2494 : 0 : PyErr_SetString(
2495 : : PyExc_ValueError,
2496 : : "can't unpack IEEE 754 special value "
2497 : : "on non-IEEE platform");
2498 : 0 : return -1;
2499 : : }
2500 : :
2501 : : /* Third byte */
2502 : 0 : f |= *p << 8;
2503 : 0 : p += incr;
2504 : :
2505 : : /* Fourth byte */
2506 : 0 : f |= *p;
2507 : :
2508 : 0 : x = (double)f / 8388608.0;
2509 : :
2510 : : /* XXX This sadly ignores Inf/NaN issues */
2511 [ # # ]: 0 : if (e == 0)
2512 : 0 : e = -126;
2513 : : else {
2514 : 0 : x += 1.0;
2515 : 0 : e -= 127;
2516 : : }
2517 : 0 : x = ldexp(x, e);
2518 : :
2519 [ # # ]: 0 : if (sign)
2520 : 0 : x = -x;
2521 : :
2522 : 0 : return x;
2523 : : }
2524 : : else {
2525 : : float x;
2526 : :
2527 [ + - + + ]: 46473 : if ((float_format == ieee_little_endian_format && !le)
2528 [ - + - - ]: 32298 : || (float_format == ieee_big_endian_format && le)) {
2529 : : char buf[4];
2530 : 14175 : char *d = &buf[3];
2531 : : int i;
2532 : :
2533 [ + + ]: 70875 : for (i = 0; i < 4; i++) {
2534 : 56700 : *d-- = *p++;
2535 : : }
2536 : 14175 : memcpy(&x, buf, 4);
2537 : : }
2538 : : else {
2539 : 32298 : memcpy(&x, p, 4);
2540 : : }
2541 : :
2542 : 46473 : return x;
2543 : : }
2544 : : }
2545 : :
2546 : : double
2547 : 182387 : PyFloat_Unpack8(const char *data, int le)
2548 : : {
2549 : 182387 : unsigned char *p = (unsigned char *)data;
2550 [ - + ]: 182387 : if (double_format == unknown_format) {
2551 : : unsigned char sign;
2552 : : int e;
2553 : : unsigned int fhi, flo;
2554 : : double x;
2555 : 0 : int incr = 1;
2556 : :
2557 [ # # ]: 0 : if (le) {
2558 : 0 : p += 7;
2559 : 0 : incr = -1;
2560 : : }
2561 : :
2562 : : /* First byte */
2563 : 0 : sign = (*p >> 7) & 1;
2564 : 0 : e = (*p & 0x7F) << 4;
2565 : :
2566 : 0 : p += incr;
2567 : :
2568 : : /* Second byte */
2569 : 0 : e |= (*p >> 4) & 0xF;
2570 : 0 : fhi = (*p & 0xF) << 24;
2571 : 0 : p += incr;
2572 : :
2573 [ # # ]: 0 : if (e == 2047) {
2574 : 0 : PyErr_SetString(
2575 : : PyExc_ValueError,
2576 : : "can't unpack IEEE 754 special value "
2577 : : "on non-IEEE platform");
2578 : 0 : return -1.0;
2579 : : }
2580 : :
2581 : : /* Third byte */
2582 : 0 : fhi |= *p << 16;
2583 : 0 : p += incr;
2584 : :
2585 : : /* Fourth byte */
2586 : 0 : fhi |= *p << 8;
2587 : 0 : p += incr;
2588 : :
2589 : : /* Fifth byte */
2590 : 0 : fhi |= *p;
2591 : 0 : p += incr;
2592 : :
2593 : : /* Sixth byte */
2594 : 0 : flo = *p << 16;
2595 : 0 : p += incr;
2596 : :
2597 : : /* Seventh byte */
2598 : 0 : flo |= *p << 8;
2599 : 0 : p += incr;
2600 : :
2601 : : /* Eighth byte */
2602 : 0 : flo |= *p;
2603 : :
2604 : 0 : x = (double)fhi + (double)flo / 16777216.0; /* 2**24 */
2605 : 0 : x /= 268435456.0; /* 2**28 */
2606 : :
2607 [ # # ]: 0 : if (e == 0)
2608 : 0 : e = -1022;
2609 : : else {
2610 : 0 : x += 1.0;
2611 : 0 : e -= 1023;
2612 : : }
2613 : 0 : x = ldexp(x, e);
2614 : :
2615 [ # # ]: 0 : if (sign)
2616 : 0 : x = -x;
2617 : :
2618 : 0 : return x;
2619 : : }
2620 : : else {
2621 : : double x;
2622 : :
2623 [ + - + + ]: 182387 : if ((double_format == ieee_little_endian_format && !le)
2624 [ - + - - ]: 129989 : || (double_format == ieee_big_endian_format && le)) {
2625 : : char buf[8];
2626 : 52398 : char *d = &buf[7];
2627 : : int i;
2628 : :
2629 [ + + ]: 471582 : for (i = 0; i < 8; i++) {
2630 : 419184 : *d-- = *p++;
2631 : : }
2632 : 52398 : memcpy(&x, buf, 8);
2633 : : }
2634 : : else {
2635 : 129989 : memcpy(&x, p, 8);
2636 : : }
2637 : :
2638 : 182387 : return x;
2639 : : }
2640 : : }
|
