| 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 |
}; |