1const std = @import("std");
2const testing = std.testing;
3const math = std.math;
4
5const impl = @import("int_from_float.zig");
6
7const i32_intFromFloat_f16 = impl.i32_intFromFloat_f16;
8const u32_intFromFloat_f16 = impl.u32_intFromFloat_f16;
9const i64_intFromFloat_f16 = impl.i64_intFromFloat_f16;
10const u64_intFromFloat_f16 = impl.u64_intFromFloat_f16;
11const i128_intFromFloat_f16 = impl.i128_intFromFloat_f16;
12const u128_intFromFloat_f16 = impl.u128_intFromFloat_f16;
13const signed_intFromFloat_f16 = impl.signed_intFromFloat_f16;
14const unsigned_intFromFloat_f16 = impl.unsigned_intFromFloat_f16;
15
16const i32_intFromFloat_f32 = impl.i32_intFromFloat_f32;
17const u32_intFromFloat_f32 = impl.u32_intFromFloat_f32;
18const i64_intFromFloat_f32 = impl.i64_intFromFloat_f32;
19const u64_intFromFloat_f32 = impl.u64_intFromFloat_f32;
20const i128_intFromFloat_f32 = impl.i128_intFromFloat_f32;
21const u128_intFromFloat_f32 = impl.u128_intFromFloat_f32;
22const signed_intFromFloat_f32 = impl.signed_intFromFloat_f32;
23const unsigned_intFromFloat_f32 = impl.unsigned_intFromFloat_f32;
24
25const i32_intFromFloat_f64 = impl.i32_intFromFloat_f64;
26const u32_intFromFloat_f64 = impl.u32_intFromFloat_f64;
27const i64_intFromFloat_f64 = impl.i64_intFromFloat_f64;
28const u64_intFromFloat_f64 = impl.u64_intFromFloat_f64;
29const i128_intFromFloat_f64 = impl.i128_intFromFloat_f64;
30const u128_intFromFloat_f64 = impl.u128_intFromFloat_f64;
31const signed_intFromFloat_f64 = impl.signed_intFromFloat_f64;
32const unsigned_intFromFloat_f64 = impl.unsigned_intFromFloat_f64;
33
34const i32_intFromFloat_f80 = impl.i32_intFromFloat_f80;
35const u32_intFromFloat_f80 = impl.u32_intFromFloat_f80;
36const i64_intFromFloat_f80 = impl.i64_intFromFloat_f80;
37const u64_intFromFloat_f80 = impl.u64_intFromFloat_f80;
38const i128_intFromFloat_f80 = impl.i128_intFromFloat_f80;
39const u128_intFromFloat_f80 = impl.u128_intFromFloat_f80;
40const signed_intFromFloat_f80 = impl.signed_intFromFloat_f80;
41const unsigned_intFromFloat_f80 = impl.unsigned_intFromFloat_f80;
42
43const i32_intFromFloat_f128 = impl.i32_intFromFloat_f128;
44const u32_intFromFloat_f128 = impl.u32_intFromFloat_f128;
45const i64_intFromFloat_f128 = impl.i64_intFromFloat_f128;
46const u64_intFromFloat_f128 = impl.u64_intFromFloat_f128;
47const i128_intFromFloat_f128 = impl.i128_intFromFloat_f128;
48const u128_intFromFloat_f128 = impl.u128_intFromFloat_f128;
49const signed_intFromFloat_f128 = impl.signed_intFromFloat_f128;
50const unsigned_intFromFloat_f128 = impl.unsigned_intFromFloat_f128;
51
52fn test_i32_intFromFloat_f32(a: f32, expected: i32) !void {
53 const x = i32_intFromFloat_f32(a);
54 try testing.expect(x == expected);
55}
56
57fn test_u32_intFromFloat_f32(a: f32, expected: u32) !void {
58 const x = u32_intFromFloat_f32(a);
59 try testing.expect(x == expected);
60}
61
62test i32_intFromFloat_f32 {
63 try test_i32_intFromFloat_f32(-math.floatMax(f32), math.minInt(i32));
64
65 try test_i32_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
66 try test_i32_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
67
68 try test_i32_intFromFloat_f32(-0x1.0000000000000p+127, -0x80000000);
69 try test_i32_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
70 try test_i32_intFromFloat_f32(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
71
72 try test_i32_intFromFloat_f32(-0x1.0000000000001p+63, -0x80000000);
73 try test_i32_intFromFloat_f32(-0x1.0000000000000p+63, -0x80000000);
74 try test_i32_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
75 try test_i32_intFromFloat_f32(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
76
77 try test_i32_intFromFloat_f32(-0x1.FFFFFEp+62, -0x80000000);
78 try test_i32_intFromFloat_f32(-0x1.FFFFFCp+62, -0x80000000);
79
80 try test_i32_intFromFloat_f32(-0x1.000000p+31, -0x80000000);
81 try test_i32_intFromFloat_f32(-0x1.FFFFFFp+30, -0x80000000);
82 try test_i32_intFromFloat_f32(-0x1.FFFFFEp+30, -0x7FFFFF80);
83 try test_i32_intFromFloat_f32(-0x1.FFFFFCp+30, -0x7FFFFF00);
84
85 try test_i32_intFromFloat_f32(-2.01, -2);
86 try test_i32_intFromFloat_f32(-2.0, -2);
87 try test_i32_intFromFloat_f32(-1.99, -1);
88 try test_i32_intFromFloat_f32(-1.0, -1);
89 try test_i32_intFromFloat_f32(-0.99, 0);
90 try test_i32_intFromFloat_f32(-0.5, 0);
91
92 try test_i32_intFromFloat_f32(-math.floatMin(f32), 0);
93 try test_i32_intFromFloat_f32(0.0, 0);
94 try test_i32_intFromFloat_f32(math.floatMin(f32), 0);
95 try test_i32_intFromFloat_f32(0.5, 0);
96 try test_i32_intFromFloat_f32(0.99, 0);
97 try test_i32_intFromFloat_f32(1.0, 1);
98 try test_i32_intFromFloat_f32(1.5, 1);
99 try test_i32_intFromFloat_f32(1.99, 1);
100 try test_i32_intFromFloat_f32(2.0, 2);
101 try test_i32_intFromFloat_f32(2.01, 2);
102
103 try test_i32_intFromFloat_f32(0x1.FFFFFCp+30, 0x7FFFFF00);
104 try test_i32_intFromFloat_f32(0x1.FFFFFEp+30, 0x7FFFFF80);
105 try test_i32_intFromFloat_f32(0x1.FFFFFFp+30, 0x7FFFFFFF);
106 try test_i32_intFromFloat_f32(0x1.000000p+31, 0x7FFFFFFF);
107
108 try test_i32_intFromFloat_f32(0x1.FFFFFCp+62, 0x7FFFFFFF);
109 try test_i32_intFromFloat_f32(0x1.FFFFFEp+62, 0x7FFFFFFF);
110
111 try test_i32_intFromFloat_f32(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
112 try test_i32_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
113 try test_i32_intFromFloat_f32(0x1.0000000000000p+63, 0x7FFFFFFF);
114 try test_i32_intFromFloat_f32(0x1.0000000000001p+63, 0x7FFFFFFF);
115
116 try test_i32_intFromFloat_f32(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
117 try test_i32_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
118 try test_i32_intFromFloat_f32(0x1.0000000000000p+127, 0x7FFFFFFF);
119
120 try test_i32_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
121 try test_i32_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
122
123 try test_i32_intFromFloat_f32(math.floatMax(f32), math.maxInt(i32));
124}
125
126test u32_intFromFloat_f32 {
127 try test_u32_intFromFloat_f32(0.0, 0);
128
129 try test_u32_intFromFloat_f32(0.5, 0);
130 try test_u32_intFromFloat_f32(0.99, 0);
131 try test_u32_intFromFloat_f32(1.0, 1);
132 try test_u32_intFromFloat_f32(1.5, 1);
133 try test_u32_intFromFloat_f32(1.99, 1);
134 try test_u32_intFromFloat_f32(2.0, 2);
135 try test_u32_intFromFloat_f32(2.01, 2);
136 try test_u32_intFromFloat_f32(-0.5, 0);
137 try test_u32_intFromFloat_f32(-0.99, 0);
138
139 try test_u32_intFromFloat_f32(-1.0, 0);
140 try test_u32_intFromFloat_f32(-1.5, 0);
141 try test_u32_intFromFloat_f32(-1.99, 0);
142 try test_u32_intFromFloat_f32(-2.0, 0);
143 try test_u32_intFromFloat_f32(-2.01, 0);
144
145 try test_u32_intFromFloat_f32(0x1.000000p+31, 0x80000000);
146 try test_u32_intFromFloat_f32(0x1.000000p+32, 0xFFFFFFFF);
147 try test_u32_intFromFloat_f32(0x1.FFFFFEp+31, 0xFFFFFF00);
148 try test_u32_intFromFloat_f32(0x1.FFFFFEp+30, 0x7FFFFF80);
149 try test_u32_intFromFloat_f32(0x1.FFFFFCp+30, 0x7FFFFF00);
150
151 try test_u32_intFromFloat_f32(-0x1.FFFFFEp+30, 0);
152 try test_u32_intFromFloat_f32(-0x1.FFFFFCp+30, 0);
153}
154
155fn test_i64_intFromFloat_f32(a: f32, expected: i64) !void {
156 const x = i64_intFromFloat_f32(a);
157 try testing.expect(x == expected);
158}
159
160fn test_u64_intFromFloat_f32(a: f32, expected: u64) !void {
161 const x = u64_intFromFloat_f32(a);
162 try testing.expect(x == expected);
163}
164
165test i64_intFromFloat_f32 {
166 try test_i64_intFromFloat_f32(-math.floatMax(f32), math.minInt(i64));
167
168 try test_i64_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
169 try test_i64_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
170
171 try test_i64_intFromFloat_f32(-0x1.0000000000000p+127, -0x8000000000000000);
172 try test_i64_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
173 try test_i64_intFromFloat_f32(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
174
175 try test_i64_intFromFloat_f32(-0x1.0000000000001p+63, -0x8000000000000000);
176 try test_i64_intFromFloat_f32(-0x1.0000000000000p+63, -0x8000000000000000);
177 try test_i64_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
178 try test_i64_intFromFloat_f32(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
179
180 try test_i64_intFromFloat_f32(-0x1.FFFFFFp+62, -0x8000000000000000);
181 try test_i64_intFromFloat_f32(-0x1.FFFFFEp+62, -0x7fffff8000000000);
182 try test_i64_intFromFloat_f32(-0x1.FFFFFCp+62, -0x7fffff0000000000);
183
184 try test_i64_intFromFloat_f32(-2.01, -2);
185 try test_i64_intFromFloat_f32(-2.0, -2);
186 try test_i64_intFromFloat_f32(-1.99, -1);
187 try test_i64_intFromFloat_f32(-1.0, -1);
188 try test_i64_intFromFloat_f32(-0.99, 0);
189 try test_i64_intFromFloat_f32(-0.5, 0);
190 try test_i64_intFromFloat_f32(-math.floatMin(f32), 0);
191 try test_i64_intFromFloat_f32(0.0, 0);
192 try test_i64_intFromFloat_f32(math.floatMin(f32), 0);
193 try test_i64_intFromFloat_f32(0.5, 0);
194 try test_i64_intFromFloat_f32(0.99, 0);
195 try test_i64_intFromFloat_f32(1.0, 1);
196 try test_i64_intFromFloat_f32(1.5, 1);
197 try test_i64_intFromFloat_f32(1.99, 1);
198 try test_i64_intFromFloat_f32(2.0, 2);
199 try test_i64_intFromFloat_f32(2.01, 2);
200
201 try test_i64_intFromFloat_f32(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
202 try test_i64_intFromFloat_f32(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
203 try test_i64_intFromFloat_f32(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
204
205 try test_i64_intFromFloat_f32(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
206 try test_i64_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
207 try test_i64_intFromFloat_f32(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
208 try test_i64_intFromFloat_f32(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
209
210 try test_i64_intFromFloat_f32(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
211 try test_i64_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
212 try test_i64_intFromFloat_f32(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
213
214 try test_i64_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
215 try test_i64_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
216
217 try test_i64_intFromFloat_f32(math.floatMax(f32), math.maxInt(i64));
218}
219
220test u64_intFromFloat_f32 {
221 try test_u64_intFromFloat_f32(0.0, 0);
222
223 try test_u64_intFromFloat_f32(0.5, 0);
224 try test_u64_intFromFloat_f32(0.99, 0);
225 try test_u64_intFromFloat_f32(1.0, 1);
226 try test_u64_intFromFloat_f32(1.5, 1);
227 try test_u64_intFromFloat_f32(1.99, 1);
228 try test_u64_intFromFloat_f32(2.0, 2);
229 try test_u64_intFromFloat_f32(2.01, 2);
230 try test_u64_intFromFloat_f32(-0.5, 0);
231 try test_u64_intFromFloat_f32(-0.99, 0);
232
233 try test_u64_intFromFloat_f32(-1.0, 0);
234 try test_u64_intFromFloat_f32(-1.5, 0);
235 try test_u64_intFromFloat_f32(-1.99, 0);
236 try test_u64_intFromFloat_f32(-2.0, 0);
237 try test_u64_intFromFloat_f32(-2.01, 0);
238
239 try test_u64_intFromFloat_f32(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
240 try test_u64_intFromFloat_f32(0x1.000000p+63, 0x8000000000000000);
241 try test_u64_intFromFloat_f32(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
242 try test_u64_intFromFloat_f32(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
243
244 try test_u64_intFromFloat_f32(-0x1.FFFFFEp+62, 0x0000000000000000);
245 try test_u64_intFromFloat_f32(-0x1.FFFFFCp+62, 0x0000000000000000);
246}
247
248fn test_i128_intFromFloat_f32(a: f32, expected: i128) !void {
249 const x = i128_intFromFloat_f32(a);
250 try testing.expect(x == expected);
251}
252
253fn test_u128_intFromFloat_f32(a: f32, expected: u128) !void {
254 const x = u128_intFromFloat_f32(a);
255 try testing.expect(x == expected);
256}
257
258test i128_intFromFloat_f32 {
259 try test_i128_intFromFloat_f32(-math.floatMax(f32), math.minInt(i128));
260
261 try test_i128_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
262 try test_i128_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
263
264 try test_i128_intFromFloat_f32(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
265 try test_i128_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
266 try test_i128_intFromFloat_f32(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
267 try test_i128_intFromFloat_f32(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
268 try test_i128_intFromFloat_f32(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
269 try test_i128_intFromFloat_f32(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
270
271 try test_i128_intFromFloat_f32(-0x1.0000000000001p+63, -0x8000000000000000);
272 try test_i128_intFromFloat_f32(-0x1.0000000000000p+63, -0x8000000000000000);
273 try test_i128_intFromFloat_f32(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
274 try test_i128_intFromFloat_f32(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
275
276 try test_i128_intFromFloat_f32(-0x1.FFFFFFp+62, -0x8000000000000000);
277 try test_i128_intFromFloat_f32(-0x1.FFFFFEp+62, -0x7fffff8000000000);
278 try test_i128_intFromFloat_f32(-0x1.FFFFFCp+62, -0x7fffff0000000000);
279
280 try test_i128_intFromFloat_f32(-0x1.000000p+31, -0x80000000);
281 try test_i128_intFromFloat_f32(-0x1.FFFFFFp+30, -0x80000000);
282 try test_i128_intFromFloat_f32(-0x1.FFFFFEp+30, -0x7FFFFF80);
283 try test_i128_intFromFloat_f32(-0x1.FFFFFCp+30, -0x7FFFFF00);
284
285 try test_i128_intFromFloat_f32(-2.01, -2);
286 try test_i128_intFromFloat_f32(-2.0, -2);
287 try test_i128_intFromFloat_f32(-1.99, -1);
288 try test_i128_intFromFloat_f32(-1.0, -1);
289 try test_i128_intFromFloat_f32(-0.99, 0);
290 try test_i128_intFromFloat_f32(-0.5, 0);
291 try test_i128_intFromFloat_f32(-math.floatMin(f32), 0);
292 try test_i128_intFromFloat_f32(0.0, 0);
293 try test_i128_intFromFloat_f32(math.floatMin(f32), 0);
294 try test_i128_intFromFloat_f32(0.5, 0);
295 try test_i128_intFromFloat_f32(0.99, 0);
296 try test_i128_intFromFloat_f32(1.0, 1);
297 try test_i128_intFromFloat_f32(1.5, 1);
298 try test_i128_intFromFloat_f32(1.99, 1);
299 try test_i128_intFromFloat_f32(2.0, 2);
300 try test_i128_intFromFloat_f32(2.01, 2);
301
302 try test_i128_intFromFloat_f32(0x1.FFFFFCp+30, 0x7FFFFF00);
303 try test_i128_intFromFloat_f32(0x1.FFFFFEp+30, 0x7FFFFF80);
304 try test_i128_intFromFloat_f32(0x1.FFFFFFp+30, 0x80000000);
305 try test_i128_intFromFloat_f32(0x1.000000p+31, 0x80000000);
306
307 try test_i128_intFromFloat_f32(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
308 try test_i128_intFromFloat_f32(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
309 try test_i128_intFromFloat_f32(0x1.FFFFFFp+62, 0x8000000000000000);
310
311 try test_i128_intFromFloat_f32(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
312 try test_i128_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
313 try test_i128_intFromFloat_f32(0x1.0000000000000p+63, 0x8000000000000000);
314 try test_i128_intFromFloat_f32(0x1.0000000000001p+63, 0x8000000000000000);
315
316 try test_i128_intFromFloat_f32(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
317 try test_i128_intFromFloat_f32(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
318 try test_i128_intFromFloat_f32(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
319 try test_i128_intFromFloat_f32(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
320 try test_i128_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
321 try test_i128_intFromFloat_f32(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
322
323 try test_i128_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
324 try test_i128_intFromFloat_f32(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
325
326 try test_i128_intFromFloat_f32(math.floatMax(f32), math.maxInt(i128));
327}
328
329test u128_intFromFloat_f32 {
330 try test_u128_intFromFloat_f32(0.0, 0);
331
332 try test_u128_intFromFloat_f32(0.5, 0);
333 try test_u128_intFromFloat_f32(0.99, 0);
334 try test_u128_intFromFloat_f32(1.0, 1);
335 try test_u128_intFromFloat_f32(1.5, 1);
336 try test_u128_intFromFloat_f32(1.99, 1);
337 try test_u128_intFromFloat_f32(2.0, 2);
338 try test_u128_intFromFloat_f32(2.01, 2);
339 try test_u128_intFromFloat_f32(-0.5, 0);
340 try test_u128_intFromFloat_f32(-0.99, 0);
341
342 try test_u128_intFromFloat_f32(-1.0, 0);
343 try test_u128_intFromFloat_f32(-1.5, 0);
344 try test_u128_intFromFloat_f32(-1.99, 0);
345 try test_u128_intFromFloat_f32(-2.0, 0);
346 try test_u128_intFromFloat_f32(-2.01, 0);
347
348 try test_u128_intFromFloat_f32(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
349 try test_u128_intFromFloat_f32(0x1.000000p+63, 0x8000000000000000);
350 try test_u128_intFromFloat_f32(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
351 try test_u128_intFromFloat_f32(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
352 try test_u128_intFromFloat_f32(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
353 try test_u128_intFromFloat_f32(0x1.000000p+127, 0x80000000000000000000000000000000);
354 try test_u128_intFromFloat_f32(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
355 try test_u128_intFromFloat_f32(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
356
357 try test_u128_intFromFloat_f32(-0x1.FFFFFEp+62, 0x0000000000000000);
358 try test_u128_intFromFloat_f32(-0x1.FFFFFCp+62, 0x0000000000000000);
359 try test_u128_intFromFloat_f32(-0x1.FFFFFEp+126, 0x0000000000000000);
360 try test_u128_intFromFloat_f32(-0x1.FFFFFCp+126, 0x0000000000000000);
361 try test_u128_intFromFloat_f32(math.floatMax(f32), 0xffffff00000000000000000000000000);
362 try test_u128_intFromFloat_f32(math.inf(f32), math.maxInt(u128));
363}
364
365fn test_intFromFloat_f32(comptime T: type, expected: T, a: f32) !void {
366 const int = @typeInfo(T).int;
367 var actual: T = undefined;
368 _ = switch (int.signedness) {
369 .signed => signed_intFromFloat_f32,
370 .unsigned => unsigned_intFromFloat_f32,
371 }(@ptrCast(&actual), a);
372 try testing.expect(expected == actual);
373}
374
375test signed_intFromFloat_f32 {
376 try test_intFromFloat_f32(i256, -1 << 127, -0x1p127);
377 try test_intFromFloat_f32(i256, -1 << 100, -0x1p100);
378 try test_intFromFloat_f32(i256, -1 << 50, -0x1p50);
379 try test_intFromFloat_f32(i256, -1 << 1, -0x1p1);
380 try test_intFromFloat_f32(i256, -1 << 0, -0x1p0);
381 try test_intFromFloat_f32(i256, 0, 0);
382 try test_intFromFloat_f32(i256, 1 << 0, 0x1p0);
383 try test_intFromFloat_f32(i256, 1 << 1, 0x1p1);
384 try test_intFromFloat_f32(i256, 1 << 50, 0x1p50);
385 try test_intFromFloat_f32(i256, 1 << 100, 0x1p100);
386 try test_intFromFloat_f32(i256, 1 << 127, 0x1p127);
387}
388
389test unsigned_intFromFloat_f32 {
390 try test_intFromFloat_f32(u256, 0, 0);
391 try test_intFromFloat_f32(u256, 1 << 0, 0x1p0);
392 try test_intFromFloat_f32(u256, 1 << 1, 0x1p1);
393 try test_intFromFloat_f32(u256, 1 << 50, 0x1p50);
394 try test_intFromFloat_f32(u256, 1 << 100, 0x1p100);
395 try test_intFromFloat_f32(u256, 1 << 127, 0x1p127);
396}
397
398fn test_i32_intFromFloat_f64(a: f64, expected: i32) !void {
399 const x = i32_intFromFloat_f64(a);
400 try testing.expect(x == expected);
401}
402
403fn test_u32_intFromFloat_f64(a: f64, expected: u32) !void {
404 const x = u32_intFromFloat_f64(a);
405 try testing.expect(x == expected);
406}
407
408test i32_intFromFloat_f64 {
409 try test_i32_intFromFloat_f64(-math.floatMax(f64), math.minInt(i32));
410
411 try test_i32_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
412 try test_i32_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
413
414 try test_i32_intFromFloat_f64(-0x1.0000000000000p+127, -0x80000000);
415 try test_i32_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
416 try test_i32_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
417
418 try test_i32_intFromFloat_f64(-0x1.0000000000001p+63, -0x80000000);
419 try test_i32_intFromFloat_f64(-0x1.0000000000000p+63, -0x80000000);
420 try test_i32_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
421 try test_i32_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
422
423 try test_i32_intFromFloat_f64(-0x1.FFFFFEp+62, -0x80000000);
424 try test_i32_intFromFloat_f64(-0x1.FFFFFCp+62, -0x80000000);
425
426 try test_i32_intFromFloat_f64(-0x1.000000p+31, -0x80000000);
427 try test_i32_intFromFloat_f64(-0x1.FFFFFFp+30, -0x7FFFFFC0);
428 try test_i32_intFromFloat_f64(-0x1.FFFFFEp+30, -0x7FFFFF80);
429
430 try test_i32_intFromFloat_f64(-2.01, -2);
431 try test_i32_intFromFloat_f64(-2.0, -2);
432 try test_i32_intFromFloat_f64(-1.99, -1);
433 try test_i32_intFromFloat_f64(-1.0, -1);
434 try test_i32_intFromFloat_f64(-0.99, 0);
435 try test_i32_intFromFloat_f64(-0.5, 0);
436 try test_i32_intFromFloat_f64(-math.floatMin(f64), 0);
437 try test_i32_intFromFloat_f64(0.0, 0);
438 try test_i32_intFromFloat_f64(math.floatMin(f64), 0);
439 try test_i32_intFromFloat_f64(0.5, 0);
440 try test_i32_intFromFloat_f64(0.99, 0);
441 try test_i32_intFromFloat_f64(1.0, 1);
442 try test_i32_intFromFloat_f64(1.5, 1);
443 try test_i32_intFromFloat_f64(1.99, 1);
444 try test_i32_intFromFloat_f64(2.0, 2);
445 try test_i32_intFromFloat_f64(2.01, 2);
446
447 try test_i32_intFromFloat_f64(0x1.FFFFFEp+30, 0x7FFFFF80);
448 try test_i32_intFromFloat_f64(0x1.FFFFFFp+30, 0x7FFFFFC0);
449 try test_i32_intFromFloat_f64(0x1.000000p+31, 0x7FFFFFFF);
450
451 try test_i32_intFromFloat_f64(0x1.FFFFFCp+62, 0x7FFFFFFF);
452 try test_i32_intFromFloat_f64(0x1.FFFFFEp+62, 0x7FFFFFFF);
453
454 try test_i32_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
455 try test_i32_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
456 try test_i32_intFromFloat_f64(0x1.0000000000000p+63, 0x7FFFFFFF);
457 try test_i32_intFromFloat_f64(0x1.0000000000001p+63, 0x7FFFFFFF);
458
459 try test_i32_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
460 try test_i32_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
461 try test_i32_intFromFloat_f64(0x1.0000000000000p+127, 0x7FFFFFFF);
462
463 try test_i32_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
464 try test_i32_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
465
466 try test_i32_intFromFloat_f64(math.floatMax(f64), math.maxInt(i32));
467}
468
469test u32_intFromFloat_f64 {
470 try test_u32_intFromFloat_f64(0.0, 0);
471
472 try test_u32_intFromFloat_f64(0.5, 0);
473 try test_u32_intFromFloat_f64(0.99, 0);
474 try test_u32_intFromFloat_f64(1.0, 1);
475 try test_u32_intFromFloat_f64(1.5, 1);
476 try test_u32_intFromFloat_f64(1.99, 1);
477 try test_u32_intFromFloat_f64(2.0, 2);
478 try test_u32_intFromFloat_f64(2.01, 2);
479 try test_u32_intFromFloat_f64(-0.5, 0);
480 try test_u32_intFromFloat_f64(-0.99, 0);
481 try test_u32_intFromFloat_f64(-1.0, 0);
482 try test_u32_intFromFloat_f64(-1.5, 0);
483 try test_u32_intFromFloat_f64(-1.99, 0);
484 try test_u32_intFromFloat_f64(-2.0, 0);
485 try test_u32_intFromFloat_f64(-2.01, 0);
486
487 try test_u32_intFromFloat_f64(0x1.000000p+31, 0x80000000);
488 try test_u32_intFromFloat_f64(0x1.000000p+32, 0xFFFFFFFF);
489 try test_u32_intFromFloat_f64(0x1.FFFFFEp+31, 0xFFFFFF00);
490 try test_u32_intFromFloat_f64(0x1.FFFFFEp+30, 0x7FFFFF80);
491 try test_u32_intFromFloat_f64(0x1.FFFFFCp+30, 0x7FFFFF00);
492
493 try test_u32_intFromFloat_f64(-0x1.FFFFFEp+30, 0);
494 try test_u32_intFromFloat_f64(-0x1.FFFFFCp+30, 0);
495
496 try test_u32_intFromFloat_f64(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
497 try test_u32_intFromFloat_f64(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
498 try test_u32_intFromFloat_f64(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
499}
500
501fn test_i64_intFromFloat_f64(a: f64, expected: i64) !void {
502 const x = i64_intFromFloat_f64(a);
503 try testing.expect(x == expected);
504}
505
506fn test_u64_intFromFloat_f64(a: f64, expected: u64) !void {
507 const x = u64_intFromFloat_f64(a);
508 try testing.expect(x == expected);
509}
510
511test i64_intFromFloat_f64 {
512 try test_i64_intFromFloat_f64(-math.floatMax(f64), math.minInt(i64));
513
514 try test_i64_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
515 try test_i64_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
516
517 try test_i64_intFromFloat_f64(-0x1.0000000000000p+127, -0x8000000000000000);
518 try test_i64_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
519 try test_i64_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
520
521 try test_i64_intFromFloat_f64(-0x1.0000000000001p+63, -0x8000000000000000);
522 try test_i64_intFromFloat_f64(-0x1.0000000000000p+63, -0x8000000000000000);
523 try test_i64_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
524 try test_i64_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
525
526 try test_i64_intFromFloat_f64(-0x1.FFFFFEp+62, -0x7fffff8000000000);
527 try test_i64_intFromFloat_f64(-0x1.FFFFFCp+62, -0x7fffff0000000000);
528
529 try test_i64_intFromFloat_f64(-2.01, -2);
530 try test_i64_intFromFloat_f64(-2.0, -2);
531 try test_i64_intFromFloat_f64(-1.99, -1);
532 try test_i64_intFromFloat_f64(-1.0, -1);
533 try test_i64_intFromFloat_f64(-0.99, 0);
534 try test_i64_intFromFloat_f64(-0.5, 0);
535 try test_i64_intFromFloat_f64(-math.floatMin(f64), 0);
536 try test_i64_intFromFloat_f64(0.0, 0);
537 try test_i64_intFromFloat_f64(math.floatMin(f64), 0);
538 try test_i64_intFromFloat_f64(0.5, 0);
539 try test_i64_intFromFloat_f64(0.99, 0);
540 try test_i64_intFromFloat_f64(1.0, 1);
541 try test_i64_intFromFloat_f64(1.5, 1);
542 try test_i64_intFromFloat_f64(1.99, 1);
543 try test_i64_intFromFloat_f64(2.0, 2);
544 try test_i64_intFromFloat_f64(2.01, 2);
545
546 try test_i64_intFromFloat_f64(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
547 try test_i64_intFromFloat_f64(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
548
549 try test_i64_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
550 try test_i64_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
551 try test_i64_intFromFloat_f64(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
552 try test_i64_intFromFloat_f64(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
553
554 try test_i64_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
555 try test_i64_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
556 try test_i64_intFromFloat_f64(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
557
558 try test_i64_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
559 try test_i64_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
560
561 try test_i64_intFromFloat_f64(math.floatMax(f64), math.maxInt(i64));
562}
563
564test u64_intFromFloat_f64 {
565 try test_u64_intFromFloat_f64(0.0, 0);
566 try test_u64_intFromFloat_f64(0.5, 0);
567 try test_u64_intFromFloat_f64(0.99, 0);
568 try test_u64_intFromFloat_f64(1.0, 1);
569 try test_u64_intFromFloat_f64(1.5, 1);
570 try test_u64_intFromFloat_f64(1.99, 1);
571 try test_u64_intFromFloat_f64(2.0, 2);
572 try test_u64_intFromFloat_f64(2.01, 2);
573 try test_u64_intFromFloat_f64(-0.5, 0);
574 try test_u64_intFromFloat_f64(-0.99, 0);
575 try test_u64_intFromFloat_f64(-1.0, 0);
576 try test_u64_intFromFloat_f64(-1.5, 0);
577 try test_u64_intFromFloat_f64(-1.99, 0);
578 try test_u64_intFromFloat_f64(-2.0, 0);
579 try test_u64_intFromFloat_f64(-2.01, 0);
580
581 try test_u64_intFromFloat_f64(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
582 try test_u64_intFromFloat_f64(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
583
584 try test_u64_intFromFloat_f64(-0x1.FFFFFEp+62, 0);
585 try test_u64_intFromFloat_f64(-0x1.FFFFFCp+62, 0);
586
587 try test_u64_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
588 try test_u64_intFromFloat_f64(0x1.0000000000000p+63, 0x8000000000000000);
589 try test_u64_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
590 try test_u64_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
591
592 try test_u64_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+62, 0);
593 try test_u64_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+62, 0);
594}
595
596fn test_i128_intFromFloat_f64(a: f64, expected: i128) !void {
597 const x = i128_intFromFloat_f64(a);
598 try testing.expect(x == expected);
599}
600
601fn test_u128_intFromFloat_f64(a: f64, expected: u128) !void {
602 const x = u128_intFromFloat_f64(a);
603 try testing.expect(x == expected);
604}
605
606test i128_intFromFloat_f64 {
607 try test_i128_intFromFloat_f64(-math.floatMax(f64), math.minInt(i128));
608
609 try test_i128_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
610 try test_i128_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
611
612 try test_i128_intFromFloat_f64(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
613 try test_i128_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
614 try test_i128_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
615
616 try test_i128_intFromFloat_f64(-0x1.0000000000001p+63, -0x8000000000000800);
617 try test_i128_intFromFloat_f64(-0x1.0000000000000p+63, -0x8000000000000000);
618 try test_i128_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
619 try test_i128_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
620
621 try test_i128_intFromFloat_f64(-0x1.FFFFFEp+62, -0x7fffff8000000000);
622 try test_i128_intFromFloat_f64(-0x1.FFFFFCp+62, -0x7fffff0000000000);
623
624 try test_i128_intFromFloat_f64(-2.01, -2);
625 try test_i128_intFromFloat_f64(-2.0, -2);
626 try test_i128_intFromFloat_f64(-1.99, -1);
627 try test_i128_intFromFloat_f64(-1.0, -1);
628 try test_i128_intFromFloat_f64(-0.99, 0);
629 try test_i128_intFromFloat_f64(-0.5, 0);
630 try test_i128_intFromFloat_f64(-math.floatMin(f64), 0);
631 try test_i128_intFromFloat_f64(0.0, 0);
632 try test_i128_intFromFloat_f64(math.floatMin(f64), 0);
633 try test_i128_intFromFloat_f64(0.5, 0);
634 try test_i128_intFromFloat_f64(0.99, 0);
635 try test_i128_intFromFloat_f64(1.0, 1);
636 try test_i128_intFromFloat_f64(1.5, 1);
637 try test_i128_intFromFloat_f64(1.99, 1);
638 try test_i128_intFromFloat_f64(2.0, 2);
639 try test_i128_intFromFloat_f64(2.01, 2);
640
641 try test_i128_intFromFloat_f64(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
642 try test_i128_intFromFloat_f64(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
643
644 try test_i128_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
645 try test_i128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
646 try test_i128_intFromFloat_f64(0x1.0000000000000p+63, 0x8000000000000000);
647 try test_i128_intFromFloat_f64(0x1.0000000000001p+63, 0x8000000000000800);
648
649 try test_i128_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
650 try test_i128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
651 try test_i128_intFromFloat_f64(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
652
653 try test_i128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
654 try test_i128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
655
656 try test_i128_intFromFloat_f64(math.floatMax(f64), math.maxInt(i128));
657}
658
659test u128_intFromFloat_f64 {
660 try test_u128_intFromFloat_f64(0.0, 0);
661
662 try test_u128_intFromFloat_f64(0.5, 0);
663 try test_u128_intFromFloat_f64(0.99, 0);
664 try test_u128_intFromFloat_f64(1.0, 1);
665 try test_u128_intFromFloat_f64(1.5, 1);
666 try test_u128_intFromFloat_f64(1.99, 1);
667 try test_u128_intFromFloat_f64(2.0, 2);
668 try test_u128_intFromFloat_f64(2.01, 2);
669 try test_u128_intFromFloat_f64(-0.5, 0);
670 try test_u128_intFromFloat_f64(-0.99, 0);
671 try test_u128_intFromFloat_f64(-1.0, 0);
672 try test_u128_intFromFloat_f64(-1.5, 0);
673 try test_u128_intFromFloat_f64(-1.99, 0);
674 try test_u128_intFromFloat_f64(-2.0, 0);
675 try test_u128_intFromFloat_f64(-2.01, 0);
676
677 try test_u128_intFromFloat_f64(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
678 try test_u128_intFromFloat_f64(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
679
680 try test_u128_intFromFloat_f64(-0x1.FFFFFEp+62, 0);
681 try test_u128_intFromFloat_f64(-0x1.FFFFFCp+62, 0);
682
683 try test_u128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
684 try test_u128_intFromFloat_f64(0x1.0000000000000p+63, 0x8000000000000000);
685 try test_u128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
686 try test_u128_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
687
688 try test_u128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
689 try test_u128_intFromFloat_f64(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
690 try test_u128_intFromFloat_f64(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
691 try test_u128_intFromFloat_f64(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
692 try test_u128_intFromFloat_f64(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
693
694 try test_u128_intFromFloat_f64(-0x1.FFFFFFFFFFFFFp+62, 0);
695 try test_u128_intFromFloat_f64(-0x1.FFFFFFFFFFFFEp+62, 0);
696}
697
698fn test_intFromFloat_f64(comptime T: type, expected: T, a: f64) !void {
699 const int = @typeInfo(T).int;
700 var actual: T = undefined;
701 _ = switch (int.signedness) {
702 .signed => signed_intFromFloat_f64,
703 .unsigned => unsigned_intFromFloat_f64,
704 }(@ptrCast(&actual), a);
705 try testing.expect(expected == actual);
706}
707
708test signed_intFromFloat_f64 {
709 try test_intFromFloat_f64(i256, -1 << 255, -0x1p255);
710 try test_intFromFloat_f64(i256, -1 << 127, -0x1p127);
711 try test_intFromFloat_f64(i256, -1 << 100, -0x1p100);
712 try test_intFromFloat_f64(i256, -1 << 50, -0x1p50);
713 try test_intFromFloat_f64(i256, -1 << 1, -0x1p1);
714 try test_intFromFloat_f64(i256, -1 << 0, -0x1p0);
715 try test_intFromFloat_f64(i256, 0, 0);
716 try test_intFromFloat_f64(i256, 1 << 0, 0x1p0);
717 try test_intFromFloat_f64(i256, 1 << 1, 0x1p1);
718 try test_intFromFloat_f64(i256, 1 << 50, 0x1p50);
719 try test_intFromFloat_f64(i256, 1 << 100, 0x1p100);
720 try test_intFromFloat_f64(i256, 1 << 127, 0x1p127);
721 try test_intFromFloat_f64(i256, 1 << 254, 0x1p254);
722}
723
724test unsigned_intFromFloat_f64 {
725 try test_intFromFloat_f64(u256, 0, 0);
726 try test_intFromFloat_f64(u256, 1 << 0, 0x1p0);
727 try test_intFromFloat_f64(u256, 1 << 1, 0x1p1);
728 try test_intFromFloat_f64(u256, 1 << 50, 0x1p50);
729 try test_intFromFloat_f64(u256, 1 << 100, 0x1p100);
730 try test_intFromFloat_f64(u256, 1 << 127, 0x1p127);
731 try test_intFromFloat_f64(u256, 1 << 255, 0x1p255);
732}
733
734fn test_i32_intFromFloat_f128(a: f128, expected: i32) !void {
735 const x = i32_intFromFloat_f128(a);
736 try testing.expect(x == expected);
737}
738
739fn test_u32_intFromFloat_f128(a: f128, expected: u32) !void {
740 const x = u32_intFromFloat_f128(a);
741 try testing.expect(x == expected);
742}
743
744test i32_intFromFloat_f128 {
745 try test_i32_intFromFloat_f128(-math.floatMax(f128), math.minInt(i32));
746
747 try test_i32_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
748 try test_i32_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
749
750 try test_i32_intFromFloat_f128(-0x1.0000000000000p+127, -0x80000000);
751 try test_i32_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
752 try test_i32_intFromFloat_f128(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
753
754 try test_i32_intFromFloat_f128(-0x1.0000000000001p+63, -0x80000000);
755 try test_i32_intFromFloat_f128(-0x1.0000000000000p+63, -0x80000000);
756 try test_i32_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
757 try test_i32_intFromFloat_f128(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
758
759 try test_i32_intFromFloat_f128(-0x1.FFFFFEp+62, -0x80000000);
760 try test_i32_intFromFloat_f128(-0x1.FFFFFCp+62, -0x80000000);
761
762 try test_i32_intFromFloat_f128(-0x1.000000p+31, -0x80000000);
763 try test_i32_intFromFloat_f128(-0x1.FFFFFFp+30, -0x7FFFFFC0);
764 try test_i32_intFromFloat_f128(-0x1.FFFFFEp+30, -0x7FFFFF80);
765 try test_i32_intFromFloat_f128(-0x1.FFFFFCp+30, -0x7FFFFF00);
766
767 try test_i32_intFromFloat_f128(-2.01, -2);
768 try test_i32_intFromFloat_f128(-2.0, -2);
769 try test_i32_intFromFloat_f128(-1.99, -1);
770 try test_i32_intFromFloat_f128(-1.0, -1);
771 try test_i32_intFromFloat_f128(-0.99, 0);
772 try test_i32_intFromFloat_f128(-0.5, 0);
773 try test_i32_intFromFloat_f128(-math.floatMin(f32), 0);
774 try test_i32_intFromFloat_f128(0.0, 0);
775 try test_i32_intFromFloat_f128(math.floatMin(f32), 0);
776 try test_i32_intFromFloat_f128(0.5, 0);
777 try test_i32_intFromFloat_f128(0.99, 0);
778 try test_i32_intFromFloat_f128(1.0, 1);
779 try test_i32_intFromFloat_f128(1.5, 1);
780 try test_i32_intFromFloat_f128(1.99, 1);
781 try test_i32_intFromFloat_f128(2.0, 2);
782 try test_i32_intFromFloat_f128(2.01, 2);
783
784 try test_i32_intFromFloat_f128(0x1.FFFFFCp+30, 0x7FFFFF00);
785 try test_i32_intFromFloat_f128(0x1.FFFFFEp+30, 0x7FFFFF80);
786 try test_i32_intFromFloat_f128(0x1.FFFFFFp+30, 0x7FFFFFC0);
787 try test_i32_intFromFloat_f128(0x1.000000p+31, 0x7FFFFFFF);
788
789 try test_i32_intFromFloat_f128(0x1.FFFFFCp+62, 0x7FFFFFFF);
790 try test_i32_intFromFloat_f128(0x1.FFFFFEp+62, 0x7FFFFFFF);
791
792 try test_i32_intFromFloat_f128(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
793 try test_i32_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
794 try test_i32_intFromFloat_f128(0x1.0000000000000p+63, 0x7FFFFFFF);
795 try test_i32_intFromFloat_f128(0x1.0000000000001p+63, 0x7FFFFFFF);
796
797 try test_i32_intFromFloat_f128(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
798 try test_i32_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
799 try test_i32_intFromFloat_f128(0x1.0000000000000p+127, 0x7FFFFFFF);
800
801 try test_i32_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
802 try test_i32_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
803
804 try test_i32_intFromFloat_f128(math.floatMax(f128), math.maxInt(i32));
805}
806
807test u32_intFromFloat_f128 {
808 try test_u32_intFromFloat_f128(math.inf(f128), 0xffffffff);
809 try test_u32_intFromFloat_f128(0, 0x0);
810 try test_u32_intFromFloat_f128(0x1.23456789abcdefp+5, 0x24);
811 try test_u32_intFromFloat_f128(0x1.23456789abcdefp-3, 0x0);
812 try test_u32_intFromFloat_f128(0x1.23456789abcdefp+20, 0x123456);
813 try test_u32_intFromFloat_f128(0x1.23456789abcdefp+40, 0xffffffff);
814 try test_u32_intFromFloat_f128(0x1.23456789abcdefp+256, 0xffffffff);
815 try test_u32_intFromFloat_f128(-0x1.23456789abcdefp+3, 0x0);
816
817 try test_u32_intFromFloat_f128(0x1p+32, 0xFFFFFFFF);
818}
819
820fn test_i64_intFromFloat_f128(a: f128, expected: i64) !void {
821 const x = i64_intFromFloat_f128(a);
822 try testing.expect(x == expected);
823}
824
825fn test_u64_intFromFloat_f128(a: f128, expected: u64) !void {
826 const x = u64_intFromFloat_f128(a);
827 try testing.expect(x == expected);
828}
829
830test i64_intFromFloat_f128 {
831 try test_i64_intFromFloat_f128(-math.floatMax(f128), math.minInt(i64));
832
833 try test_i64_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
834 try test_i64_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
835
836 try test_i64_intFromFloat_f128(-0x1.0000000000000p+127, -0x8000000000000000);
837 try test_i64_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
838 try test_i64_intFromFloat_f128(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
839
840 try test_i64_intFromFloat_f128(-0x1.0000000000001p+63, -0x8000000000000000);
841 try test_i64_intFromFloat_f128(-0x1.0000000000000p+63, -0x8000000000000000);
842 try test_i64_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
843 try test_i64_intFromFloat_f128(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
844
845 try test_i64_intFromFloat_f128(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
846 try test_i64_intFromFloat_f128(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
847
848 try test_i64_intFromFloat_f128(-0x1.000000p+31, -0x80000000);
849 try test_i64_intFromFloat_f128(-0x1.FFFFFFp+30, -0x7FFFFFC0);
850 try test_i64_intFromFloat_f128(-0x1.FFFFFEp+30, -0x7FFFFF80);
851 try test_i64_intFromFloat_f128(-0x1.FFFFFCp+30, -0x7FFFFF00);
852
853 try test_i64_intFromFloat_f128(-2.01, -2);
854 try test_i64_intFromFloat_f128(-2.0, -2);
855 try test_i64_intFromFloat_f128(-1.99, -1);
856 try test_i64_intFromFloat_f128(-1.0, -1);
857 try test_i64_intFromFloat_f128(-0.99, 0);
858 try test_i64_intFromFloat_f128(-0.5, 0);
859 try test_i64_intFromFloat_f128(-math.floatMin(f64), 0);
860 try test_i64_intFromFloat_f128(0.0, 0);
861 try test_i64_intFromFloat_f128(math.floatMin(f64), 0);
862 try test_i64_intFromFloat_f128(0.5, 0);
863 try test_i64_intFromFloat_f128(0.99, 0);
864 try test_i64_intFromFloat_f128(1.0, 1);
865 try test_i64_intFromFloat_f128(1.5, 1);
866 try test_i64_intFromFloat_f128(1.99, 1);
867 try test_i64_intFromFloat_f128(2.0, 2);
868 try test_i64_intFromFloat_f128(2.01, 2);
869
870 try test_i64_intFromFloat_f128(0x1.FFFFFCp+30, 0x7FFFFF00);
871 try test_i64_intFromFloat_f128(0x1.FFFFFEp+30, 0x7FFFFF80);
872 try test_i64_intFromFloat_f128(0x1.FFFFFFp+30, 0x7FFFFFC0);
873 try test_i64_intFromFloat_f128(0x1.000000p+31, 0x80000000);
874
875 try test_i64_intFromFloat_f128(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
876 try test_i64_intFromFloat_f128(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
877
878 try test_i64_intFromFloat_f128(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
879 try test_i64_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
880 try test_i64_intFromFloat_f128(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
881 try test_i64_intFromFloat_f128(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
882
883 try test_i64_intFromFloat_f128(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
884 try test_i64_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
885 try test_i64_intFromFloat_f128(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
886
887 try test_i64_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
888 try test_i64_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
889
890 try test_i64_intFromFloat_f128(math.floatMax(f128), math.maxInt(i64));
891}
892
893test u64_intFromFloat_f128 {
894 try test_u64_intFromFloat_f128(0.0, 0);
895
896 try test_u64_intFromFloat_f128(0.5, 0);
897 try test_u64_intFromFloat_f128(0.99, 0);
898 try test_u64_intFromFloat_f128(1.0, 1);
899 try test_u64_intFromFloat_f128(1.5, 1);
900 try test_u64_intFromFloat_f128(1.99, 1);
901 try test_u64_intFromFloat_f128(2.0, 2);
902 try test_u64_intFromFloat_f128(2.01, 2);
903 try test_u64_intFromFloat_f128(-0.5, 0);
904 try test_u64_intFromFloat_f128(-0.99, 0);
905 try test_u64_intFromFloat_f128(-1.0, 0);
906 try test_u64_intFromFloat_f128(-1.5, 0);
907 try test_u64_intFromFloat_f128(-1.99, 0);
908 try test_u64_intFromFloat_f128(-2.0, 0);
909 try test_u64_intFromFloat_f128(-2.01, 0);
910
911 try test_u64_intFromFloat_f128(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
912 try test_u64_intFromFloat_f128(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
913
914 try test_u64_intFromFloat_f128(-0x1.FFFFFEp+62, 0);
915 try test_u64_intFromFloat_f128(-0x1.FFFFFCp+62, 0);
916
917 try test_u64_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
918 try test_u64_intFromFloat_f128(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
919
920 try test_u64_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+62, 0);
921 try test_u64_intFromFloat_f128(-0x1.FFFFFFFFFFFFEp+62, 0);
922
923 try test_u64_intFromFloat_f128(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
924 try test_u64_intFromFloat_f128(0x1.0000000000000002p+63, 0x8000000000000001);
925 try test_u64_intFromFloat_f128(0x1.0000000000000000p+63, 0x8000000000000000);
926 try test_u64_intFromFloat_f128(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
927 try test_u64_intFromFloat_f128(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
928 try test_u64_intFromFloat_f128(0x1p+64, 0xFFFFFFFFFFFFFFFF);
929
930 try test_u64_intFromFloat_f128(-0x1.0000000000000000p+63, 0);
931 try test_u64_intFromFloat_f128(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
932 try test_u64_intFromFloat_f128(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
933}
934
935fn test_i128_intFromFloat_f128(a: f128, expected: i128) !void {
936 const x = i128_intFromFloat_f128(a);
937 try testing.expect(x == expected);
938}
939
940fn test_u128_intFromFloat_f128(a: f128, expected: u128) !void {
941 const x = u128_intFromFloat_f128(a);
942 try testing.expect(x == expected);
943}
944
945test i128_intFromFloat_f128 {
946 try test_i128_intFromFloat_f128(-math.floatMax(f128), math.minInt(i128));
947
948 try test_i128_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
949 try test_i128_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
950
951 try test_i128_intFromFloat_f128(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
952 try test_i128_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
953 try test_i128_intFromFloat_f128(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
954
955 try test_i128_intFromFloat_f128(-0x1.0000000000001p+63, -0x8000000000000800);
956 try test_i128_intFromFloat_f128(-0x1.0000000000000p+63, -0x8000000000000000);
957 try test_i128_intFromFloat_f128(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
958 try test_i128_intFromFloat_f128(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
959
960 try test_i128_intFromFloat_f128(-0x1.FFFFFEp+62, -0x7fffff8000000000);
961 try test_i128_intFromFloat_f128(-0x1.FFFFFCp+62, -0x7fffff0000000000);
962
963 try test_i128_intFromFloat_f128(-2.01, -2);
964 try test_i128_intFromFloat_f128(-2.0, -2);
965 try test_i128_intFromFloat_f128(-1.99, -1);
966 try test_i128_intFromFloat_f128(-1.0, -1);
967 try test_i128_intFromFloat_f128(-0.99, 0);
968 try test_i128_intFromFloat_f128(-0.5, 0);
969 try test_i128_intFromFloat_f128(-math.floatMin(f128), 0);
970 try test_i128_intFromFloat_f128(0.0, 0);
971 try test_i128_intFromFloat_f128(math.floatMin(f128), 0);
972 try test_i128_intFromFloat_f128(0.5, 0);
973 try test_i128_intFromFloat_f128(0.99, 0);
974 try test_i128_intFromFloat_f128(1.0, 1);
975 try test_i128_intFromFloat_f128(1.5, 1);
976 try test_i128_intFromFloat_f128(1.99, 1);
977 try test_i128_intFromFloat_f128(2.0, 2);
978 try test_i128_intFromFloat_f128(2.01, 2);
979
980 try test_i128_intFromFloat_f128(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
981 try test_i128_intFromFloat_f128(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
982
983 try test_i128_intFromFloat_f128(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
984 try test_i128_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
985 try test_i128_intFromFloat_f128(0x1.0000000000000p+63, 0x8000000000000000);
986 try test_i128_intFromFloat_f128(0x1.0000000000001p+63, 0x8000000000000800);
987
988 try test_i128_intFromFloat_f128(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
989 try test_i128_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
990 try test_i128_intFromFloat_f128(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
991
992 try test_i128_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
993 try test_i128_intFromFloat_f128(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
994
995 try test_i128_intFromFloat_f128(math.floatMax(f128), math.maxInt(i128));
996}
997
998test u128_intFromFloat_f128 {
999 try test_u128_intFromFloat_f128(math.inf(f128), 0xffffffffffffffffffffffffffffffff);
1000
1001 try test_u128_intFromFloat_f128(0.0, 0);
1002
1003 try test_u128_intFromFloat_f128(0.5, 0);
1004 try test_u128_intFromFloat_f128(0.99, 0);
1005 try test_u128_intFromFloat_f128(1.0, 1);
1006 try test_u128_intFromFloat_f128(1.5, 1);
1007 try test_u128_intFromFloat_f128(1.99, 1);
1008 try test_u128_intFromFloat_f128(2.0, 2);
1009 try test_u128_intFromFloat_f128(2.01, 2);
1010 try test_u128_intFromFloat_f128(-0.01, 0);
1011 try test_u128_intFromFloat_f128(-0.99, 0);
1012
1013 try test_u128_intFromFloat_f128(0x1p+128, 0xffffffffffffffffffffffffffffffff);
1014
1015 try test_u128_intFromFloat_f128(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
1016 try test_u128_intFromFloat_f128(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
1017 try test_u128_intFromFloat_f128(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
1018 try test_u128_intFromFloat_f128(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
1019}
1020
1021fn test_u128_intFromFloat_f16(a: f16, expected: u128) !void {
1022 const x = impl.u128_intFromFloat_f16(a);
1023 try testing.expect(x == expected);
1024}
1025
1026test u128_intFromFloat_f16 {
1027 try test_u128_intFromFloat_f16(math.inf(f16), math.maxInt(u128));
1028 try test_u128_intFromFloat_f16(math.floatMax(f16), 65504);
1029}
1030
1031fn test_u128_intFromFloat_f80(a: f80, expected: u128) !void {
1032 const x = impl.u128_intFromFloat_f80(a);
1033 try testing.expect(x == expected);
1034}
1035
1036test u128_intFromFloat_f80 {
1037 try test_u128_intFromFloat_f80(math.inf(f80), math.maxInt(u128));
1038 try test_u128_intFromFloat_f80(math.floatMax(f80), math.maxInt(u128));
1039 try test_u128_intFromFloat_f80(math.maxInt(u64), math.maxInt(u64));
1040}