Debian Codegraph @

math/+test/math_test.ha

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