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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
(* TEST *)
let is_nan2 (x, y) = Float.is_nan x && Float.is_nan y
type test = True of (unit -> bool)
| False of (unit -> bool)
| Equal of ((unit -> float) * float)
| Pair of ((unit -> float * float) * (float * float))
let cases = [
( 1, True (fun () -> Float.is_finite 1.));
( 2, True (fun () -> Float.is_finite Float.pi));
( 3, False(fun () -> Float.is_finite Float.infinity));
( 4, False(fun () -> Float.is_finite Float.nan));
( 5, True (fun () -> Float.is_infinite Float.infinity));
( 6, False(fun () -> Float.is_infinite 1.));
( 7, False(fun () -> Float.is_infinite Float.nan));
( 8, True (fun () -> Float.is_nan Float.nan));
( 9, False(fun () -> Float.is_nan 1.));
(10, False(fun () -> Float.is_nan neg_infinity));
(11, True (fun () -> Float.is_integer 1.));
(12, True (fun () -> Float.is_integer (-1e10)));
(13, False(fun () -> Float.is_integer 1.5));
(14, False(fun () -> Float.is_integer Float.infinity));
(15, False(fun () -> Float.is_integer Float.nan));
(16, Equal((fun () -> Float.trunc 1.5), 1.));
(17, Equal((fun () -> Float.trunc (-1.5)), -1.));
(18, Equal(Float.((fun () -> trunc infinity), infinity)));
(19, Equal(Float.(((fun () -> trunc neg_infinity), neg_infinity))));
(20, True (fun () -> Float.(is_nan(trunc nan))));
(21, Equal((fun () -> Float.round 0.5), 1.));
(22, Equal((fun () -> Float.round (-0.5)), -1.));
(23, Equal((fun () -> Float.round 1.5), 2.));
(24, Equal((fun () -> Float.round (-1.5)), -2.));
(25, let x = 0x1.0000000000001p52 in (* x + 0.5 rounds to x +. 1. *)
Equal((fun () -> Float.round x), x));
(26, Equal((fun () -> Float.round (Float.next_after 0.5 0.)), 0.));
(27, Equal(Float.((fun () -> round infinity), infinity)));
(28, Equal(Float.((fun () -> round neg_infinity), neg_infinity)));
(29, True (fun () -> Float.(is_nan(round nan))));
(30, Equal((fun () -> Float.next_after 0x1.FFFFFFFFFFFFFp-2 1.), 0.5));
(31, Equal((fun () -> Float.next_after 0x1.FFFFFFFFFFFFFp-2 0.), 0x1.FFFFFFFFFFFFEp-2));
(32, Equal(Float.((fun () -> next_after 0x1.FFFFFFFFFFFFFp-2 infinity), 0.5)));
(33, Equal(Float.((fun () -> next_after 0x1.FFFFFFFFFFFFFp-2 neg_infinity), 0x1.FFFFFFFFFFFFEp-2)));
(34, Equal((fun () -> Float.next_after 1. 1.), 1.));
(35, True (fun () -> Float.(is_nan(next_after nan 1.))));
(36, True (fun () -> Float.(is_nan(next_after 3. nan))));
(37, Equal(Float.((fun () -> succ 0x1.FFFFFFFFFFFFFp-2), 0.5)));
(38, Equal(Float.((fun () -> pred 0.5), 0x1.FFFFFFFFFFFFFp-2)));
(39, True (Float.(fun () -> succ 0. > 0.)));
(40, True (Float.(fun () -> pred 0. < 0.)));
(41, Equal(Float.((fun () -> succ max_float), infinity)));
(42, Equal(Float.((fun () -> pred (-. max_float)), neg_infinity)));
(43, True (Float.(fun () -> succ 0. < min_float)));
(44, Equal(Float.((fun () -> succ infinity), infinity)));
(45, Equal(Float.((fun () -> pred neg_infinity), neg_infinity)));
(46, True (Float.(fun () -> is_nan(succ nan))));
(47, True (Float.(fun () -> is_nan(pred nan))));
(48, False(fun () -> Float.sign_bit 1.));
(49, True (fun () -> Float.sign_bit (-1.)));
(50, False(fun () -> Float.sign_bit 0.));
(51, True (fun () -> Float.sign_bit (-0.)));
(52, False(fun () -> Float.sign_bit infinity));
(53, True (fun () -> Float.sign_bit neg_infinity));
(54, Equal((fun () -> Float.min 1. 2.), 1.));
(55, Equal((fun () -> Float.min 2. 1.), 1.));
(56, True (fun () -> Float.(is_nan(min 1. nan))));
(57, True (fun () -> Float.(is_nan(min nan 2.))));
(58, True (fun () -> Float.(is_nan(min nan nan))));
(59, Equal((fun () -> 1. /. Float.min (-0.) (+0.)), neg_infinity));
(60, Equal((fun () -> 1. /. Float.min (+0.) (-0.)), neg_infinity));
(61, Equal((fun () -> Float.max 1. 2.), 2.));
(62, Equal((fun () -> Float.max 2. 1.), 2.));
(63, True (fun () -> Float.(is_nan(max 1. nan))));
(64, True (fun () -> Float.(is_nan(max nan 2.))));
(65, True (fun () -> Float.(is_nan(max nan nan))));
(66, Equal((fun () -> 1. /. Float.max (-0.) (+0.)), infinity));
(67, Equal((fun () -> 1. /. Float.max (+0.) (-0.)), infinity));
(68, Pair ((fun () -> Float.min_max 1. 2.), (1., 2.)));
(69, Pair ((fun () -> Float.min_max 2. 1.), (1., 2.)));
(70, True (fun () -> Float.(is_nan2(min_max 1. nan))));
(71, True (fun () -> Float.(is_nan2(min_max nan 2.))));
(72, True (fun () -> Float.(is_nan2(min_max nan nan))));
(73, Pair ((fun () -> let x, y = Float.min_max (-0.) (+0.) in
(1. /. x, 1. /. y)), (neg_infinity, infinity)));
(74, Pair ((fun () -> let x, y = Float.min_max (+0.) (-0.) in
(1. /. x, 1. /. y)), (neg_infinity, infinity)));
(75, Equal((fun () -> Float.min_num 1. 2.), 1.));
(76, Equal(Float.((fun () -> min_num 1. nan), 1.)));
(77, Equal(Float.((fun () -> min_num nan 2.), 2.)));
(78, True (fun () -> Float.(is_nan(min_num nan nan))));
(79, Equal((fun () -> 1. /. Float.min_num (-0.) (+0.)), neg_infinity));
(80, Equal((fun () -> 1. /. Float.min_num (+0.) (-0.)), neg_infinity));
(81, Equal((fun () -> Float.max_num 1. 2.), 2.));
(82, Equal(Float.((fun () -> max_num 1. nan), 1.)));
(83, Equal(Float.((fun () -> max_num nan 2.), 2.)));
(84, True (fun () -> Float.(is_nan(max_num nan nan))));
(85, Equal((fun () -> 1. /. Float.max_num (-0.) (+0.)), infinity));
(86, Equal((fun () -> 1. /. Float.max_num (+0.) (-0.)), infinity));
(87, Pair ((fun () -> Float.min_max_num 1. 2.), (1., 2.)));
(88, Pair ((fun () -> Float.min_max_num 2. 1.), (1., 2.)));
(89, Pair ((fun () -> Float.min_max_num 1. nan), (1., 1.)));
(90, Pair ((fun () -> Float.min_max_num nan 1.), (1., 1.)));
(91, True (fun () -> Float.(is_nan2(min_max_num nan nan))));
(92, Pair ((fun () -> let x, y = Float.min_max_num (-0.) (+0.) in
(1. /. x, 1. /. y)), (neg_infinity, infinity)));
(93, Pair ((fun () -> let x, y = Float.min_max_num (+0.) (-0.) in
(1. /. x, 1. /. y)), (neg_infinity, infinity)));
]
let () =
let f (n, test) =
match test with
| True p ->
Printf.printf "%03d: %s\n%!" n (if p () then "OK" else "FAIL")
| False p ->
Printf.printf "%03d: %s\n%!" n (if p () then "FAIL" else "OK")
| Equal (f, result) ->
let v = f () in
if v = result then
Printf.printf "%03d: OK\n%!" n
else
Printf.printf "%03d: FAIL (%h returned instead of %h)\n%!" n v result
| Pair (f, ((l', r') as result)) ->
let (l, r) as v = f () in
if v = result then
Printf.printf "%03d: OK\n%!" n
else
Printf.printf "%03d: FAIL ((%h, %h) returned instead of (%h, %h))\n%!" n l r l' r'
in
List.iter f cases
|
