╭ float_from_int_test.zig ──────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯
🬂🬂🬒 🬂🬰🬂 🬑🬂🬀 ╭master╮ master xeubie: 🬋 🬋 🬃🬇🬋 │files │ commits refs discuss issues patches new login 🬯🬭🬭 🬭🬰🬭 🬟🬭🬑 ╰──────╯ (15882) user
╭ find file ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╮ ╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╮ │ │ │http│ ssh │ │ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╯ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╯
.. aarch64_outline_atomics.zig absv.zig absvdi2.zig absvdi2_test.zig absvsi2.zig absvsi2_test.zig absvti2.zig absvti2_test.zig addf3.zig addf3_test.zig addvdi3.zig addvsi3.zig arm.zig atomics.zig aulldiv.zig aullrem.zig bitreverse.zig bitreversedi2_test.zig bitreversesi2_test.zig bitreverseti2_test.zig bswap.zig bswapdi2_test.zig bswapsi2_test.zig bswapti2_test.zig clear_cache.zig clzdi2_test.zig clzsi2_test.zig clzti2_test.zig cmp.zig cmpdi2_test.zig cmpsi2_test.zig cmpti2_test.zig comparedf2_test.zig comparef.zig comparesf2_test.zig cos.zig count0bits.zig ctzdi2_test.zig ctzsi2_test.zig ctzti2_test.zig divc3.zig divc3_test.zig divdf3.zig divdf3_test.zig divmodei4.zig divsf3.zig divsf3_test.zig divtf3.zig divtf3_test.zig divti3_test.zig divxf3.zig divxf3_test.zig emutls.zig exp.zig exp2.zig exp_f128.zig extendf.zig extendf_test.zig fabs.zig ffsdi2_test.zig ffssi2_test.zig ffsti2_test.zig float_from_int.zig ╭─────────────────────────────────╮ │float_from_int_test.zig │ ╰─────────────────────────────────╯ floor_ceil.zig fma.zig fmax.zig fmin.zig fmod.zig fmodq_test.zig fmodx_test.zig hexagon.zig int.zig int_from_float.zig int_from_float_test.zig limb64.zig log.zig log10.zig log2.zig log_f128.zig memcpy.zig memmove.zig modti3_test.zig mulXi3.zig mulXi3_test.zig mulc3.zig mulc3_test.zig mulf3.zig mulf3_test.zig mulo.zig mulodi4_test.zig mulosi4_test.zig muloti4_test.zig mulvsi3.zig negdi2_test.zig negsi2_test.zig negti2_test.zig negv.zig negvdi2_test.zig negvsi2_test.zig negvti2_test.zig os_version_check.zig parity.zig paritydi2_test.zig paritysi2_test.zig parityti2_test.zig popcount.zig popcountdi2_test.zig popcountsi2_test.zig popcountti2_test.zig powiXf2.zig powiXf2_test.zig rem_pio2.zig rem_pio2_large.zig rem_pio2f.zig rem_pio2l.zig round.zig shift.zig shift_test.zig sin.zig sincos.zig sqrt.zig ssp.zig stack_probe.zig subvdi3.zig subvsi3.zig tan.zig trig.zig trunc.zig truncf.zig truncf_test.zig ucmpdi2_test.zig ucmpsi2_test.zig ucmpti2_test.zig udivmod.zig udivmoddi4_test.zig udivmodei4.zig udivmodsi4_test.zig udivmodti4_test.zig
1 const std = @import("std"); 2 const testing = std.testing; 3 const math = std.math; 4 5 const impl = @import("float_from_int.zig"); 6 7 const f16_floatFromInt_i32 = impl.f16_floatFromInt_i32; 8 const f16_floatFromInt_u32 = impl.f16_floatFromInt_u32; 9 const f16_floatFromInt_i64 = impl.f16_floatFromInt_i64; 10 const f16_floatFromInt_u64 = impl.f16_floatFromInt_u64; 11 const f16_floatFromInt_i128 = impl.f16_floatFromInt_i128; 12 const f16_floatFromInt_u128 = impl.f16_floatFromInt_u128; 13 const f16_floatFromInt_signed = impl.f16_floatFromInt_signed; 14 const f16_floatFromInt_unsigned = impl.f16_floatFromInt_unsigned; 15 16 const f32_floatFromInt_i32 = impl.f32_floatFromInt_i32; 17 const f32_floatFromInt_u32 = impl.f32_floatFromInt_u32; 18 const f32_floatFromInt_i64 = impl.f32_floatFromInt_i64; 19 const f32_floatFromInt_u64 = impl.f32_floatFromInt_u64; 20 const f32_floatFromInt_i128 = impl.f32_floatFromInt_i128; 21 const f32_floatFromInt_u128 = impl.f32_floatFromInt_u128; 22 const f32_floatFromInt_signed = impl.f32_floatFromInt_signed; 23 const f32_floatFromInt_unsigned = impl.f32_floatFromInt_unsigned; 24 25 const f64_floatFromInt_i32 = impl.f64_floatFromInt_i32; 26 const f64_floatFromInt_u32 = impl.f64_floatFromInt_u32; 27 const f64_floatFromInt_i64 = impl.f64_floatFromInt_i64; 28 const f64_floatFromInt_u64 = impl.f64_floatFromInt_u64; 29 const f64_floatFromInt_i128 = impl.f64_floatFromInt_i128; 30 const f64_floatFromInt_u128 = impl.f64_floatFromInt_u128; 31 const f64_floatFromInt_signed = impl.f64_floatFromInt_signed; 32 const f64_floatFromInt_unsigned = impl.f64_floatFromInt_unsigned; 33 34 const f80_floatFromInt_i32 = impl.f80_floatFromInt_i32; 35 const f80_floatFromInt_u32 = impl.f80_floatFromInt_u32; 36 const f80_floatFromInt_i64 = impl.f80_floatFromInt_i64; 37 const f80_floatFromInt_u64 = impl.f80_floatFromInt_u64; 38 const f80_floatFromInt_i128 = impl.f80_floatFromInt_i128; 39 const f80_floatFromInt_u128 = impl.f80_floatFromInt_u128; 40 const f80_floatFromInt_signed = impl.f80_floatFromInt_signed; 41 const f80_floatFromInt_unsigned = impl.f80_floatFromInt_unsigned; 42 43 const f128_floatFromInt_i32 = impl.f128_floatFromInt_i32; 44 const f128_floatFromInt_u32 = impl.f128_floatFromInt_u32; 45 const f128_floatFromInt_i64 = impl.f128_floatFromInt_i64; 46 const f128_floatFromInt_u64 = impl.f128_floatFromInt_u64; 47 const f128_floatFromInt_i128 = impl.f128_floatFromInt_i128; 48 const f128_floatFromInt_u128 = impl.f128_floatFromInt_u128; 49 const f128_floatFromInt_signed = impl.f128_floatFromInt_signed; 50 const f128_floatFromInt_unsigned = impl.f128_floatFromInt_unsigned; 51 52 fn test_f32_floatFromInt_i32(a: i32, expected: u32) !void { 53 const r = f32_floatFromInt_i32(a); 54 try std.testing.expect(@as(u32, @bitCast(r)) == expected); 55 } 56 57 fn test_f32_floatFromInt_u32(a: u32, expected: u32) !void { 58 const r = f32_floatFromInt_u32(a); 59 try std.testing.expect(@as(u32, @bitCast(r)) == expected); 60 } 61 62 test f32_floatFromInt_i32 { 63 try test_f32_floatFromInt_i32(0, 0x00000000); 64 try test_f32_floatFromInt_i32(1, 0x3f800000); 65 try test_f32_floatFromInt_i32(-1, 0xbf800000); 66 try test_f32_floatFromInt_i32(0x7FFFFFFF, 0x4f000000); 67 try test_f32_floatFromInt_i32(@bitCast(@as(u32, @intCast(0x80000000))), 0xcf000000); 68 69 try testing.expect(f32_floatFromInt_i32(math.minInt(i32)) == math.minInt(i32)); 70 } 71 72 test f32_floatFromInt_u32 { 73 // Test the produced bit pattern 74 try test_f32_floatFromInt_u32(0, 0); 75 try test_f32_floatFromInt_u32(1, 0x3f800000); 76 try test_f32_floatFromInt_u32(0x7FFFFFFF, 0x4f000000); 77 try test_f32_floatFromInt_u32(0x80000000, 0x4f000000); 78 try test_f32_floatFromInt_u32(0xFFFFFFFF, 0x4f800000); 79 80 try testing.expect(f32_floatFromInt_u32(0) == 0.0); 81 try testing.expect(f32_floatFromInt_u32(math.maxInt(u24)) == math.maxInt(u24)); 82 try testing.expect(f32_floatFromInt_u32(math.maxInt(u24) + 1) == math.maxInt(u24) + 1); // 0x100_0000 - Exact 83 try testing.expect(f32_floatFromInt_u32(math.maxInt(u24) + 2) == math.maxInt(u24) + 1); // 0x100_0001 - Tie: Rounds down to even 84 try testing.expect(f32_floatFromInt_u32(math.maxInt(u24) + 3) == math.maxInt(u24) + 3); // 0x100_0002 - Exact 85 try testing.expect(f32_floatFromInt_u32(math.maxInt(u24) + 4) == math.maxInt(u24) + 5); // 0x100_0003 - Tie: Rounds up to even 86 try testing.expect(f32_floatFromInt_u32(math.maxInt(u24) + 5) == math.maxInt(u24) + 5); // 0x100_0004 - Exact 87 try testing.expect(f32_floatFromInt_u32(math.maxInt(u32)) == math.maxInt(u32) + 1); 88 } 89 90 fn test_f32_floatFromInt_i64(a: i64, expected: f32) !void { 91 const x = f32_floatFromInt_i64(a); 92 try testing.expect(x == expected); 93 } 94 95 fn test_f32_floatFromInt_u64(a: u64, expected: f32) !void { 96 const x = f32_floatFromInt_u64(a); 97 try testing.expect(x == expected); 98 } 99 100 test f32_floatFromInt_i64 { 101 try test_f32_floatFromInt_i64(0, 0.0); 102 try test_f32_floatFromInt_i64(1, 1.0); 103 try test_f32_floatFromInt_i64(2, 2.0); 104 try test_f32_floatFromInt_i64(-1, -1.0); 105 try test_f32_floatFromInt_i64(-2, -2.0); 106 try test_f32_floatFromInt_i64(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 107 try test_f32_floatFromInt_i64(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 108 try test_f32_floatFromInt_i64(@bitCast(@as(u64, 0x8000008000000000)), -0x1.FFFFFEp+62); 109 try test_f32_floatFromInt_i64(@bitCast(@as(u64, 0x8000010000000000)), -0x1.FFFFFCp+62); 110 try test_f32_floatFromInt_i64(@bitCast(@as(u64, 0x8000000000000000)), -0x1.000000p+63); 111 try test_f32_floatFromInt_i64(@bitCast(@as(u64, 0x8000000000000001)), -0x1.000000p+63); 112 try test_f32_floatFromInt_i64(0x0007FB72E8000000, 0x1.FEDCBAp+50); 113 try test_f32_floatFromInt_i64(0x0007FB72EA000000, 0x1.FEDCBAp+50); 114 try test_f32_floatFromInt_i64(0x0007FB72EB000000, 0x1.FEDCBAp+50); 115 try test_f32_floatFromInt_i64(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 116 try test_f32_floatFromInt_i64(0x0007FB72EC000000, 0x1.FEDCBCp+50); 117 try test_f32_floatFromInt_i64(0x0007FB72E8000001, 0x1.FEDCBAp+50); 118 try test_f32_floatFromInt_i64(0x0007FB72E6000000, 0x1.FEDCBAp+50); 119 try test_f32_floatFromInt_i64(0x0007FB72E7000000, 0x1.FEDCBAp+50); 120 try test_f32_floatFromInt_i64(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 121 try test_f32_floatFromInt_i64(0x0007FB72E4000001, 0x1.FEDCBAp+50); 122 try test_f32_floatFromInt_i64(0x0007FB72E4000000, 0x1.FEDCB8p+50); 123 } 124 125 test f32_floatFromInt_u64 { 126 try test_f32_floatFromInt_u64(0, 0.0); 127 try test_f32_floatFromInt_u64(1, 1.0); 128 try test_f32_floatFromInt_u64(2, 2.0); 129 try test_f32_floatFromInt_u64(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 130 try test_f32_floatFromInt_u64(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 131 try test_f32_floatFromInt_u64(0x8000008000000000, 0x1p+63); 132 try test_f32_floatFromInt_u64(0x8000010000000000, 0x1.000002p+63); 133 try test_f32_floatFromInt_u64(0x8000000000000000, 0x1p+63); 134 try test_f32_floatFromInt_u64(0x8000000000000001, 0x1p+63); 135 try test_f32_floatFromInt_u64(0xFFFFFFFFFFFFFFFE, 0x1p+64); 136 try test_f32_floatFromInt_u64(0xFFFFFFFFFFFFFFFF, 0x1p+64); 137 try test_f32_floatFromInt_u64(0x0007FB72E8000000, 0x1.FEDCBAp+50); 138 try test_f32_floatFromInt_u64(0x0007FB72EA000000, 0x1.FEDCBAp+50); 139 try test_f32_floatFromInt_u64(0x0007FB72EB000000, 0x1.FEDCBAp+50); 140 try test_f32_floatFromInt_u64(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 141 try test_f32_floatFromInt_u64(0x0007FB72EC000000, 0x1.FEDCBCp+50); 142 try test_f32_floatFromInt_u64(0x0007FB72E8000001, 0x1.FEDCBAp+50); 143 try test_f32_floatFromInt_u64(0x0007FB72E6000000, 0x1.FEDCBAp+50); 144 try test_f32_floatFromInt_u64(0x0007FB72E7000000, 0x1.FEDCBAp+50); 145 try test_f32_floatFromInt_u64(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 146 try test_f32_floatFromInt_u64(0x0007FB72E4000001, 0x1.FEDCBAp+50); 147 try test_f32_floatFromInt_u64(0x0007FB72E4000000, 0x1.FEDCB8p+50); 148 } 149 150 fn test_f32_floatFromInt_i128(a: i128, expected: f32) !void { 151 const x = f32_floatFromInt_i128(a); 152 try testing.expect(x == expected); 153 } 154 155 fn test_f32_floatFromInt_u128(a: u128, expected: f32) !void { 156 const x = f32_floatFromInt_u128(a); 157 try testing.expect(x == expected); 158 } 159 160 test f32_floatFromInt_i128 { 161 try test_f32_floatFromInt_i128(0, 0.0); 162 163 try test_f32_floatFromInt_i128(1, 1.0); 164 try test_f32_floatFromInt_i128(2, 2.0); 165 try test_f32_floatFromInt_i128(-1, -1.0); 166 try test_f32_floatFromInt_i128(-2, -2.0); 167 168 try test_f32_floatFromInt_i128(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 169 try test_f32_floatFromInt_i128(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 170 171 try test_f32_floatFromInt_i128(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62); 172 try test_f32_floatFromInt_i128(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62); 173 174 try test_f32_floatFromInt_i128(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63); 175 try test_f32_floatFromInt_i128(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63); 176 177 try test_f32_floatFromInt_i128(0x0007FB72E8000000, 0x1.FEDCBAp+50); 178 179 try test_f32_floatFromInt_i128(0x0007FB72EA000000, 0x1.FEDCBAp+50); 180 try test_f32_floatFromInt_i128(0x0007FB72EB000000, 0x1.FEDCBAp+50); 181 try test_f32_floatFromInt_i128(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 182 try test_f32_floatFromInt_i128(0x0007FB72EC000000, 0x1.FEDCBCp+50); 183 try test_f32_floatFromInt_i128(0x0007FB72E8000001, 0x1.FEDCBAp+50); 184 185 try test_f32_floatFromInt_i128(0x0007FB72E6000000, 0x1.FEDCBAp+50); 186 try test_f32_floatFromInt_i128(0x0007FB72E7000000, 0x1.FEDCBAp+50); 187 try test_f32_floatFromInt_i128(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 188 try test_f32_floatFromInt_i128(0x0007FB72E4000001, 0x1.FEDCBAp+50); 189 try test_f32_floatFromInt_i128(0x0007FB72E4000000, 0x1.FEDCB8p+50); 190 191 try test_f32_floatFromInt_i128(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114); 192 193 try test_f32_floatFromInt_i128(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114); 194 try test_f32_floatFromInt_i128(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114); 195 try test_f32_floatFromInt_i128(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114); 196 try test_f32_floatFromInt_i128(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114); 197 try test_f32_floatFromInt_i128(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114); 198 199 try test_f32_floatFromInt_i128(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114); 200 try test_f32_floatFromInt_i128(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114); 201 try test_f32_floatFromInt_i128(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114); 202 try test_f32_floatFromInt_i128(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114); 203 try test_f32_floatFromInt_i128(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114); 204 } 205 206 test f32_floatFromInt_u128 { 207 try test_f32_floatFromInt_u128(0, 0.0); 208 209 try test_f32_floatFromInt_u128(1, 1.0); 210 try test_f32_floatFromInt_u128(2, 2.0); 211 try test_f32_floatFromInt_u128(20, 20.0); 212 213 try test_f32_floatFromInt_u128(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 214 try test_f32_floatFromInt_u128(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 215 216 try test_f32_floatFromInt_u128(make_uti(0x8000008000000000, 0), 0x1.000001p+127); 217 try test_f32_floatFromInt_u128(make_uti(0x8000000000000800, 0), 0x1.0p+127); 218 try test_f32_floatFromInt_u128(make_uti(0x8000010000000000, 0), 0x1.000002p+127); 219 220 try test_f32_floatFromInt_u128(make_uti(0x8000000000000000, 0), 0x1.000000p+127); 221 222 try test_f32_floatFromInt_u128(0x0007FB72E8000000, 0x1.FEDCBAp+50); 223 224 try test_f32_floatFromInt_u128(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 225 try test_f32_floatFromInt_u128(0x0007FB72EB000000, 0x1.FEDCBACp+50); 226 227 try test_f32_floatFromInt_u128(0x0007FB72EC000000, 0x1.FEDCBBp+50); 228 229 try test_f32_floatFromInt_u128(0x0007FB72E6000000, 0x1.FEDCB98p+50); 230 try test_f32_floatFromInt_u128(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 231 try test_f32_floatFromInt_u128(0x0007FB72E4000000, 0x1.FEDCB9p+50); 232 233 try test_f32_floatFromInt_u128(0xFFFFFFFFFFFFFFFE, 0x1p+64); 234 try test_f32_floatFromInt_u128(0xFFFFFFFFFFFFFFFF, 0x1p+64); 235 236 try test_f32_floatFromInt_u128(0x0007FB72E8000000, 0x1.FEDCBAp+50); 237 238 try test_f32_floatFromInt_u128(0x0007FB72EA000000, 0x1.FEDCBAp+50); 239 try test_f32_floatFromInt_u128(0x0007FB72EB000000, 0x1.FEDCBAp+50); 240 try test_f32_floatFromInt_u128(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 241 try test_f32_floatFromInt_u128(0x0007FB72EC000000, 0x1.FEDCBCp+50); 242 try test_f32_floatFromInt_u128(0x0007FB72E8000001, 0x1.FEDCBAp+50); 243 244 try test_f32_floatFromInt_u128(0x0007FB72E6000000, 0x1.FEDCBAp+50); 245 try test_f32_floatFromInt_u128(0x0007FB72E7000000, 0x1.FEDCBAp+50); 246 try test_f32_floatFromInt_u128(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 247 try test_f32_floatFromInt_u128(0x0007FB72E4000001, 0x1.FEDCBAp+50); 248 try test_f32_floatFromInt_u128(0x0007FB72E4000000, 0x1.FEDCB8p+50); 249 250 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76); 251 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76); 252 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76); 253 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76); 254 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76); 255 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76); 256 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76); 257 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76); 258 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76); 259 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76); 260 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76); 261 try test_f32_floatFromInt_u128(make_uti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76); 262 263 // Test overflow to infinity 264 try test_f32_floatFromInt_u128(math.maxInt(u128), @bitCast(math.inf(f32))); 265 } 266 267 fn test_f32_floatFromInt(expected: u32, comptime T: type, a: T) !void { 268 const int = @typeInfo(T).int; 269 const r = switch (int.signedness) { 270 .signed => f32_floatFromInt_signed, 271 .unsigned => f32_floatFromInt_unsigned, 272 }(@ptrCast(&a)); 273 try testing.expect(expected == @as(u32, @bitCast(r))); 274 } 275 276 test f32_floatFromInt_signed { 277 try test_f32_floatFromInt(0xFF000000, i256, -1 << 127); 278 try test_f32_floatFromInt(0xFF000000, i256, -math.maxInt(u127)); 279 try test_f32_floatFromInt(0xDF012347, i256, -0x8123468100000000); 280 try test_f32_floatFromInt(0xDF012347, i256, -0x8123468000000001); 281 try test_f32_floatFromInt(0xDF012346, i256, -0x8123468000000000); 282 try test_f32_floatFromInt(0xDF012346, i256, -0x8123458100000000); 283 try test_f32_floatFromInt(0xDF012346, i256, -0x8123458000000001); 284 try test_f32_floatFromInt(0xDF012346, i256, -0x8123458000000000); 285 try test_f32_floatFromInt(0xDF012345, i256, -0x8123456789ABCDEF); 286 try test_f32_floatFromInt(0xBF800000, i256, -1); 287 try test_f32_floatFromInt(0x00000000, i256, 0); 288 try test_f32_floatFromInt(0x5F012345, i256, 0x8123456789ABCDEF); 289 try test_f32_floatFromInt(0x5F012346, i256, 0x8123458000000000); 290 try test_f32_floatFromInt(0x5F012346, i256, 0x8123458000000001); 291 try test_f32_floatFromInt(0x5F012346, i256, 0x8123458100000000); 292 try test_f32_floatFromInt(0x5F012346, i256, 0x8123468000000000); 293 try test_f32_floatFromInt(0x5F012347, i256, 0x8123468000000001); 294 try test_f32_floatFromInt(0x5F012347, i256, 0x8123468100000000); 295 try test_f32_floatFromInt(0x7F000000, i256, math.maxInt(u127)); 296 try test_f32_floatFromInt(0x7F000000, i256, 1 << 127); 297 } 298 299 test f32_floatFromInt_unsigned { 300 try test_f32_floatFromInt(0x00000000, u256, 0); 301 try test_f32_floatFromInt(0x5F012345, u256, 0x8123456789ABCDEF); 302 try test_f32_floatFromInt(0x5F012346, u256, 0x8123458000000000); 303 try test_f32_floatFromInt(0x5F012346, u256, 0x8123458000000001); 304 try test_f32_floatFromInt(0x5F012346, u256, 0x8123458080000000); 305 try test_f32_floatFromInt(0x5F012346, u256, 0x8123468000000000); 306 try test_f32_floatFromInt(0x5F012347, u256, 0x8123468000000001); 307 try test_f32_floatFromInt(0x5F012347, u256, 0x8123468080000000); 308 try test_f32_floatFromInt(0x7F000000, u256, math.maxInt(u127)); 309 try test_f32_floatFromInt(0x7F000000, u256, 1 << 127); 310 try test_f32_floatFromInt(0x7F800000, u256, math.maxInt(u256)); 311 } 312 313 fn test_f64_floatFromInt_i32(a: i32, expected: u64) !void { 314 const r = f64_floatFromInt_i32(a); 315 try std.testing.expect(@as(u64, @bitCast(r)) == expected); 316 } 317 318 fn test_f64_floatFromInt_u32(a: u32, expected: u64) !void { 319 const r = f64_floatFromInt_u32(a); 320 try std.testing.expect(@as(u64, @bitCast(r)) == expected); 321 } 322 323 test f64_floatFromInt_i32 { 324 try test_f64_floatFromInt_i32(0, 0x0000000000000000); 325 try test_f64_floatFromInt_i32(1, 0x3ff0000000000000); 326 try test_f64_floatFromInt_i32(-1, 0xbff0000000000000); 327 try test_f64_floatFromInt_i32(0x7FFFFFFF, 0x41dfffffffc00000); 328 try test_f64_floatFromInt_i32(@bitCast(@as(u32, @intCast(0x80000000))), 0xc1e0000000000000); 329 } 330 331 test f64_floatFromInt_u32 { 332 try test_f64_floatFromInt_u32(0, 0x0000000000000000); 333 try test_f64_floatFromInt_u32(1, 0x3ff0000000000000); 334 try test_f64_floatFromInt_u32(0x7FFFFFFF, 0x41dfffffffc00000); 335 try test_f64_floatFromInt_u32(@intCast(0x80000000), 0x41e0000000000000); 336 try test_f64_floatFromInt_u32(@intCast(0xFFFFFFFF), 0x41efffffffe00000); 337 } 338 339 fn test_f64_floatFromInt_i64(a: i64, expected: f64) !void { 340 const r = f64_floatFromInt_i64(a); 341 try testing.expect(r == expected); 342 } 343 344 fn test_f64_floatFromInt_u64(a: u64, expected: f64) !void { 345 const r = f64_floatFromInt_u64(a); 346 try testing.expect(r == expected); 347 } 348 349 test f64_floatFromInt_i64 { 350 try test_f64_floatFromInt_i64(0, 0.0); 351 try test_f64_floatFromInt_i64(1, 1.0); 352 try test_f64_floatFromInt_i64(2, 2.0); 353 try test_f64_floatFromInt_i64(20, 20.0); 354 try test_f64_floatFromInt_i64(-1, -1.0); 355 try test_f64_floatFromInt_i64(-2, -2.0); 356 try test_f64_floatFromInt_i64(-20, -20.0); 357 try test_f64_floatFromInt_i64(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 358 try test_f64_floatFromInt_i64(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 359 try test_f64_floatFromInt_i64(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 360 try test_f64_floatFromInt_i64(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 361 try test_f64_floatFromInt_i64(@bitCast(@as(u64, @intCast(0x8000008000000000))), -0x1.FFFFFEp+62); 362 try test_f64_floatFromInt_i64(@bitCast(@as(u64, @intCast(0x8000000000000800))), -0x1.FFFFFFFFFFFFEp+62); 363 try test_f64_floatFromInt_i64(@bitCast(@as(u64, @intCast(0x8000010000000000))), -0x1.FFFFFCp+62); 364 try test_f64_floatFromInt_i64(@bitCast(@as(u64, @intCast(0x8000000000001000))), -0x1.FFFFFFFFFFFFCp+62); 365 try test_f64_floatFromInt_i64(@bitCast(@as(u64, @intCast(0x8000000000000000))), -0x1.000000p+63); 366 try test_f64_floatFromInt_i64(@bitCast(@as(u64, @intCast(0x8000000000000001))), -0x1.000000p+63); // 0x8000000000000001 367 try test_f64_floatFromInt_i64(0x0007FB72E8000000, 0x1.FEDCBAp+50); 368 try test_f64_floatFromInt_i64(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 369 try test_f64_floatFromInt_i64(0x0007FB72EB000000, 0x1.FEDCBACp+50); 370 try test_f64_floatFromInt_i64(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 371 try test_f64_floatFromInt_i64(0x0007FB72EC000000, 0x1.FEDCBBp+50); 372 try test_f64_floatFromInt_i64(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 373 try test_f64_floatFromInt_i64(0x0007FB72E6000000, 0x1.FEDCB98p+50); 374 try test_f64_floatFromInt_i64(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 375 try test_f64_floatFromInt_i64(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 376 try test_f64_floatFromInt_i64(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 377 try test_f64_floatFromInt_i64(0x0007FB72E4000000, 0x1.FEDCB9p+50); 378 try test_f64_floatFromInt_i64(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 379 try test_f64_floatFromInt_i64(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 380 try test_f64_floatFromInt_i64(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 381 try test_f64_floatFromInt_i64(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 382 try test_f64_floatFromInt_i64(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 383 try test_f64_floatFromInt_i64(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 384 try test_f64_floatFromInt_i64(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 385 try test_f64_floatFromInt_i64(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 386 try test_f64_floatFromInt_i64(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 387 try test_f64_floatFromInt_i64(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 388 try test_f64_floatFromInt_i64(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 389 try test_f64_floatFromInt_i64(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 390 try test_f64_floatFromInt_i64(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 391 try test_f64_floatFromInt_i64(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 392 try test_f64_floatFromInt_i64(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 393 } 394 395 test f64_floatFromInt_u64 { 396 try test_f64_floatFromInt_u64(0, 0.0); 397 try test_f64_floatFromInt_u64(1, 1.0); 398 try test_f64_floatFromInt_u64(2, 2.0); 399 try test_f64_floatFromInt_u64(20, 20.0); 400 try test_f64_floatFromInt_u64(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 401 try test_f64_floatFromInt_u64(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 402 try test_f64_floatFromInt_u64(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 403 try test_f64_floatFromInt_u64(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 404 try test_f64_floatFromInt_u64(0x8000008000000000, 0x1.000001p+63); 405 try test_f64_floatFromInt_u64(0x8000000000000800, 0x1.0000000000001p+63); 406 try test_f64_floatFromInt_u64(0x8000010000000000, 0x1.000002p+63); 407 try test_f64_floatFromInt_u64(0x8000000000001000, 0x1.0000000000002p+63); 408 try test_f64_floatFromInt_u64(0x8000000000000000, 0x1p+63); 409 try test_f64_floatFromInt_u64(0x8000000000000001, 0x1p+63); 410 try test_f64_floatFromInt_u64(0x0007FB72E8000000, 0x1.FEDCBAp+50); 411 try test_f64_floatFromInt_u64(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 412 try test_f64_floatFromInt_u64(0x0007FB72EB000000, 0x1.FEDCBACp+50); 413 try test_f64_floatFromInt_u64(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 414 try test_f64_floatFromInt_u64(0x0007FB72EC000000, 0x1.FEDCBBp+50); 415 try test_f64_floatFromInt_u64(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 416 try test_f64_floatFromInt_u64(0x0007FB72E6000000, 0x1.FEDCB98p+50); 417 try test_f64_floatFromInt_u64(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 418 try test_f64_floatFromInt_u64(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 419 try test_f64_floatFromInt_u64(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 420 try test_f64_floatFromInt_u64(0x0007FB72E4000000, 0x1.FEDCB9p+50); 421 try test_f64_floatFromInt_u64(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 422 try test_f64_floatFromInt_u64(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 423 try test_f64_floatFromInt_u64(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 424 try test_f64_floatFromInt_u64(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 425 try test_f64_floatFromInt_u64(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 426 try test_f64_floatFromInt_u64(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 427 try test_f64_floatFromInt_u64(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 428 try test_f64_floatFromInt_u64(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 429 try test_f64_floatFromInt_u64(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 430 try test_f64_floatFromInt_u64(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 431 try test_f64_floatFromInt_u64(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 432 try test_f64_floatFromInt_u64(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 433 try test_f64_floatFromInt_u64(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 434 try test_f64_floatFromInt_u64(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 435 try test_f64_floatFromInt_u64(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 436 } 437 438 fn test_f64_floatFromInt_i128(a: i128, expected: f64) !void { 439 const x = f64_floatFromInt_i128(a); 440 try testing.expect(x == expected); 441 } 442 443 fn test_f64_floatFromInt_u128(a: u128, expected: f64) !void { 444 const x = f64_floatFromInt_u128(a); 445 try testing.expect(x == expected); 446 } 447 448 test f64_floatFromInt_i128 { 449 try test_f64_floatFromInt_i128(0, 0.0); 450 451 try test_f64_floatFromInt_i128(1, 1.0); 452 try test_f64_floatFromInt_i128(2, 2.0); 453 try test_f64_floatFromInt_i128(20, 20.0); 454 try test_f64_floatFromInt_i128(-1, -1.0); 455 try test_f64_floatFromInt_i128(-2, -2.0); 456 try test_f64_floatFromInt_i128(-20, -20.0); 457 458 try test_f64_floatFromInt_i128(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 459 try test_f64_floatFromInt_i128(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 460 try test_f64_floatFromInt_i128(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 461 try test_f64_floatFromInt_i128(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 462 463 try test_f64_floatFromInt_i128(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); 464 try test_f64_floatFromInt_i128(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); 465 try test_f64_floatFromInt_i128(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); 466 try test_f64_floatFromInt_i128(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); 467 468 try test_f64_floatFromInt_i128(make_ti(0x8000000000000000, 0), -0x1.000000p+127); 469 try test_f64_floatFromInt_i128(make_ti(0x8000000000000001, 0), -0x1.000000p+127); 470 471 try test_f64_floatFromInt_i128(0x0007FB72E8000000, 0x1.FEDCBAp+50); 472 473 try test_f64_floatFromInt_i128(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 474 try test_f64_floatFromInt_i128(0x0007FB72EB000000, 0x1.FEDCBACp+50); 475 try test_f64_floatFromInt_i128(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 476 try test_f64_floatFromInt_i128(0x0007FB72EC000000, 0x1.FEDCBBp+50); 477 try test_f64_floatFromInt_i128(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 478 479 try test_f64_floatFromInt_i128(0x0007FB72E6000000, 0x1.FEDCB98p+50); 480 try test_f64_floatFromInt_i128(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 481 try test_f64_floatFromInt_i128(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 482 try test_f64_floatFromInt_i128(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 483 try test_f64_floatFromInt_i128(0x0007FB72E4000000, 0x1.FEDCB9p+50); 484 485 try test_f64_floatFromInt_i128(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 486 try test_f64_floatFromInt_i128(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 487 try test_f64_floatFromInt_i128(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 488 try test_f64_floatFromInt_i128(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 489 try test_f64_floatFromInt_i128(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 490 try test_f64_floatFromInt_i128(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 491 try test_f64_floatFromInt_i128(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 492 try test_f64_floatFromInt_i128(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 493 try test_f64_floatFromInt_i128(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 494 try test_f64_floatFromInt_i128(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 495 try test_f64_floatFromInt_i128(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 496 try test_f64_floatFromInt_i128(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 497 try test_f64_floatFromInt_i128(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 498 try test_f64_floatFromInt_i128(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 499 try test_f64_floatFromInt_i128(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 500 501 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 502 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); 503 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); 504 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); 505 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); 506 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); 507 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); 508 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); 509 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); 510 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); 511 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); 512 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); 513 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); 514 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); 515 try test_f64_floatFromInt_i128(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 516 } 517 518 test f64_floatFromInt_u128 { 519 try test_f64_floatFromInt_u128(0, 0.0); 520 521 try test_f64_floatFromInt_u128(1, 1.0); 522 try test_f64_floatFromInt_u128(2, 2.0); 523 try test_f64_floatFromInt_u128(20, 20.0); 524 525 try test_f64_floatFromInt_u128(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 526 try test_f64_floatFromInt_u128(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 527 try test_f64_floatFromInt_u128(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 528 try test_f64_floatFromInt_u128(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 529 530 try test_f64_floatFromInt_u128(make_uti(0x8000008000000000, 0), 0x1.000001p+127); 531 try test_f64_floatFromInt_u128(make_uti(0x8000000000000800, 0), 0x1.0000000000001p+127); 532 try test_f64_floatFromInt_u128(make_uti(0x8000010000000000, 0), 0x1.000002p+127); 533 try test_f64_floatFromInt_u128(make_uti(0x8000000000001000, 0), 0x1.0000000000002p+127); 534 535 try test_f64_floatFromInt_u128(make_uti(0x8000000000000000, 0), 0x1.000000p+127); 536 try test_f64_floatFromInt_u128(make_uti(0x8000000000000001, 0), 0x1.0000000000000002p+127); 537 538 try test_f64_floatFromInt_u128(0x0007FB72E8000000, 0x1.FEDCBAp+50); 539 540 try test_f64_floatFromInt_u128(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 541 try test_f64_floatFromInt_u128(0x0007FB72EB000000, 0x1.FEDCBACp+50); 542 try test_f64_floatFromInt_u128(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 543 try test_f64_floatFromInt_u128(0x0007FB72EC000000, 0x1.FEDCBBp+50); 544 try test_f64_floatFromInt_u128(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 545 546 try test_f64_floatFromInt_u128(0x0007FB72E6000000, 0x1.FEDCB98p+50); 547 try test_f64_floatFromInt_u128(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 548 try test_f64_floatFromInt_u128(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 549 try test_f64_floatFromInt_u128(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 550 try test_f64_floatFromInt_u128(0x0007FB72E4000000, 0x1.FEDCB9p+50); 551 552 try test_f64_floatFromInt_u128(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 553 try test_f64_floatFromInt_u128(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 554 try test_f64_floatFromInt_u128(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 555 try test_f64_floatFromInt_u128(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 556 try test_f64_floatFromInt_u128(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 557 try test_f64_floatFromInt_u128(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 558 try test_f64_floatFromInt_u128(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 559 try test_f64_floatFromInt_u128(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 560 try test_f64_floatFromInt_u128(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 561 try test_f64_floatFromInt_u128(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 562 try test_f64_floatFromInt_u128(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 563 try test_f64_floatFromInt_u128(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 564 try test_f64_floatFromInt_u128(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 565 try test_f64_floatFromInt_u128(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 566 try test_f64_floatFromInt_u128(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 567 568 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 569 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); 570 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); 571 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); 572 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); 573 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); 574 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); 575 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); 576 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); 577 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); 578 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); 579 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); 580 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); 581 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); 582 try test_f64_floatFromInt_u128(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 583 } 584 585 fn test_f128_floatFromInt_i32(a: i32, expected: u128) !void { 586 const r = f128_floatFromInt_i32(a); 587 try std.testing.expect(@as(u128, @bitCast(r)) == expected); 588 } 589 590 fn test_f128_floatFromInt_u32(a: u32, expected_hi: u64, expected_lo: u64) !void { 591 const x = f128_floatFromInt_u32(a); 592 593 const x_repr: u128 = @bitCast(x); 594 const x_hi: u64 = @intCast(x_repr >> 64); 595 const x_lo: u64 = @truncate(x_repr); 596 597 if (x_hi == expected_hi and x_lo == expected_lo) { 598 return; 599 } 600 // nan repr 601 else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { 602 if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { 603 return; 604 } 605 } 606 return error.TestFailure; 607 } 608 609 test f128_floatFromInt_i32 { 610 try test_f128_floatFromInt_i32(0, 0); 611 try test_f128_floatFromInt_i32(0x7FFFFFFF, 0x401dfffffffc00000000000000000000); 612 try test_f128_floatFromInt_i32(0x12345678, 0x401b2345678000000000000000000000); 613 try test_f128_floatFromInt_i32(-0x12345678, 0xc01b2345678000000000000000000000); 614 try test_f128_floatFromInt_i32(@bitCast(@as(u32, @intCast(0xffffffff))), 0xbfff0000000000000000000000000000); 615 try test_f128_floatFromInt_i32(@bitCast(@as(u32, @intCast(0x80000000))), 0xc01e0000000000000000000000000000); 616 } 617 618 test f128_floatFromInt_u32 { 619 try test_f128_floatFromInt_u32(0x7fffffff, 0x401dfffffffc0000, 0x0); 620 try test_f128_floatFromInt_u32(0, 0x0, 0x0); 621 try test_f128_floatFromInt_u32(0xffffffff, 0x401efffffffe0000, 0x0); 622 try test_f128_floatFromInt_u32(0x12345678, 0x401b234567800000, 0x0); 623 } 624 625 fn test_f128_floatFromInt_i64(a: i64, expected: f128) !void { 626 const x = f128_floatFromInt_i64(a); 627 try testing.expect(x == expected); 628 } 629 630 fn test_f128_floatFromInt_u64(a: u64, expected_hi: u64, expected_lo: u64) !void { 631 const x = f128_floatFromInt_u64(a); 632 633 const x_repr: u128 = @bitCast(x); 634 const x_hi: u64 = @intCast(x_repr >> 64); 635 const x_lo: u64 = @truncate(x_repr); 636 637 if (x_hi == expected_hi and x_lo == expected_lo) { 638 return; 639 } 640 // nan repr 641 else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { 642 if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { 643 return; 644 } 645 } 646 return error.TestFailure; 647 } 648 649 test f128_floatFromInt_i64 { 650 try test_f128_floatFromInt_i64(0x7fffffffffffffff, make_tf(0x403dffffffffffff, 0xfffc000000000000)); 651 try test_f128_floatFromInt_i64(0x123456789abcdef1, make_tf(0x403b23456789abcd, 0xef10000000000000)); 652 try test_f128_floatFromInt_i64(0x2, make_tf(0x4000000000000000, 0x0)); 653 try test_f128_floatFromInt_i64(0x1, make_tf(0x3fff000000000000, 0x0)); 654 try test_f128_floatFromInt_i64(0x0, make_tf(0x0, 0x0)); 655 try test_f128_floatFromInt_i64(@bitCast(@as(u64, 0xffffffffffffffff)), make_tf(0xbfff000000000000, 0x0)); 656 try test_f128_floatFromInt_i64(@bitCast(@as(u64, 0xfffffffffffffffe)), make_tf(0xc000000000000000, 0x0)); 657 try test_f128_floatFromInt_i64(-0x123456789abcdef1, make_tf(0xc03b23456789abcd, 0xef10000000000000)); 658 try test_f128_floatFromInt_i64(@bitCast(@as(u64, 0x8000000000000000)), make_tf(0xc03e000000000000, 0x0)); 659 } 660 661 test f128_floatFromInt_u64 { 662 try test_f128_floatFromInt_u64(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000); 663 try test_f128_floatFromInt_u64(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000); 664 try test_f128_floatFromInt_u64(0x8000000000000000, 0x403e000000000000, 0x0); 665 try test_f128_floatFromInt_u64(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000); 666 try test_f128_floatFromInt_u64(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000); 667 try test_f128_floatFromInt_u64(0x2, 0x4000000000000000, 0x0); 668 try test_f128_floatFromInt_u64(0x1, 0x3fff000000000000, 0x0); 669 try test_f128_floatFromInt_u64(0x0, 0x0, 0x0); 670 } 671 672 fn test_f128_floatFromInt_i128(a: i128, expected: f128) !void { 673 const x = f128_floatFromInt_i128(a); 674 try testing.expect(x == expected); 675 } 676 677 fn test_f128_floatFromInt_u128(a: u128, expected: f128) !void { 678 const x = f128_floatFromInt_u128(a); 679 try testing.expect(x == expected); 680 } 681 682 test f128_floatFromInt_i128 { 683 try test_f128_floatFromInt_i128(0, 0.0); 684 685 try test_f128_floatFromInt_i128(1, 1.0); 686 try test_f128_floatFromInt_i128(2, 2.0); 687 try test_f128_floatFromInt_i128(20, 20.0); 688 try test_f128_floatFromInt_i128(-1, -1.0); 689 try test_f128_floatFromInt_i128(-2, -2.0); 690 try test_f128_floatFromInt_i128(-20, -20.0); 691 692 try test_f128_floatFromInt_i128(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 693 try test_f128_floatFromInt_i128(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 694 try test_f128_floatFromInt_i128(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 695 try test_f128_floatFromInt_i128(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 696 697 try test_f128_floatFromInt_i128(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); 698 try test_f128_floatFromInt_i128(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); 699 try test_f128_floatFromInt_i128(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); 700 try test_f128_floatFromInt_i128(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); 701 702 try test_f128_floatFromInt_i128(make_ti(0x8000000000000000, 0), -0x1.000000p+127); 703 try test_f128_floatFromInt_i128(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126); 704 705 try test_f128_floatFromInt_i128(0x0007FB72E8000000, 0x1.FEDCBAp+50); 706 707 try test_f128_floatFromInt_i128(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 708 try test_f128_floatFromInt_i128(0x0007FB72EB000000, 0x1.FEDCBACp+50); 709 try test_f128_floatFromInt_i128(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 710 try test_f128_floatFromInt_i128(0x0007FB72EC000000, 0x1.FEDCBBp+50); 711 try test_f128_floatFromInt_i128(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 712 713 try test_f128_floatFromInt_i128(0x0007FB72E6000000, 0x1.FEDCB98p+50); 714 try test_f128_floatFromInt_i128(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 715 try test_f128_floatFromInt_i128(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 716 try test_f128_floatFromInt_i128(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 717 try test_f128_floatFromInt_i128(0x0007FB72E4000000, 0x1.FEDCB9p+50); 718 719 try test_f128_floatFromInt_i128(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 720 try test_f128_floatFromInt_i128(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); 721 try test_f128_floatFromInt_i128(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); 722 try test_f128_floatFromInt_i128(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); 723 try test_f128_floatFromInt_i128(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); 724 try test_f128_floatFromInt_i128(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); 725 try test_f128_floatFromInt_i128(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); 726 try test_f128_floatFromInt_i128(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); 727 try test_f128_floatFromInt_i128(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); 728 try test_f128_floatFromInt_i128(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); 729 try test_f128_floatFromInt_i128(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); 730 try test_f128_floatFromInt_i128(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); 731 try test_f128_floatFromInt_i128(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); 732 try test_f128_floatFromInt_i128(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); 733 try test_f128_floatFromInt_i128(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 734 735 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 736 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); 737 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); 738 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); 739 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); 740 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); 741 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); 742 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); 743 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); 744 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); 745 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); 746 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); 747 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); 748 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); 749 try test_f128_floatFromInt_i128(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 750 751 try test_f128_floatFromInt_i128(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); 752 753 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); 754 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); 755 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); 756 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); 757 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); 758 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); 759 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); 760 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); 761 try test_f128_floatFromInt_i128(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); 762 } 763 764 test f128_floatFromInt_u128 { 765 try test_f128_floatFromInt_u128(0, 0.0); 766 767 try test_f128_floatFromInt_u128(1, 1.0); 768 try test_f128_floatFromInt_u128(2, 2.0); 769 try test_f128_floatFromInt_u128(20, 20.0); 770 771 try test_f128_floatFromInt_u128(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 772 try test_f128_floatFromInt_u128(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 773 try test_f128_floatFromInt_u128(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 774 try test_f128_floatFromInt_u128(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 775 try test_f128_floatFromInt_u128(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59); 776 try test_f128_floatFromInt_u128(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60); 777 try test_f128_floatFromInt_u128(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60); 778 779 try test_f128_floatFromInt_u128(0x8000008000000000, 0x8.000008p+60); 780 try test_f128_floatFromInt_u128(0x8000000000000800, 0x8.0000000000008p+60); 781 try test_f128_floatFromInt_u128(0x8000010000000000, 0x8.00001p+60); 782 try test_f128_floatFromInt_u128(0x8000000000001000, 0x8.000000000001p+60); 783 784 try test_f128_floatFromInt_u128(0x8000000000000000, 0x8p+60); 785 try test_f128_floatFromInt_u128(0x8000000000000001, 0x8.000000000000001p+60); 786 787 try test_f128_floatFromInt_u128(0x0007FB72E8000000, 0x1.FEDCBAp+50); 788 789 try test_f128_floatFromInt_u128(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 790 try test_f128_floatFromInt_u128(0x0007FB72EB000000, 0x1.FEDCBACp+50); 791 try test_f128_floatFromInt_u128(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 792 try test_f128_floatFromInt_u128(0x0007FB72EC000000, 0x1.FEDCBBp+50); 793 try test_f128_floatFromInt_u128(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 794 795 try test_f128_floatFromInt_u128(0x0007FB72E6000000, 0x1.FEDCB98p+50); 796 try test_f128_floatFromInt_u128(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 797 try test_f128_floatFromInt_u128(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 798 try test_f128_floatFromInt_u128(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 799 try test_f128_floatFromInt_u128(0x0007FB72E4000000, 0x1.FEDCB9p+50); 800 801 try test_f128_floatFromInt_u128(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 802 try test_f128_floatFromInt_u128(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); 803 try test_f128_floatFromInt_u128(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); 804 try test_f128_floatFromInt_u128(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); 805 try test_f128_floatFromInt_u128(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); 806 try test_f128_floatFromInt_u128(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); 807 try test_f128_floatFromInt_u128(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); 808 try test_f128_floatFromInt_u128(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); 809 try test_f128_floatFromInt_u128(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); 810 try test_f128_floatFromInt_u128(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); 811 try test_f128_floatFromInt_u128(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); 812 try test_f128_floatFromInt_u128(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); 813 try test_f128_floatFromInt_u128(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); 814 try test_f128_floatFromInt_u128(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); 815 try test_f128_floatFromInt_u128(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 816 817 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 818 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); 819 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); 820 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); 821 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); 822 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); 823 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); 824 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); 825 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); 826 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); 827 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); 828 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); 829 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); 830 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); 831 try test_f128_floatFromInt_u128(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 832 833 try test_f128_floatFromInt_u128(make_uti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); 834 835 try test_f128_floatFromInt_u128(make_uti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127); 836 try test_f128_floatFromInt_u128(make_uti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128); 837 838 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); 839 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); 840 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); 841 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); 842 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); 843 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); 844 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); 845 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); 846 try test_f128_floatFromInt_u128(make_uti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); 847 } 848 849 fn make_ti(high: u64, low: u64) i128 { 850 var result: u128 = high; 851 result <<= 64; 852 result |= low; 853 return @bitCast(result); 854 } 855 856 fn make_uti(high: u64, low: u64) u128 { 857 var result: u128 = high; 858 result <<= 64; 859 result |= low; 860 return result; 861 } 862 863 fn make_tf(high: u64, low: u64) f128 { 864 var result: u128 = high; 865 result <<= 64; 866 result |= low; 867 return @bitCast(result); 868 } 869 870 test f16_floatFromInt_u32 { 871 try testing.expect(f16_floatFromInt_u32(0) == 0.0); 872 try testing.expect(f16_floatFromInt_u32(1) == 1.0); 873 try testing.expect(f16_floatFromInt_u32(65504) == 65504); 874 try testing.expect(f16_floatFromInt_u32(65504 + (1 << 4)) == math.inf(f16)); 875 } 876 877 test f80_floatFromInt_u32 { 878 try testing.expect(f80_floatFromInt_u32(0) == 0.0); 879 try testing.expect(f80_floatFromInt_u32(1) == 1.0); 880 try testing.expect(f80_floatFromInt_u32(math.maxInt(u24) + 0) == math.maxInt(u24)); 881 } 882 883 test f80_floatFromInt_u64 { 884 try testing.expect(f80_floatFromInt_u64(math.maxInt(u64) + 0) == math.maxInt(u64) + 0); 885 } 886 887 test f80_floatFromInt_i128 { 888 try testing.expect(f80_floatFromInt_i128(-12) == -12); 889 } 890 891 test f80_floatFromInt_u128 { 892 try testing.expect(f80_floatFromInt_u128(math.maxInt(u64) + 1) == math.maxInt(u64) + 1); 893 894 try testing.expect(f80_floatFromInt_u128(math.maxInt(u64) + 0) == math.maxInt(u64)); 895 try testing.expect(f80_floatFromInt_u128(math.maxInt(u64) + 1) == math.maxInt(u64) + 1); // Exact 896 try testing.expect(f80_floatFromInt_u128(math.maxInt(u64) + 2) == math.maxInt(u64) + 1); // Rounds down 897 try testing.expect(f80_floatFromInt_u128(math.maxInt(u64) + 3) == math.maxInt(u64) + 3); // Tie - Exact 898 try testing.expect(f80_floatFromInt_u128(math.maxInt(u64) + 4) == math.maxInt(u64) + 5); // Rounds up 899 900 try testing.expect(f80_floatFromInt_u128(math.maxInt(u65) + 0) == math.maxInt(u65) + 1); // Rounds up 901 try testing.expect(f80_floatFromInt_u128(math.maxInt(u65) + 1) == math.maxInt(u65) + 1); // Exact 902 try testing.expect(f80_floatFromInt_u128(math.maxInt(u65) + 2) == math.maxInt(u65) + 1); // Rounds down 903 try testing.expect(f80_floatFromInt_u128(math.maxInt(u65) + 3) == math.maxInt(u65) + 1); // Tie - Rounds down 904 try testing.expect(f80_floatFromInt_u128(math.maxInt(u65) + 4) == math.maxInt(u65) + 5); // Rounds up 905 try testing.expect(f80_floatFromInt_u128(math.maxInt(u65) + 5) == math.maxInt(u65) + 5); // Exact 906 } 907