Mercurial > cpython-lru_cache-weakref

annotate Objects/floatobject.c @ 48980:5fd39b84fc29 legacy-trunk

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