HAXY

▀ ▄▄▄ ▀ ▀▀ ▄▀ ▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▄▀ ▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀ ▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▄▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▄▀ ▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀ ▄▄ ▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀ ▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀ ▄▀▀ ▀▀▀▀▀▀▀▀▀▀▄▀▄ ▄▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▄▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

╭ int_from_float_test.zig ──────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯

╭ find file ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╮ ╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╮ │ │ │http│ ssh │ │ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╯ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╯

1 const std = @import("std"); 2 const testing = std.testing; 3 const math = std.math; 4 5 const impl = @import("int_from_float.zig"); 6 7 const i32_intFromFloat_f16 = impl.i32_intFromFloat_f16; 8 const u32_intFromFloat_f16 = impl.u32_intFromFloat_f16; 9 const i64_intFromFloat_f16 = impl.i64_intFromFloat_f16; 10 const u64_intFromFloat_f16 = impl.u64_intFromFloat_f16; 11 const i128_intFromFloat_f16 = impl.i128_intFromFloat_f16; 12 const u128_intFromFloat_f16 = impl.u128_intFromFloat_f16; 13 const signed_intFromFloat_f16 = impl.signed_intFromFloat_f16; 14 const unsigned_intFromFloat_f16 = impl.unsigned_intFromFloat_f16; 15 16 const i32_intFromFloat_f32 = impl.i32_intFromFloat_f32; 17 const u32_intFromFloat_f32 = impl.u32_intFromFloat_f32; 18 const i64_intFromFloat_f32 = impl.i64_intFromFloat_f32; 19 const u64_intFromFloat_f32 = impl.u64_intFromFloat_f32; 20 const i128_intFromFloat_f32 = impl.i128_intFromFloat_f32; 21 const u128_intFromFloat_f32 = impl.u128_intFromFloat_f32; 22 const signed_intFromFloat_f32 = impl.signed_intFromFloat_f32; 23 const unsigned_intFromFloat_f32 = impl.unsigned_intFromFloat_f32; 24 25 const i32_intFromFloat_f64 = impl.i32_intFromFloat_f64; 26 const u32_intFromFloat_f64 = impl.u32_intFromFloat_f64; 27 const i64_intFromFloat_f64 = impl.i64_intFromFloat_f64; 28 const u64_intFromFloat_f64 = impl.u64_intFromFloat_f64; 29 const i128_intFromFloat_f64 = impl.i128_intFromFloat_f64; 30 const u128_intFromFloat_f64 = impl.u128_intFromFloat_f64; 31 const signed_intFromFloat_f64 = impl.signed_intFromFloat_f64; 32 const unsigned_intFromFloat_f64 = impl.unsigned_intFromFloat_f64; 33 34 const i32_intFromFloat_f80 = impl.i32_intFromFloat_f80; 35 const u32_intFromFloat_f80 = impl.u32_intFromFloat_f80; 36 const i64_intFromFloat_f80 = impl.i64_intFromFloat_f80; 37 const u64_intFromFloat_f80 = impl.u64_intFromFloat_f80; 38 const i128_intFromFloat_f80 = impl.i128_intFromFloat_f80; 39 const u128_intFromFloat_f80 = impl.u128_intFromFloat_f80; 40 const signed_intFromFloat_f80 = impl.signed_intFromFloat_f80; 41 const unsigned_intFromFloat_f80 = impl.unsigned_intFromFloat_f80; 42 43 const i32_intFromFloat_f128 = impl.i32_intFromFloat_f128; 44 const u32_intFromFloat_f128 = impl.u32_intFromFloat_f128; 45 const i64_intFromFloat_f128 = impl.i64_intFromFloat_f128; 46 const u64_intFromFloat_f128 = impl.u64_intFromFloat_f128; 47 const i128_intFromFloat_f128 = impl.i128_intFromFloat_f128; 48 const u128_intFromFloat_f128 = impl.u128_intFromFloat_f128; 49 const signed_intFromFloat_f128 = impl.signed_intFromFloat_f128; 50 const unsigned_intFromFloat_f128 = impl.unsigned_intFromFloat_f128; 51 52 fn test_i32_intFromFloat_f32(a: f32, expected: i32) !void { 53 const x = i32_intFromFloat_f32(a); 54 try testing.expect(x == expected); 55 } 56 57 fn test_u32_intFromFloat_f32(a: f32, expected: u32) !void { 58 const x = u32_intFromFloat_f32(a); 59 try testing.expect(x == expected); 60 } 61 62 test 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 126 test 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 155 fn test_i64_intFromFloat_f32(a: f32, expected: i64) !void { 156 const x = i64_intFromFloat_f32(a); 157 try testing.expect(x == expected); 158 } 159 160 fn test_u64_intFromFloat_f32(a: f32, expected: u64) !void { 161 const x = u64_intFromFloat_f32(a); 162 try testing.expect(x == expected); 163 } 164 165 test 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 220 test 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 248 fn test_i128_intFromFloat_f32(a: f32, expected: i128) !void { 249 const x = i128_intFromFloat_f32(a); 250 try testing.expect(x == expected); 251 } 252 253 fn test_u128_intFromFloat_f32(a: f32, expected: u128) !void { 254 const x = u128_intFromFloat_f32(a); 255 try testing.expect(x == expected); 256 } 257 258 test 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 329 test 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 365 fn 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 375 test 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 389 test 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 398 fn test_i32_intFromFloat_f64(a: f64, expected: i32) !void { 399 const x = i32_intFromFloat_f64(a); 400 try testing.expect(x == expected); 401 } 402 403 fn test_u32_intFromFloat_f64(a: f64, expected: u32) !void { 404 const x = u32_intFromFloat_f64(a); 405 try testing.expect(x == expected); 406 } 407 408 test 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 469 test 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 501 fn test_i64_intFromFloat_f64(a: f64, expected: i64) !void { 502 const x = i64_intFromFloat_f64(a); 503 try testing.expect(x == expected); 504 } 505 506 fn test_u64_intFromFloat_f64(a: f64, expected: u64) !void { 507 const x = u64_intFromFloat_f64(a); 508 try testing.expect(x == expected); 509 } 510 511 test 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 564 test 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 596 fn test_i128_intFromFloat_f64(a: f64, expected: i128) !void { 597 const x = i128_intFromFloat_f64(a); 598 try testing.expect(x == expected); 599 } 600 601 fn test_u128_intFromFloat_f64(a: f64, expected: u128) !void { 602 const x = u128_intFromFloat_f64(a); 603 try testing.expect(x == expected); 604 } 605 606 test 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 659 test 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 698 fn 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 708 test 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 724 test 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 734 fn test_i32_intFromFloat_f128(a: f128, expected: i32) !void { 735 const x = i32_intFromFloat_f128(a); 736 try testing.expect(x == expected); 737 } 738 739 fn test_u32_intFromFloat_f128(a: f128, expected: u32) !void { 740 const x = u32_intFromFloat_f128(a); 741 try testing.expect(x == expected); 742 } 743 744 test 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 807 test 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 820 fn test_i64_intFromFloat_f128(a: f128, expected: i64) !void { 821 const x = i64_intFromFloat_f128(a); 822 try testing.expect(x == expected); 823 } 824 825 fn test_u64_intFromFloat_f128(a: f128, expected: u64) !void { 826 const x = u64_intFromFloat_f128(a); 827 try testing.expect(x == expected); 828 } 829 830 test 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 893 test 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 935 fn test_i128_intFromFloat_f128(a: f128, expected: i128) !void { 936 const x = i128_intFromFloat_f128(a); 937 try testing.expect(x == expected); 938 } 939 940 fn test_u128_intFromFloat_f128(a: f128, expected: u128) !void { 941 const x = u128_intFromFloat_f128(a); 942 try testing.expect(x == expected); 943 } 944 945 test 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 998 test 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 1021 fn 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 1026 test 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 1031 fn 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 1036 test 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 } 1041