Debian Codegraph @

math/+test/floats_test.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 @test fn floatbits() void = {
5 const a: [_]f64 = [INF, -INF, 0.0, 1.0, -1.0, 123456789.0,
6 F64_MIN_SUBNORMAL, F64_MIN_NORMAL, F64_MAX_NORMAL];
7 for (let i = 0z; i < len(a); i += 1) {
8 assert(f64frombits(f64bits(a[i])) == a[i]);
9 };
10 const a: [_]f32 = [INF, -INF, 0.0, 1.0, -1.0, -123456.0,
11 F32_MIN_SUBNORMAL, F32_MIN_NORMAL, F32_MAX_NORMAL];
12 for (let i = 0z; i < len(a); i += 1) {
13 assert(f32frombits(f32bits(a[i])) == a[i]);
14 };
15 };
16
17 @test fn isnan() void = {
18 assert(isnan(NAN));
19 assert(isnan(-NAN));
20 assert(isnan(f64frombits(0xfffabcdef1234567)));
21 assert(!isnan(INF));
22 assert(!isnan(1.23f32));
23 };
24
25 @test fn float_normality() void = {
26 assert(isnormalf32(1.0));
27 assert(isnormalf32(0.0));
28 assert(!isnormalf32(NAN));
29 assert(!isnormalf32(INF));
30 assert(!isnormalf32(-1.0e-40));
31 assert(isnormalf32(-1.0e-50));
32
33 assert(isnormalf64(1.0));
34 assert(isnormalf64(0.0));
35 assert(!isnormalf64(NAN));
36 assert(!isnormalf64(INF));
37 assert(!isnormalf64(-1.0e-320));
38 assert(isnormalf64(-1.0e-330));
39
40 assert(issubnormalf32(1.0e-45));
41 assert(issubnormalf32(-1.0e-39));
42 assert(!issubnormalf32(-NAN));
43 assert(!issubnormalf32(-INF));
44 assert(!issubnormalf32(0.0));
45 assert(!issubnormalf32(-1.0e-49));
46
47 assert(issubnormalf64(5.0e-324));
48 assert(issubnormalf64(-2.0e-310));
49 assert(!issubnormalf64(-NAN));
50 assert(!issubnormalf64(-INF));
51 assert(!issubnormalf64(-1.0e-400));
52 assert(!issubnormalf64(0.0));
53 };
54
55 @test fn absf() void = {
56 for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) {
57 assert(absf64(TEST_INPUTS[idx]) == TEST_ABSF[idx]);
58 };
59 assert(absf64(2f64) == 2f64);
60 assert(absf32(2.0f32) == 2.0f32);
61 assert(absf64(-2f64) == 2f64);
62 assert(absf32(-2.0f32) == 2.0f32);
63 assert(absf64(0f64) == 0f64);
64 assert(absf32(0f32) == 0f32);
65 };
66
67 @test fn copysign() void = {
68 assert(copysignf64(100f64, 1f64) == 100f64);
69 assert(copysignf64(100f64, -1f64) == -100f64);
70 assert(copysignf32(100.0f32, 1.0f32) == 100.0f32);
71 assert(copysignf32(100.0f32, -1.0f32) == -100.0f32);
72 assert(copysignf64(100f64, 0f64) == 100f64);
73 assert(copysignf64(100f64, -0f64) == -100f64);
74 assert(copysignf64(0f64, 100f64) == 0f64);
75 assert(signf64(copysignf64(0f64, 100f64)) > 0);
76 assert(copysignf64(0f64, -100f64) == 0f64);
77 assert(signf64(copysignf64(0f64, -100f64)) < 0);
78 };
79
80 @test fn signf() void = {
81 for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) {
82 assert(signf64(TEST_INPUTS[idx]) == TEST_SIGNF[idx]);
83 };
84 assert(signf64(0f64) > 0);
85 assert(signf64(-0f64) < 0);
86 assert(signf32(0f32) > 0);
87 assert(signf32(-0f32) < 0);
88 assert(signf64(1.5f64) > 0);
89 assert(signf64(-1.5f64) < 0);
90 assert(ispositivef64(1f64));
91 assert(!ispositivef64(-1f64));
92 assert(isnegativef64(-1f64));
93 assert(!isnegativef64(1f64));
94 };
95
96 @test fn normalize() void = {
97 let res = normalizef64(5.0e-320);
98 assert(res.0 > F64_MIN_NORMAL);
99 assert(res.1 < 0i64);
100 res = normalizef64(5.0e-300);
101 assert(res.0 == 5.0e-300);
102 assert(res.1 == 0i64);
103 };
104
105 @test fn frexp() void = {
106 for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) {
107 let res = frexpf64(TEST_INPUTS[idx]);
108 let expected = TEST_FREXP[idx];
109 assert(res.0 == expected.0);
110 assert(res.1 == expected.1);
111 };
112 let res = frexpf64(3f64);
113 assert(res.0 == 0.75f64);
114 assert(res.1 == 2i64);
115 res = frexpf64(2.42f64);
116 assert(res.0 == 0.605f64);
117 assert(res.1 == 2i64);
118 let res = frexpf32(NAN);
119 assert(res.1 == 0);
120 res = frexpf32(INF);
121 assert(res.1 == 0);
122 };
123
124 @test fn frexp_ldexp() void = {
125 const tests64: [_]f64 = [INF, -INF,
126 0.0, 1.0, -1.0, 2.42, 123456789.0,
127 F64_MIN_NORMAL, F64_MAX_NORMAL,
128 3.0e-310f64];
129 for (let i = 0z; i < len(tests64); i += 1) {
130 const parts = frexpf64(tests64[i]);
131 const res64 = ldexpf64(parts.0, parts.1);
132 assert(res64 == tests64[i]);
133 };
134 assert(ldexpf64(1f64, -1076i64) == 0f64);
135 assert(ldexpf64(-1f64, -1076i64) == -0f64);
136 assert(signf64(ldexpf64(-1f64, -1076i64)) < 0);
137 assert(ldexpf64(2f64, 1024i64) == INF);
138 assert(ldexpf64(-2f64, 1024i64) == -INF);
139
140 const tests32: [_]f32 = [INF, -INF,
141 0.0, 1.0, -1.0, 2.42, 123456789.0,
142 F32_MIN_NORMAL, F32_MAX_NORMAL,
143 3.0e-39f32];
144 for (let i = 0z; i < len(tests32); i += 1) {
145 const parts = frexpf32(tests32[i]);
146 const res = ldexpf32(parts.0, parts.1);
147 assert(res == tests32[i]);
148 };
149 assert(ldexpf32(1.0f32, -1076i32) == 0.0f32);
150 assert(ldexpf32(-1.0f32, -1076i32) == -0.0f32);
151 assert(signf64(ldexpf32(-1.0f32, -1076i32)) < 0);
152 assert(ldexpf32(2.0f32, 1024i32) == INF);
153 assert(ldexpf32(-2.0f32, 1024i32) == -INF);
154 };
155
156 @test fn modfrac() void = {
157 // 64
158 for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) {
159 let res = modfracf64(TEST_INPUTS[idx]);
160 assert(res.0 == TEST_MODFRAC[idx].0);
161 assert(isclosef64(res.1, TEST_MODFRAC[idx].1));
162 };
163 let res = modfracf64(1.75f64);
164 assert(res.0 == 1f64);
165 assert(res.1 == 0.75f64);
166 res = modfracf64(0.75f64);
167 assert(res.0 == 0f64);
168 assert(res.1 == 0.75f64);
169 res = modfracf64(-0.75f64);
170 assert(res.0 == -0f64);
171 assert(res.1 == -0.75f64);
172 res = modfracf64(0f64);
173 assert(res.0 == 0f64);
174 assert(res.1 == 0f64);
175 assert(signf64(res.1) > 0);
176 res = modfracf64(-0f64);
177 assert(res.0 == -0f64);
178 assert(res.1 == -0f64);
179 assert(signf64(res.1) < 0);
180 res = modfracf64(23.50f64);
181 assert(res.0 == 23f64);
182 assert(res.1 == 0.50f64);
183 res = modfracf64(F64_MAX_NORMAL);
184 assert(res.0 == F64_MAX_NORMAL);
185 assert(res.1 == 0f64);
186
187 // 32
188 let res = modfracf32(1.75f32);
189 assert(res.0 == 1f32);
190 assert(res.1 == 0.75f32);
191 res = modfracf32(0.75f32);
192 assert(res.0 == 0f32);
193 assert(res.1 == 0.75f32);
194 res = modfracf32(-0.75f32);
195 assert(res.0 == -0f32);
196 assert(res.1 == -0.75f32);
197 res = modfracf32(0.0f32);
198 assert(res.0 == 0f32);
199 assert(res.1 == 0.0f32);
200 assert(signf64(res.1) > 0);
201 res = modfracf32(-0.0f32);
202 assert(res.0 == -0f32);
203 assert(res.1 == -0.0f32);
204 assert(signf64(res.1) < 0);
205 res = modfracf32(23.50f32);
206 assert(res.0 == 23f32);
207 assert(res.1 == 0.50f32);
208 res = modfracf32(F32_MAX_NORMAL);
209 assert(res.0 == F32_MAX_NORMAL);
210 assert(res.1 == 0f32);
211 };
212
213 @test fn nextafter() void = {
214 let f = &f64frombits;
215 // from musl's testsuite
216 assert(nextafterf64(f(0xc0202239f3c6a8f1), f(0x40122484b9ef31f0)) == f(0xc0202239f3c6a8f0));
217 assert(nextafterf64(f(0x401161868e18bc67), f(0xc021c6a6cdce75e8)) == f(0x401161868e18bc66));
218 assert(nextafterf64(f(0xc020c34b3e01e6e7), f(0xc0061bde29e83f6d)) == f(0xc020c34b3e01e6e6));
219 assert(nextafterf64(f(0xc01a206f0a19dcc4), f(0x40124527f7b576ac)) == f(0xc01a206f0a19dcc3));
220 assert(nextafterf64(f(0x402288bbb0d6a1e6), f(0x40133edd910a3c01)) == f(0x402288bbb0d6a1e5));
221 assert(nextafterf64(f(0xc019ccd8be03f495), f(0x3fe52fb12ef638a1)) == f(0xc019ccd8be03f494));
222 assert(nextafterf64(f(0x401f6f80ed2eab44), f(0x3faab3ff8575b21d)) == f(0x401f6f80ed2eab43));
223 assert(nextafterf64(f(0xbfe95882b433fad3), f(0x401eb4a2e7ce0693)) == f(0xbfe95882b433fad2));
224 assert(nextafterf64(f(0x3fe3b3d617ae3c4a), f(0x40001860611d75e1)) == f(0x3fe3b3d617ae3c4b));
225 assert(nextafterf64(f(0xbfe1e159e36313ee), f(0x3fa081bd34224213)) == f(0xbfe1e159e36313ed));
226
227 assert(nextafterf64(f(0xbfe1e159e36313ee), f(0xbfe1e159e36313ee)) == f(0xbfe1e159e36313ee));
228 assert(nextafterf64(0.0f64, 1.0f64) == f(0x1));
229 assert(nextafterf64(0.0f64, -1.0f64) == f(0x8000000000000001));
230 assert(nextafterf64(-0.0f64, 1.0f64) == f(0x1));
231 assert(nextafterf64(-0.0f64, -1.0f64) == f(0x8000000000000001));
232 assert(nextafterf64(0.0f64, 0.0f64) == 0.0f64);
233 assert(nextafterf64(-0.0f64, 0.0f64) == 0.0f64);
234 assert(nextafterf64(0.0f64, -0.0f64) == -0.0f64);
235 assert(isnan(nextafterf64(1.0f64, NAN)));
236 assert(isnan(nextafterf64(NAN, -2f64)));
237 assert(isnan(nextafterf64(NAN, NAN)));
238
239 let f = &f32frombits;
240 assert(nextafterf32(f(0xc10111d0), f(0x40912426)) == f(0xc10111cf));
241 assert(nextafterf32(f(0x408b0c34), f(0xc10e3536)) == f(0x408b0c33));
242 assert(nextafterf32(f(0xc1061a5a), f(0xc030def1)) == f(0xc1061a59));
243 assert(nextafterf32(f(0xc0d10378), f(0x40922940)) == f(0xc0d10377));
244 assert(nextafterf32(f(0x411445de), f(0x4099f6ed)) == f(0x411445dd));
245 assert(nextafterf32(f(0xc0ce66c6), f(0x3f297d89)) == f(0xc0ce66c5));
246 assert(nextafterf32(f(0x40fb7c07), f(0x3d559ffc)) == f(0x40fb7c06));
247 assert(nextafterf32(f(0xbf4ac416), f(0x40f5a517)) == f(0xbf4ac415));
248 assert(nextafterf32(f(0x3f1d9eb1), f(0x4000c303)) == f(0x3f1d9eb2));
249 assert(nextafterf32(f(0xbf0f0acf), f(0x3d040dea)) == f(0xbf0f0ace));
250
251 assert(nextafterf32(f(0xbf0f0acf), f(0xbf0f0acf)) == f(0xbf0f0acf));
252 assert(nextafterf32(0.0f32, 1.0f32) == f(0x1));
253 assert(nextafterf32(0.0f32, -1.0f32) == f(0x80000001));
254 assert(nextafterf32(-0.0f32, 1.0f32) == f(0x1));
255 assert(nextafterf32(-0.0f32, -1.0f32) == f(0x80000001));
256 assert(nextafterf32(0.0f32, 0.0f32) == 0.0f32);
257 assert(nextafterf32(-0.0f32, 0.0f32) == 0.0f32);
258 assert(nextafterf32(0.0f32, -0.0f32) == -0.0f32);
259 assert(isnan(nextafterf32(1.0f32, NAN)));
260 assert(isnan(nextafterf32(NAN, -2f32)));
261 assert(isnan(nextafterf32(NAN, NAN)));
262 };
263
264 @test fn nearbyint() void = {
265 // from musl's testsuite
266 let f = &f64frombits;
267 assert(nearbyintf64(f(0xc0202239f3c6a8f1)) == f(0xc020000000000000));
268 assert(nearbyintf64(f(0x401161868e18bc67)) == f(0x4010000000000000));
269 assert(nearbyintf64(f(0xc020c34b3e01e6e7)) == f(0xc020000000000000));
270 assert(nearbyintf64(f(0xc01a206f0a19dcc4)) == f(0xc01c000000000000));
271 assert(nearbyintf64(f(0x402288bbb0d6a1e6)) == f(0x4022000000000000));
272 assert(nearbyintf64(f(0x3fe52efd0cd80497)) == f(0x3ff0000000000000));
273 assert(nearbyintf64(f(0xbfda05cc754481d1)) == f(0x8000000000000000));
274 assert(nearbyintf64(f(0x3fe1f9ef934745cb)) == f(0x3ff0000000000000));
275 assert(nearbyintf64(f(0x3fe8c5db097f7442)) == f(0x3ff0000000000000));
276 assert(nearbyintf64(f(0xbfe5b86ea8118a0e)) == f(0xbff0000000000000));
277
278 let f = &f32frombits;
279 assert(nearbyintf32(f(0xc10111d0)) == f(0xc1000000));
280 assert(nearbyintf32(f(0x408b0c34)) == f(0x40800000));
281 assert(nearbyintf32(f(0xc1061a5a)) == f(0xc1000000));
282 assert(nearbyintf32(f(0xc0d10378)) == f(0xc0e00000));
283 assert(nearbyintf32(f(0x411445de)) == f(0x41100000));
284 assert(nearbyintf32(f(0x3f2977e8)) == f(0x3f800000));
285 assert(nearbyintf32(f(0xbed02e64)) == f(0x80000000));
286 assert(nearbyintf32(f(0x3f0fcf7d)) == f(0x3f800000));
287 assert(nearbyintf32(f(0x3f462ed8)) == f(0x3f800000));
288 assert(nearbyintf32(f(0xbf2dc375)) == f(0xbf800000));
289 };