source: python/trunk/Objects/floatobject.c@ 384

Last change on this file since 384 was 2, checked in by Yuri Dario, 15 years ago

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