| 1 |
// SPDX-License-Identifier: MPL-2.0 |
| 2 |
// (c) Hare authors <https://harelang.org> |
| 3 |
|
| 4 |
@test fn isclose() void = { |
| 5 |
assert(isclosef64(1f64, 2f64, 2f64)); |
| 6 |
assert(isclosef32(1.0f32, 2.0f32, 2.0f32)); |
| 7 |
assert(!isclosef32(1.0005f32, 1.0004f32, 0.00001f32)); |
| 8 |
assert(isclosef64(1f64, 1.0000000000000000000000000001f64)); |
| 9 |
assert(isclosef32(1.0f32, 1.0000000000000000000000000001f32)); |
| 10 |
assert(!isclosef32(1.0005f32, 1.0004f32)); |
| 11 |
}; |
| 12 |
|
| 13 |
@test fn logf64() void = { |
| 14 |
for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) { |
| 15 |
assert(isclosef64( |
| 16 |
logf64(absf64(TEST_INPUTS[idx])), |
| 17 |
TEST_LOG[idx])); |
| 18 |
}; |
| 19 |
assert(logf64(E) == 1f64); |
| 20 |
assert(logf64(54.598150033144239078110261202860878402790f64) == 4f64); |
| 21 |
assert(isnan(logf64(-1f64))); |
| 22 |
assert(logf64(INF) == INF); |
| 23 |
assert(logf64(0f64) == -INF); |
| 24 |
assert(isnan(logf64(NAN))); |
| 25 |
}; |
| 26 |
|
| 27 |
@test fn log10f64() void = { |
| 28 |
for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) { |
| 29 |
assert(isclosef64( |
| 30 |
log10f64(absf64(TEST_INPUTS[idx])), |
| 31 |
TEST_LOG10[idx])); |
| 32 |
}; |
| 33 |
}; |
| 34 |
|
| 35 |
@test fn log2f64() void = { |
| 36 |
for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) { |
| 37 |
assert(isclosef64( |
| 38 |
log2f64(absf64(TEST_INPUTS[idx])), |
| 39 |
TEST_LOG2[idx])); |
| 40 |
}; |
| 41 |
}; |
| 42 |
|
| 43 |
@test fn log1p() void = { |
| 44 |
for (let idx = 0z; idx < 10; idx += 1) { |
| 45 |
assert(isclosef64( |
| 46 |
log1pf64(TEST_INPUTS[idx] / 100f64), |
| 47 |
TEST_LOG1P[idx])); |
| 48 |
}; |
| 49 |
assert(isnan(log1pf64(-INF))); |
| 50 |
assert(isnan(log1pf64(-PI))); |
| 51 |
assert(log1pf64(-1f64) == -INF); |
| 52 |
assert(log1pf64(-0f64) == -0f64); |
| 53 |
assert(log1pf64(0f64) == 0f64); |
| 54 |
assert(log1pf64(INF) == INF); |
| 55 |
assert(isnan(log1pf64(NAN))); |
| 56 |
}; |
| 57 |
|
| 58 |
@test fn expf64() void = { |
| 59 |
for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) { |
| 60 |
assert(isclosef64(expf64(TEST_INPUTS[idx]), TEST_EXP[idx])); |
| 61 |
}; |
| 62 |
assert(expf64(1f64) == E); |
| 63 |
assert(isnan(expf64(NAN))); |
| 64 |
assert(isinf(expf64(INF))); |
| 65 |
assert(expf64(-INF) == 0f64); |
| 66 |
assert(isinf(expf64(99999f64))); |
| 67 |
assert(expf64(-99999f64) == 0f64); |
| 68 |
assert(expf64(0.5e-20) == 1f64); |
| 69 |
}; |
| 70 |
|
| 71 |
@test fn exp2f64() void = { |
| 72 |
for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) { |
| 73 |
assert(isclosef64(exp2f64(TEST_INPUTS[idx]), TEST_EXP2[idx])); |
| 74 |
}; |
| 75 |
assert(exp2f64(0f64) == 1f64); |
| 76 |
assert(exp2f64(3f64) == 8f64); |
| 77 |
assert(exp2f64(-2f64) == 0.25f64); |
| 78 |
assert(!isinf(exp2f64(256f64))); |
| 79 |
assert(isinf(exp2f64(99999f64))); |
| 80 |
assert(exp2f64(-99999f64) == 0f64); |
| 81 |
assert(isnan(exp2f64(NAN))); |
| 82 |
assert(isinf(exp2f64(INF))); |
| 83 |
assert(exp2f64(-INF) == 0f64); |
| 84 |
}; |
| 85 |
|
| 86 |
@test fn sqrt() void = { |
| 87 |
for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) { |
| 88 |
assert(isclosef64( |
| 89 |
sqrtf64(absf64(TEST_INPUTS[idx])), |
| 90 |
TEST_SQRT[idx])); |
| 91 |
}; |
| 92 |
assert(sqrtf64(2f64) == SQRT_2); |
| 93 |
assert(sqrtf64(4f64) == 2f64); |
| 94 |
assert(sqrtf64(16f64) == 4f64); |
| 95 |
assert(sqrtf64(65536f64) == 256f64); |
| 96 |
assert(sqrtf64(powf64(123f64, 2f64)) == 123f64); |
| 97 |
assert(sqrtf64(0f64) == 0f64); |
| 98 |
assert(isnan(sqrtf64(NAN))); |
| 99 |
assert(sqrtf64(INF) == INF); |
| 100 |
assert(isnan(sqrtf64(-2f64))); |
| 101 |
}; |
| 102 |
|
| 103 |
@test fn powf64() void = { |
| 104 |
for (let idx = 0z; idx < len(TEST_INPUTS); idx += 1) { |
| 105 |
assert(isclosef64( |
| 106 |
powf64(10f64, TEST_INPUTS[idx]), |
| 107 |
TEST_POW[idx], |
| 108 |
1e-8f64)); |
| 109 |
}; |
| 110 |
// Positive integer |
| 111 |
assert(powf64(2f64, 2f64) == 4f64); |
| 112 |
assert(powf64(3f64, 3f64) == 27f64); |
| 113 |
// Very large positive integer |
| 114 |
assert(!isinf(powf64(2f64, 1020f64))); |
| 115 |
assert(isinf(powf64(2f64, 1050f64))); |
| 116 |
// Very very large positive integer |
| 117 |
assert(isinf(powf64(2f64, F64_MAX_NORMAL))); |
| 118 |
assert(powf64(0.5f64, F64_MAX_NORMAL) == 0f64); |
| 119 |
// Negative integer |
| 120 |
assert(powf64(2f64, -1f64) == 0.5f64); |
| 121 |
assert(powf64(2f64, -2f64) == 0.25f64); |
| 122 |
// Very small negative integer |
| 123 |
assert(powf64(2f64, -1020f64) > 0f64); |
| 124 |
assert(powf64(2f64, -1080f64) == 0f64); |
| 125 |
// Very very small negative integer |
| 126 |
assert(powf64(2f64, -F64_MAX_NORMAL) == 0f64); |
| 127 |
assert(isinf(powf64(0.5f64, -F64_MAX_NORMAL))); |
| 128 |
// Positive fractional powers |
| 129 |
assert(isclosef64(powf64(2f64, 1.5f64), 2.8284271247461900976033774f64)); |
| 130 |
assert(isclosef64(powf64(2f64, 5.5f64), 45.254833995939041561654039f64)); |
| 131 |
// Negative fractional powers |
| 132 |
assert(isclosef64(powf64(2f64, -1.5f64), 0.3535533905932737622004221f64)); |
| 133 |
assert(isclosef64(powf64(2f64, -5.5f64), 0.0220970869120796101375263f64)); |
| 134 |
|
| 135 |
// Special cases |
| 136 |
// pow(x, ±0) = 1 for any x |
| 137 |
assert(powf64(123f64, 0f64) == 1f64); |
| 138 |
// pow(1, y) = 1 for any y |
| 139 |
assert(powf64(1f64, 123f64) == 1f64); |
| 140 |
// pow(x, 1) = x for any x |
| 141 |
assert(powf64(123f64, 1f64) == 123f64); |
| 142 |
// pow(NaN, y) = NaN |
| 143 |
assert(isnan(powf64(NAN, 123f64))); |
| 144 |
// pow(x, NaN) = NaN |
| 145 |
assert(isnan(powf64(123f64, NAN))); |
| 146 |
// pow(±0, y) = ±Inf for y an odd integer < 0 |
| 147 |
assert(powf64(0f64, -3f64) == INF); |
| 148 |
assert(powf64(-0f64, -3f64) == -INF); |
| 149 |
// pow(±0, -Inf) = +Inf |
| 150 |
assert(powf64(0f64, -INF) == INF); |
| 151 |
assert(powf64(-0f64, -INF) == INF); |
| 152 |
// pow(±0, +Inf) = +0 |
| 153 |
assert(powf64(0f64, INF) == 0f64); |
| 154 |
assert(powf64(-0f64, INF) == 0f64); |
| 155 |
// pow(±0, y) = +Inf for finite y < 0 and not an odd integer |
| 156 |
assert(powf64(0f64, -2f64) == INF); |
| 157 |
assert(powf64(0f64, -2f64) == INF); |
| 158 |
//pow(±0, y) = ±0 for y an odd integer > 0 |
| 159 |
assert(powf64(0f64, 123f64) == 0f64); |
| 160 |
const neg_zero = powf64(-0f64, 123f64); |
| 161 |
assert(neg_zero == 0f64); |
| 162 |
assert(isnegativef64(neg_zero)); |
| 163 |
// pow(±0, y) = +0 for finite y > 0 and not an odd integer |
| 164 |
assert(powf64(0f64, 8f64) == 0f64); |
| 165 |
// pow(-1, ±Inf) = 1 |
| 166 |
assert(powf64(-1f64, INF) == 1f64); |
| 167 |
assert(powf64(-1f64, -INF) == 1f64); |
| 168 |
// pow(x, +Inf) = +Inf for |x| > 1 |
| 169 |
assert(powf64(123f64, INF) == INF); |
| 170 |
// pow(x, -Inf) = +0 for |x| > 1 |
| 171 |
assert(powf64(123f64, -INF) == 0f64); |
| 172 |
// pow(x, +Inf) = +0 for |x| < 1 |
| 173 |
assert(powf64(0.5f64, INF) == 0f64); |
| 174 |
assert(powf64(-0.5f64, INF) == 0f64); |
| 175 |
// pow(x, -Inf) = +Inf for |x| < 1 |
| 176 |
assert(powf64(0.5f64, -INF) == INF); |
| 177 |
assert(powf64(-0.5f64, -INF) == INF); |
| 178 |
// pow(+Inf, y) = +Inf for y > 0 |
| 179 |
assert(powf64(INF, 123f64) == INF); |
| 180 |
// pow(+Inf, y) = +0 for y < 0 |
| 181 |
assert(powf64(INF, -1f64) == 0f64); |
| 182 |
// pow(-Inf, y) = pow(-0, -y) |
| 183 |
assert(powf64(-INF, 123f64) == powf64(-0f64, -123f64)); |
| 184 |
// pow(x, y) = NaN for finite x < 0 and finite non-integer y |
| 185 |
assert(isnan(powf64(-2f64, 1.23f64))); |
| 186 |
// sqrt |
| 187 |
assert(powf64(4f64, 0.5f64) == sqrtf64(4f64)); |
| 188 |
assert(powf64(4f64, 0.5f64) == 2f64); |
| 189 |
assert(powf64(4f64, -0.5f64) == (1f64 / sqrtf64(4f64))); |
| 190 |
assert(powf64(4f64, -0.5f64) == (1f64 / 2f64)); |
| 191 |
}; |
| 192 |
|
| 193 |
@test fn floor() void = { |
| 194 |
for (let idx = 0z; idx < 10; idx += 1) { |
| 195 |
assert(isclosef64( |
| 196 |
floorf64(TEST_INPUTS[idx]), |
| 197 |
TEST_FLOOR[idx])); |
| 198 |
}; |
| 199 |
assert(floorf64(-INF) == -INF); |
| 200 |
assert(floorf64(-0f64) == -0f64); |
| 201 |
assert(floorf64(0f64) == 0f64); |
| 202 |
assert(floorf64(INF) == INF); |
| 203 |
assert(isnan(floorf64(NAN))); |
| 204 |
}; |
| 205 |
|
| 206 |
@test fn ceil() void = { |
| 207 |
for (let idx = 0z; idx < 10; idx += 1) { |
| 208 |
assert(isclosef64( |
| 209 |
ceilf64(TEST_INPUTS[idx]), |
| 210 |
TEST_CEIL[idx])); |
| 211 |
}; |
| 212 |
assert(ceilf64(-INF) == -INF); |
| 213 |
assert(ceilf64(-F64_MAX_NORMAL) == -F64_MAX_NORMAL); |
| 214 |
assert(ceilf64(-0f64) == -0f64); |
| 215 |
assert(ceilf64(0f64) == 0f64); |
| 216 |
assert(ceilf64(F64_MAX_NORMAL) == F64_MAX_NORMAL); |
| 217 |
assert(ceilf64(INF) == INF); |
| 218 |
assert(isnan(ceilf64(NAN))); |
| 219 |
}; |
| 220 |
|
| 221 |
@test fn trunc() void = { |
| 222 |
for (let idx = 0z; idx < 10; idx += 1) { |
| 223 |
assert(isclosef64( |
| 224 |
truncf64(TEST_INPUTS[idx]), |
| 225 |
TEST_TRUNC[idx])); |
| 226 |
}; |
| 227 |
assert(truncf64(-INF) == -INF); |
| 228 |
assert(truncf64(-F64_MAX_NORMAL) == -F64_MAX_NORMAL); |
| 229 |
assert(truncf64(-0f64) == -0f64); |
| 230 |
assert(truncf64(0f64) == 0f64); |
| 231 |
assert(truncf64(F64_MAX_NORMAL) == F64_MAX_NORMAL); |
| 232 |
assert(truncf64(INF) == INF); |
| 233 |
assert(isnan(truncf64(NAN))); |
| 234 |
}; |
| 235 |
|
| 236 |
@test fn round() void = { |
| 237 |
for (let idx = 0z; idx < 10; idx += 1) { |
| 238 |
assert(isclosef64( |
| 239 |
roundf64(TEST_INPUTS[idx]), |
| 240 |
TEST_ROUND[idx])); |
| 241 |
}; |
| 242 |
assert(roundf64(-INF) == -INF); |
| 243 |
assert(roundf64(-F64_MAX_NORMAL) == -F64_MAX_NORMAL); |
| 244 |
assert(roundf64(-0f64) == -0f64); |
| 245 |
assert(roundf64(0f64) == 0f64); |
| 246 |
assert(roundf64(F64_MAX_NORMAL) == F64_MAX_NORMAL); |
| 247 |
assert(roundf64(INF) == INF); |
| 248 |
assert(isnan(roundf64(NAN))); |
| 249 |
}; |
| 250 |
|
| 251 |
@test fn modf64() void = { |
| 252 |
for (let idx = 0z; idx < 10; idx += 1) { |
| 253 |
assert(isclosef64( |
| 254 |
modf64(10f64, TEST_INPUTS[idx]), |
| 255 |
TEST_MODF[idx])); |
| 256 |
}; |
| 257 |
|
| 258 |
assert(isnan(modf64(-INF, -INF))); |
| 259 |
assert(isnan(modf64(-INF, -PI))); |
| 260 |
assert(isnan(modf64(-INF, 0f64))); |
| 261 |
assert(isnan(modf64(-INF, PI))); |
| 262 |
assert(isnan(modf64(-INF, INF))); |
| 263 |
assert(isnan(modf64(-INF, NAN))); |
| 264 |
assert(modf64(-PI, -INF) == -PI); |
| 265 |
assert(isnan(modf64(-PI, 0f64))); |
| 266 |
assert(modf64(-PI, INF) == -PI); |
| 267 |
assert(isnan(modf64(-PI, NAN))); |
| 268 |
assert(modf64(-0f64, -INF) == -0f64); |
| 269 |
assert(isnan(modf64(-0f64, 0f64))); |
| 270 |
assert(modf64(-0f64, INF) == -0f64); |
| 271 |
assert(isnan(modf64(-0f64, NAN))); |
| 272 |
assert(modf64(0f64, -INF) == 0f64); |
| 273 |
assert(isnan(modf64(0f64, 0f64))); |
| 274 |
assert(modf64(0f64, INF) == 0f64); |
| 275 |
assert(isnan(modf64(0f64, NAN))); |
| 276 |
assert(modf64(PI, -INF) == PI); |
| 277 |
assert(isnan(modf64(PI, 0f64))); |
| 278 |
assert(modf64(PI, INF) == PI); |
| 279 |
assert(isnan(modf64(PI, NAN))); |
| 280 |
assert(isnan(modf64(INF, -INF))); |
| 281 |
assert(isnan(modf64(INF, -PI))); |
| 282 |
assert(isnan(modf64(INF, 0f64))); |
| 283 |
assert(isnan(modf64(INF, PI))); |
| 284 |
assert(isnan(modf64(INF, INF))); |
| 285 |
assert(isnan(modf64(INF, NAN))); |
| 286 |
assert(isnan(modf64(NAN, -INF))); |
| 287 |
assert(isnan(modf64(NAN, -PI))); |
| 288 |
assert(isnan(modf64(NAN, 0f64))); |
| 289 |
assert(isnan(modf64(NAN, PI))); |
| 290 |
assert(isnan(modf64(NAN, INF))); |
| 291 |
assert(isnan(modf64(NAN, NAN))); |
| 292 |
assert(modf64(5.9790119248836734e+200, 1.1258465975523544) == |
| 293 |
0.6447968302508578); |
| 294 |
}; |