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