FilesExpand file tree

 parse-bytecode

/

float2int_doubleprec.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

92 lines (82 loc) · 2.64 KB

 parse-bytecode

/

float2int_doubleprec.py

Copy path

Top

File metadata and controls

• Code
• Blame

92 lines (82 loc) · 2.64 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

# check cases converting float to int, requiring double precision float

try:

import ustruct as struct

except:

import struct

# work out configuration values

is_64bit = struct.calcsize("P") == 8

# 0 = none, 1 = long long, 2 = mpz

try:

dummy = 0x7fffffffffffffff

try:

if (0xffffffffffffffff + 1) > 0:

ll_type = 2

else:

ll_type = 1

except:

# in case the sum in the if statement above changes to raising an exception on overflow

ll_type = 1

except:

ll_type = 0

# This case occurs with time.time() values

if ll_type != 0:

print(int(1418774543.))

print("%d" % 1418774543.)

if ll_type == 3:

print(int(2.**100))

print("%d" % 2.**100)

else:

print(int(1073741823.))

print("%d" % 1073741823.)

testpass = True

p2_rng = ((30,63,1024),(62,63,1024))[is_64bit][ll_type]

for i in range(0,p2_rng):

bitcnt = len(bin(int(2.**i))) - 3;

if i != bitcnt:

print('fail: 2**%u was %u bits long' % (i, bitcnt));

testpass = False

print("power of 2 test: %s" % (testpass and 'passed' or 'failed'))

testpass = True

p10_rng = ((9,18,23),(18,18,23))[is_64bit][ll_type]

for i in range(0,p10_rng):

digcnt = len(str(int(10.**i))) - 1;

if i != digcnt:

print('fail: 10**%u was %u digits long' % (i, digcnt));

testpass = False

print("power of 10 test: %s" % (testpass and 'passed' or 'failed'))

def fp2int_test(num, name, should_fail):

try:

x = int(num)

passed = ~should_fail

except:

passed = should_fail

print('%s: %s' % (name, passed and 'passed' or 'failed'))

if ll_type != 2:

if ll_type == 0:

if is_64bit:

neg_bad_fp = -1.00000005*2.**62.

pos_bad_fp = 2.**62.

neg_good_fp = -2.**62.

pos_good_fp = 0.99999993*2.**62.

else:

neg_bad_fp = -1.00000005*2.**30.

pos_bad_fp = 2.**30.

neg_good_fp = -2.**30.

pos_good_fp = 0.9999999499*2.**30.

else:

neg_bad_fp = -0.51*2.**64.

pos_bad_fp = 2.**63.

neg_good_fp = -2.**63.

pos_good_fp = 1.9999998*2.**62.

fp2int_test(neg_bad_fp, 'neg bad', True)

fp2int_test(pos_bad_fp, 'pos bad', True)

fp2int_test(neg_good_fp, 'neg good', False)

fp2int_test(pos_good_fp, 'pos good', False)

else:

fp2int_test(-1.9999999999999981*2.**1023., 'large neg', False)

fp2int_test(1.9999999999999981*2.**1023., 'large pos', False)

fp2int_test(float('inf'), 'inf test', True)

fp2int_test(float('nan'), 'NaN test', True)

# test numbers < 1 (this used to fail; see issue #1044)

fp2int_test(0.0001, 'small num', False)

struct.pack('I', int(1/2))