master
1const builtin = @import("builtin");
2const std = @import("std");
3const assert = std.debug.assert;
4const expect = std.testing.expect;
5
6test "@abs integers" {
7 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11
12 try comptime testAbsIntegers();
13 try testAbsIntegers();
14}
15
16fn testAbsIntegers() !void {
17 {
18 var x: i32 = -1000;
19 _ = &x;
20 try expect(@abs(x) == 1000);
21 }
22 {
23 var x: i32 = 0;
24 _ = &x;
25 try expect(@abs(x) == 0);
26 }
27 {
28 var x: i32 = 1000;
29 _ = &x;
30 try expect(@abs(x) == 1000);
31 }
32 {
33 var x: i64 = std.math.minInt(i64);
34 _ = &x;
35 try expect(@abs(x) == @as(u64, -std.math.minInt(i64)));
36 }
37 {
38 var x: i5 = -1;
39 _ = &x;
40 try expect(@abs(x) == 1);
41 }
42 {
43 var x: i5 = -5;
44 _ = &x;
45 try expect(@abs(x) == 5);
46 }
47 comptime {
48 try expect(@abs(@as(i2, -2)) == 2);
49 }
50}
51
52test "@abs signed C ABI integers" {
53 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
54 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
55 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
57
58 const S = struct {
59 fn doTheTest() !void {
60 try testOne(isize, usize);
61 try testOne(c_short, c_ushort);
62 try testOne(c_int, c_uint);
63 try testOne(c_long, c_ulong);
64 if (!builtin.cpu.arch.isSpirV()) try testOne(c_longlong, c_ulonglong);
65 }
66 fn testOne(comptime Signed: type, comptime Unsigned: type) !void {
67 var negative_one: Signed = undefined;
68 negative_one = -1;
69 const one = @abs(negative_one);
70 comptime assert(@TypeOf(one) == Unsigned);
71 try expect(one == 1);
72 }
73 };
74
75 try S.doTheTest();
76 try comptime S.doTheTest();
77}
78
79test "@abs unsigned integers" {
80 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
81 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
82
83 try comptime testAbsUnsignedIntegers();
84 try testAbsUnsignedIntegers();
85}
86
87fn testAbsUnsignedIntegers() !void {
88 {
89 var x: u32 = 1000;
90 _ = &x;
91 try expect(@abs(x) == 1000);
92 }
93 {
94 var x: u32 = 0;
95 _ = &x;
96 try expect(@abs(x) == 0);
97 }
98 {
99 var x: u32 = 1000;
100 _ = &x;
101 try expect(@abs(x) == 1000);
102 }
103 {
104 var x: u5 = 1;
105 _ = &x;
106 try expect(@abs(x) == 1);
107 }
108 {
109 var x: u5 = 5;
110 _ = &x;
111 try expect(@abs(x) == 5);
112 }
113 comptime {
114 try expect(@abs(@as(u2, 2)) == 2);
115 }
116}
117
118test "@abs unsigned C ABI integers" {
119 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
120 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
121 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
122
123 const S = struct {
124 fn doTheTest() !void {
125 try testOne(usize);
126 try testOne(c_ushort);
127 try testOne(c_uint);
128 try testOne(c_ulong);
129 if (!builtin.cpu.arch.isSpirV()) try testOne(c_ulonglong);
130 }
131 fn testOne(comptime Unsigned: type) !void {
132 var one: Unsigned = undefined;
133 one = 1;
134 const still_one = @abs(one);
135 comptime assert(@TypeOf(still_one) == Unsigned);
136 try expect(still_one == 1);
137 }
138 };
139
140 try S.doTheTest();
141 try comptime S.doTheTest();
142}
143
144test "@abs big int <= 128 bits" {
145 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
146 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
147 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
148 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
149 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
150
151 try comptime testAbsSignedBigInt();
152 try testAbsSignedBigInt();
153
154 try comptime testAbsUnsignedBigInt();
155 try testAbsUnsignedBigInt();
156}
157
158fn abs(comptime T: type, a: T) std.meta.Int(.unsigned, @typeInfo(T).int.bits) {
159 return @abs(a);
160}
161
162fn testAbsSignedBigInt() !void {
163 try expect(abs(i65, -18446744073709551616) == 18446744073709551616);
164 try expect(abs(i65, 18446744073709551615) == 18446744073709551615);
165 try expect(abs(i65, 1234) == 1234);
166 try expect(abs(i65, -1234) == 1234);
167
168 try expect(abs(i84, -9671406556917033397649408) == 9671406556917033397649408);
169 try expect(abs(i84, 9671406556917033397649407) == 9671406556917033397649407);
170 try expect(abs(i84, 1234) == 1234);
171 try expect(abs(i84, -1234) == 1234);
172
173 try expect(abs(i96, -39614081257132168796771975168) == 39614081257132168796771975168);
174 try expect(abs(i96, 39614081257132168796771975167) == 39614081257132168796771975167);
175 try expect(abs(i96, 1234) == 1234);
176 try expect(abs(i96, -1234) == 1234);
177
178 try expect(abs(i105, -20282409603651670423947251286016) == 20282409603651670423947251286016);
179 try expect(abs(i105, 20282409603651670423947251286015) == 20282409603651670423947251286015);
180 try expect(abs(i105, 1234) == 1234);
181 try expect(abs(i105, -1234) == 1234);
182
183 try expect(abs(i128, -170141183460469231731687303715884105728) == 170141183460469231731687303715884105728);
184 try expect(abs(i128, 170141183460469231731687303715884105727) == 170141183460469231731687303715884105727);
185 try expect(abs(i128, 1234) == 1234);
186 try expect(abs(i128, -1234) == 1234);
187}
188
189fn testAbsUnsignedBigInt() !void {
190 try expect(abs(u65, 36893488147419103231) == 36893488147419103231);
191 try expect(abs(u65, 1234) == 1234);
192
193 try expect(abs(u84, 19342813113834066795298815) == 19342813113834066795298815);
194 try expect(abs(u84, 1234) == 1234);
195
196 try expect(abs(u96, 79228162514264337593543950335) == 79228162514264337593543950335);
197 try expect(abs(u96, 1234) == 1234);
198
199 try expect(abs(u105, 40564819207303340847894502572031) == 40564819207303340847894502572031);
200 try expect(abs(u105, 1234) == 1234);
201
202 try expect(abs(u128, 340282366920938463463374607431768211455) == 340282366920938463463374607431768211455);
203 try expect(abs(u128, 1234) == 1234);
204}
205
206test "@abs floats" {
207 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
208 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
209
210 try comptime testAbsFloats(f16);
211 if (builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f16);
212 try comptime testAbsFloats(f32);
213 try testAbsFloats(f32);
214 try comptime testAbsFloats(f64);
215 try testAbsFloats(f64);
216 try comptime testAbsFloats(f80);
217 if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
218 try comptime testAbsFloats(f128);
219 if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
220}
221
222fn testAbsFloats(comptime T: type) !void {
223 {
224 var x: T = -2.62;
225 _ = &x;
226 try expect(@abs(x) == 2.62);
227 }
228 {
229 var x: T = 2.62;
230 _ = &x;
231 try expect(@abs(x) == 2.62);
232 }
233 {
234 var x: T = 0.0;
235 _ = &x;
236 try expect(@abs(x) == 0.0);
237 }
238 {
239 var x: T = -std.math.pi;
240 _ = &x;
241 try expect(@abs(x) == std.math.pi);
242 }
243
244 {
245 var x: T = -std.math.inf(T);
246 _ = &x;
247 try expect(@abs(x) == std.math.inf(T));
248 }
249 {
250 var x: T = std.math.inf(T);
251 _ = &x;
252 try expect(@abs(x) == std.math.inf(T));
253 }
254 comptime {
255 try expect(@abs(@as(T, -std.math.e)) == std.math.e);
256 }
257}
258
259test "@abs int vectors" {
260 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
261 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
262 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
263 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
264 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
265 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
266 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
267
268 try comptime testAbsIntVectors(1);
269 try testAbsIntVectors(1);
270 try comptime testAbsIntVectors(2);
271 try testAbsIntVectors(2);
272 try comptime testAbsIntVectors(3);
273 try testAbsIntVectors(3);
274 try comptime testAbsIntVectors(4);
275 try testAbsIntVectors(4);
276 try comptime testAbsIntVectors(8);
277 try testAbsIntVectors(8);
278 try comptime testAbsIntVectors(16);
279 try testAbsIntVectors(16);
280 try comptime testAbsIntVectors(17);
281 try testAbsIntVectors(17);
282}
283
284fn testAbsIntVectors(comptime len: comptime_int) !void {
285 const I32 = @Vector(len, i32);
286 const U32 = @Vector(len, u32);
287 const I64 = @Vector(len, i64);
288 const U64 = @Vector(len, u64);
289 {
290 var x: I32 = @splat(-10);
291 var y: U32 = @splat(10);
292 _ = .{ &x, &y };
293 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
294 }
295 {
296 var x: I32 = @splat(10);
297 var y: U32 = @splat(10);
298 _ = .{ &x, &y };
299 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
300 }
301 {
302 var x: I32 = @splat(0);
303 var y: U32 = @splat(0);
304 _ = .{ &x, &y };
305 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
306 }
307 {
308 var x: I64 = @splat(-10);
309 var y: U64 = @splat(10);
310 _ = .{ &x, &y };
311 try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
312 }
313 {
314 var x: I64 = @splat(std.math.minInt(i64));
315 var y: U64 = @splat(-std.math.minInt(i64));
316 _ = .{ &x, &y };
317 try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
318 }
319 {
320 var x = comptime std.simd.repeat(len, @Vector(4, i32){ -2, 5, std.math.minInt(i32), -7 });
321 var y = comptime std.simd.repeat(len, @Vector(4, u32){ 2, 5, -std.math.minInt(i32), 7 });
322 _ = .{ &x, &y };
323 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
324 }
325}
326
327test "@abs unsigned int vectors" {
328 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
329 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
330 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
331 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
332 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
333 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
334
335 try comptime testAbsUnsignedIntVectors(1);
336 try testAbsUnsignedIntVectors(1);
337 try comptime testAbsUnsignedIntVectors(2);
338 try testAbsUnsignedIntVectors(2);
339 try comptime testAbsUnsignedIntVectors(3);
340 try testAbsUnsignedIntVectors(3);
341 try comptime testAbsUnsignedIntVectors(4);
342 try testAbsUnsignedIntVectors(4);
343 try comptime testAbsUnsignedIntVectors(8);
344 try testAbsUnsignedIntVectors(8);
345 try comptime testAbsUnsignedIntVectors(16);
346 try testAbsUnsignedIntVectors(16);
347 try comptime testAbsUnsignedIntVectors(17);
348 try testAbsUnsignedIntVectors(17);
349}
350
351fn testAbsUnsignedIntVectors(comptime len: comptime_int) !void {
352 const U32 = @Vector(len, u32);
353 const U64 = @Vector(len, u64);
354 {
355 var x: U32 = @splat(10);
356 var y: U32 = @splat(10);
357 _ = .{ &x, &y };
358 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
359 }
360 {
361 var x: U32 = @splat(10);
362 var y: U32 = @splat(10);
363 _ = .{ &x, &y };
364 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
365 }
366 {
367 var x: U32 = @splat(0);
368 var y: U32 = @splat(0);
369 _ = .{ &x, &y };
370 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
371 }
372 {
373 var x: U64 = @splat(10);
374 var y: U64 = @splat(10);
375 _ = .{ &x, &y };
376 try expect(std.mem.eql(u64, &@as([len]u64, y), &@as([len]u64, @abs(x))));
377 }
378 {
379 var x = comptime std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
380 var y = comptime std.simd.repeat(len, @Vector(3, u32){ 2, 5, 7 });
381 _ = .{ &x, &y };
382 try expect(std.mem.eql(u32, &@as([len]u32, y), &@as([len]u32, @abs(x))));
383 }
384}
385
386test "@abs float vectors" {
387 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
388 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
389 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
390 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
391 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
392 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
393
394 @setEvalBranchQuota(2000);
395 try comptime testAbsFloatVectors(f16, 1);
396 try testAbsFloatVectors(f16, 1);
397 try comptime testAbsFloatVectors(f16, 2);
398 try testAbsFloatVectors(f16, 2);
399 try comptime testAbsFloatVectors(f16, 3);
400 try testAbsFloatVectors(f16, 3);
401 try comptime testAbsFloatVectors(f16, 4);
402 try testAbsFloatVectors(f16, 4);
403 try comptime testAbsFloatVectors(f16, 8);
404 try testAbsFloatVectors(f16, 8);
405 try comptime testAbsFloatVectors(f16, 16);
406 try testAbsFloatVectors(f16, 16);
407 try comptime testAbsFloatVectors(f16, 17);
408
409 try testAbsFloatVectors(f32, 1);
410 try comptime testAbsFloatVectors(f32, 1);
411 try testAbsFloatVectors(f32, 1);
412 try comptime testAbsFloatVectors(f32, 2);
413 try testAbsFloatVectors(f32, 2);
414 try comptime testAbsFloatVectors(f32, 3);
415 try testAbsFloatVectors(f32, 3);
416 try comptime testAbsFloatVectors(f32, 4);
417 try testAbsFloatVectors(f32, 4);
418 try comptime testAbsFloatVectors(f32, 8);
419 try testAbsFloatVectors(f32, 8);
420 try comptime testAbsFloatVectors(f32, 16);
421 try testAbsFloatVectors(f32, 16);
422 try comptime testAbsFloatVectors(f32, 17);
423 try testAbsFloatVectors(f32, 17);
424
425 try comptime testAbsFloatVectors(f64, 1);
426 try testAbsFloatVectors(f64, 1);
427 try comptime testAbsFloatVectors(f64, 2);
428 try testAbsFloatVectors(f64, 2);
429 try comptime testAbsFloatVectors(f64, 3);
430 try testAbsFloatVectors(f64, 3);
431 try comptime testAbsFloatVectors(f64, 4);
432 try testAbsFloatVectors(f64, 4);
433 try comptime testAbsFloatVectors(f64, 8);
434 try testAbsFloatVectors(f64, 8);
435 try comptime testAbsFloatVectors(f64, 16);
436 try testAbsFloatVectors(f64, 16);
437 try comptime testAbsFloatVectors(f64, 17);
438 try testAbsFloatVectors(f64, 17);
439
440 try comptime testAbsFloatVectors(f80, 1);
441 try testAbsFloatVectors(f80, 1);
442 try comptime testAbsFloatVectors(f80, 2);
443 try testAbsFloatVectors(f80, 2);
444 try comptime testAbsFloatVectors(f80, 3);
445 try testAbsFloatVectors(f80, 3);
446 try comptime testAbsFloatVectors(f80, 4);
447 try testAbsFloatVectors(f80, 4);
448 try comptime testAbsFloatVectors(f80, 8);
449 try testAbsFloatVectors(f80, 8);
450 try comptime testAbsFloatVectors(f80, 16);
451 try testAbsFloatVectors(f80, 16);
452 try comptime testAbsFloatVectors(f80, 17);
453 try testAbsFloatVectors(f80, 17);
454
455 try comptime testAbsFloatVectors(f128, 1);
456 try testAbsFloatVectors(f128, 1);
457 try comptime testAbsFloatVectors(f128, 2);
458 try testAbsFloatVectors(f128, 2);
459 try comptime testAbsFloatVectors(f128, 3);
460 try testAbsFloatVectors(f128, 3);
461 try comptime testAbsFloatVectors(f128, 4);
462 try testAbsFloatVectors(f128, 4);
463 try comptime testAbsFloatVectors(f128, 8);
464 try testAbsFloatVectors(f128, 8);
465 try comptime testAbsFloatVectors(f128, 16);
466 try testAbsFloatVectors(f128, 16);
467 try comptime testAbsFloatVectors(f128, 17);
468 try testAbsFloatVectors(f128, 17);
469}
470
471fn testAbsFloatVectors(comptime T: type, comptime len: comptime_int) !void {
472 const V = @Vector(len, T);
473 {
474 var x: V = @splat(-7.5);
475 var y: V = @splat(7.5);
476 _ = .{ &x, &y };
477 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
478 }
479 {
480 var x: V = @splat(7.5);
481 var y: V = @splat(7.5);
482 _ = .{ &x, &y };
483 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
484 }
485 {
486 var x: V = @splat(0.0);
487 var y: V = @splat(0.0);
488 _ = .{ &x, &y };
489 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
490 }
491 {
492 var x: V = @splat(-std.math.pi);
493 var y: V = @splat(std.math.pi);
494 _ = .{ &x, &y };
495 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
496 }
497 {
498 var x: V = @splat(std.math.pi);
499 var y: V = @splat(std.math.pi);
500 _ = .{ &x, &y };
501 try expect(std.mem.eql(T, &@as([len]T, y), &@as([len]T, @abs(x))));
502 }
503}