math_test.ha (9167B)
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 };