master
1const std = @import("std");
2const testing = std.testing;
3
4const __truncsfhf2 = @import("truncsfhf2.zig").__truncsfhf2;
5const __truncdfhf2 = @import("truncdfhf2.zig").__truncdfhf2;
6const __truncdfsf2 = @import("truncdfsf2.zig").__truncdfsf2;
7const __trunctfhf2 = @import("trunctfhf2.zig").__trunctfhf2;
8const __trunctfsf2 = @import("trunctfsf2.zig").__trunctfsf2;
9const __trunctfdf2 = @import("trunctfdf2.zig").__trunctfdf2;
10const __trunctfxf2 = @import("trunctfxf2.zig").__trunctfxf2;
11
12fn test__truncsfhf2(a: u32, expected: u16) !void {
13 const actual: u16 = @bitCast(__truncsfhf2(@bitCast(a)));
14
15 if (actual == expected) {
16 return;
17 }
18
19 return error.TestFailure;
20}
21
22test "truncsfhf2" {
23 try test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN
24 try test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN
25
26 try test__truncsfhf2(0, 0); // 0
27 try test__truncsfhf2(0x80000000, 0x8000); // -0
28
29 try test__truncsfhf2(0x7f800000, 0x7c00); // inf
30 try test__truncsfhf2(0xff800000, 0xfc00); // -inf
31
32 try test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf
33 try test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf
34
35 try test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf
36 try test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf
37
38 try test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14
39 try test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14
40
41 try test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504
42 try test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504
43
44 try test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504
45 try test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504
46
47 try test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504
48 try test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504
49
50 try test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10
51 try test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10
52
53 try test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3
54 try test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3
55
56 try test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535
57 try test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535
58
59 try test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12
60
61 try test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1
62 try test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14
63
64 try test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24
65 try test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24
66
67 try test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-24
68 try test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-24
69
70 try test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20
71 try test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24
72 try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
73}
74
75fn test__truncdfhf2(a: f64, expected: u16) void {
76 const rep: u16 = @bitCast(__truncdfhf2(a));
77
78 if (rep == expected) {
79 return;
80 }
81 // test other possible NaN representation(signal NaN)
82 else if (expected == 0x7e00) {
83 if ((rep & 0x7c00) == 0x7c00 and (rep & 0x3ff) > 0) {
84 return;
85 }
86 }
87
88 @panic("__truncdfhf2 test failure");
89}
90
91fn test__truncdfhf2_raw(a: u64, expected: u16) void {
92 const actual: u16 = @bitCast(__truncdfhf2(@bitCast(a)));
93
94 if (actual == expected) {
95 return;
96 }
97
98 @panic("__truncdfhf2 test failure");
99}
100
101test "truncdfhf2" {
102 test__truncdfhf2_raw(0x7ff8000000000000, 0x7e00); // qNaN
103 test__truncdfhf2_raw(0x7ff0000000008000, 0x7e00); // NaN
104
105 test__truncdfhf2_raw(0x7ff0000000000000, 0x7c00); //inf
106 test__truncdfhf2_raw(0xfff0000000000000, 0xfc00); // -inf
107
108 test__truncdfhf2(0.0, 0x0); // zero
109 test__truncdfhf2_raw(0x80000000 << 32, 0x8000); // -zero
110
111 test__truncdfhf2(3.1415926535, 0x4248);
112 test__truncdfhf2(-3.1415926535, 0xc248);
113
114 test__truncdfhf2(0x1.987124876876324p+1000, 0x7c00);
115 test__truncdfhf2(0x1.987124876876324p+12, 0x6e62);
116 test__truncdfhf2(0x1.0p+0, 0x3c00);
117 test__truncdfhf2(0x1.0p-14, 0x0400);
118
119 // denormal
120 test__truncdfhf2(0x1.0p-20, 0x0010);
121 test__truncdfhf2(0x1.0p-24, 0x0001);
122 test__truncdfhf2(-0x1.0p-24, 0x8001);
123 test__truncdfhf2(0x1.5p-25, 0x0001);
124
125 // and back to zero
126 test__truncdfhf2(0x1.0p-25, 0x0000);
127 test__truncdfhf2(-0x1.0p-25, 0x8000);
128
129 // max (precise)
130 test__truncdfhf2(65504.0, 0x7bff);
131
132 // max (rounded)
133 test__truncdfhf2(65519.0, 0x7bff);
134
135 // max (to +inf)
136 test__truncdfhf2(65520.0, 0x7c00);
137 test__truncdfhf2(-65520.0, 0xfc00);
138 test__truncdfhf2(65536.0, 0x7c00);
139}
140
141fn test__trunctfsf2(a: f128, expected: u32) void {
142 const x = __trunctfsf2(a);
143
144 const rep: u32 = @bitCast(x);
145 if (rep == expected) {
146 return;
147 }
148 // test other possible NaN representation(signal NaN)
149 else if (expected == 0x7fc00000) {
150 if ((rep & 0x7f800000) == 0x7f800000 and (rep & 0x7fffff) > 0) {
151 return;
152 }
153 }
154
155 @panic("__trunctfsf2 test failure");
156}
157
158test "trunctfsf2" {
159 // qnan
160 test__trunctfsf2(@bitCast(@as(u128, 0x7fff800000000000 << 64)), 0x7fc00000);
161 // nan
162 test__trunctfsf2(@bitCast(@as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7fc08000);
163 // inf
164 test__trunctfsf2(@bitCast(@as(u128, 0x7fff000000000000 << 64)), 0x7f800000);
165 // zero
166 test__trunctfsf2(0.0, 0x0);
167
168 test__trunctfsf2(0x1.23a2abb4a2ddee355f36789abcdep+5, 0x4211d156);
169 test__trunctfsf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9, 0x3b71e9e2);
170 test__trunctfsf2(0x1.234eebb5faa678f4488693abcdefp+4534, 0x7f800000);
171 test__trunctfsf2(0x1.edcba9bb8c76a5a43dd21f334634p-435, 0x0);
172}
173
174fn test__trunctfdf2(a: f128, expected: u64) void {
175 const x = __trunctfdf2(a);
176
177 const rep: u64 = @bitCast(x);
178 if (rep == expected) {
179 return;
180 }
181 // test other possible NaN representation(signal NaN)
182 else if (expected == 0x7ff8000000000000) {
183 if ((rep & 0x7ff0000000000000) == 0x7ff0000000000000 and (rep & 0xfffffffffffff) > 0) {
184 return;
185 }
186 }
187
188 @panic("__trunctfsf2 test failure");
189}
190
191test "trunctfdf2" {
192 // qnan
193 test__trunctfdf2(@bitCast(@as(u128, 0x7fff800000000000 << 64)), 0x7ff8000000000000);
194 // nan
195 test__trunctfdf2(@bitCast(@as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7ff8100000000000);
196 // inf
197 test__trunctfdf2(@bitCast(@as(u128, 0x7fff000000000000 << 64)), 0x7ff0000000000000);
198 // zero
199 test__trunctfdf2(0.0, 0x0);
200
201 test__trunctfdf2(0x1.af23456789bbaaab347645365cdep+5, 0x404af23456789bbb);
202 test__trunctfdf2(0x1.dedafcff354b6ae9758763545432p-9, 0x3f6dedafcff354b7);
203 test__trunctfdf2(0x1.2f34dd5f437e849b4baab754cdefp+4534, 0x7ff0000000000000);
204 test__trunctfdf2(0x1.edcbff8ad76ab5bf46463233214fp-435, 0x24cedcbff8ad76ab);
205}
206
207fn test__truncdfsf2(a: f64, expected: u32) void {
208 const x = __truncdfsf2(a);
209
210 const rep: u32 = @bitCast(x);
211 if (rep == expected) {
212 return;
213 }
214 // test other possible NaN representation(signal NaN)
215 else if (expected == 0x7fc00000) {
216 if ((rep & 0x7f800000) == 0x7f800000 and (rep & 0x7fffff) > 0) {
217 return;
218 }
219 }
220
221 std.debug.print("got 0x{x} wanted 0x{x}\n", .{ rep, expected });
222
223 @panic("__trunctfsf2 test failure");
224}
225
226test "truncdfsf2" {
227 // nan & qnan
228 test__truncdfsf2(@bitCast(@as(u64, 0x7ff8000000000000)), 0x7fc00000);
229 test__truncdfsf2(@bitCast(@as(u64, 0x7ff0000000000001)), 0x7fc00000);
230 // inf
231 test__truncdfsf2(@bitCast(@as(u64, 0x7ff0000000000000)), 0x7f800000);
232 test__truncdfsf2(@bitCast(@as(u64, 0xfff0000000000000)), 0xff800000);
233
234 test__truncdfsf2(0.0, 0x0);
235 test__truncdfsf2(1.0, 0x3f800000);
236 test__truncdfsf2(-1.0, 0xbf800000);
237
238 // huge number becomes inf
239 test__truncdfsf2(340282366920938463463374607431768211456.0, 0x7f800000);
240}
241
242fn test__trunctfhf2(a: f128, expected: u16) void {
243 const x = __trunctfhf2(a);
244
245 const rep: u16 = @bitCast(x);
246 if (rep == expected) {
247 return;
248 }
249
250 std.debug.print("got 0x{x} wanted 0x{x}\n", .{ rep, expected });
251
252 @panic("__trunctfhf2 test failure");
253}
254
255test "trunctfhf2" {
256 // qNaN
257 test__trunctfhf2(@bitCast(@as(u128, 0x7fff8000000000000000000000000000)), 0x7e00);
258 // NaN
259 test__trunctfhf2(@bitCast(@as(u128, 0x7fff0000000000000000000000000001)), 0x7e00);
260 // inf
261 test__trunctfhf2(@bitCast(@as(u128, 0x7fff0000000000000000000000000000)), 0x7c00);
262 test__trunctfhf2(-@as(f128, @bitCast(@as(u128, 0x7fff0000000000000000000000000000))), 0xfc00);
263 // zero
264 test__trunctfhf2(0.0, 0x0);
265 test__trunctfhf2(-0.0, 0x8000);
266
267 test__trunctfhf2(3.1415926535, 0x4248);
268 test__trunctfhf2(-3.1415926535, 0xc248);
269 test__trunctfhf2(0x1.987124876876324p+100, 0x7c00);
270 test__trunctfhf2(0x1.987124876876324p+12, 0x6e62);
271 test__trunctfhf2(0x1.0p+0, 0x3c00);
272 test__trunctfhf2(0x1.0p-14, 0x0400);
273 // denormal
274 test__trunctfhf2(0x1.0p-20, 0x0010);
275 test__trunctfhf2(0x1.0p-24, 0x0001);
276 test__trunctfhf2(-0x1.0p-24, 0x8001);
277 test__trunctfhf2(0x1.5p-25, 0x0001);
278 // and back to zero
279 test__trunctfhf2(0x1.0p-25, 0x0000);
280 test__trunctfhf2(-0x1.0p-25, 0x8000);
281 // max (precise)
282 test__trunctfhf2(65504.0, 0x7bff);
283 // max (rounded)
284 test__trunctfhf2(65519.0, 0x7bff);
285 // max (to +inf)
286 test__trunctfhf2(65520.0, 0x7c00);
287 test__trunctfhf2(65536.0, 0x7c00);
288 test__trunctfhf2(-65520.0, 0xfc00);
289
290 test__trunctfhf2(0x1.23a2abb4a2ddee355f36789abcdep+5, 0x508f);
291 test__trunctfhf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9, 0x1b8f);
292 test__trunctfhf2(0x1.234eebb5faa678f4488693abcdefp+453, 0x7c00);
293 test__trunctfhf2(0x1.edcba9bb8c76a5a43dd21f334634p-43, 0x0);
294}
295
296test "trunctfxf2" {
297 try test__trunctfxf2(1.5, 1.5);
298 try test__trunctfxf2(2.5, 2.5);
299 try test__trunctfxf2(-2.5, -2.5);
300 try test__trunctfxf2(0.0, 0.0);
301}
302
303fn test__trunctfxf2(a: f128, expected: f80) !void {
304 const x = __trunctfxf2(a);
305 try testing.expect(x == expected);
306}