float_from_int_test.zig (45810B) - Raw
1 const std = @import("std"); 2 const testing = std.testing; 3 const math = std.math; 4 5 const __floatunsihf = @import("floatunsihf.zig").__floatunsihf; 6 7 // Conversion to f32 8 const __floatsisf = @import("floatsisf.zig").__floatsisf; 9 const __floatunsisf = @import("floatunsisf.zig").__floatunsisf; 10 const __floatdisf = @import("floatdisf.zig").__floatdisf; 11 const __floatundisf = @import("floatundisf.zig").__floatundisf; 12 const __floattisf = @import("floattisf.zig").__floattisf; 13 const __floatuntisf = @import("floatuntisf.zig").__floatuntisf; 14 const __floateisf = @import("floateisf.zig").__floateisf; 15 const __floatuneisf = @import("floatuneisf.zig").__floatuneisf; 16 17 // Conversion to f64 18 const __floatsidf = @import("floatsidf.zig").__floatsidf; 19 const __floatunsidf = @import("floatunsidf.zig").__floatunsidf; 20 const __floatdidf = @import("floatdidf.zig").__floatdidf; 21 const __floatundidf = @import("floatundidf.zig").__floatundidf; 22 const __floattidf = @import("floattidf.zig").__floattidf; 23 const __floatuntidf = @import("floatuntidf.zig").__floatuntidf; 24 25 // Conversion to f128 26 const __floatsitf = @import("floatsitf.zig").__floatsitf; 27 const __floatunsitf = @import("floatunsitf.zig").__floatunsitf; 28 const __floatditf = @import("floatditf.zig").__floatditf; 29 const __floatunditf = @import("floatunditf.zig").__floatunditf; 30 const __floattitf = @import("floattitf.zig").__floattitf; 31 const __floatuntitf = @import("floatuntitf.zig").__floatuntitf; 32 33 fn test__floatsisf(a: i32, expected: u32) !void { 34 const r = __floatsisf(a); 35 try std.testing.expect(@as(u32, @bitCast(r)) == expected); 36 } 37 38 fn test_one_floatunsisf(a: u32, expected: u32) !void { 39 const r = __floatunsisf(a); 40 try std.testing.expect(@as(u32, @bitCast(r)) == expected); 41 } 42 43 test "floatsisf" { 44 try test__floatsisf(0, 0x00000000); 45 try test__floatsisf(1, 0x3f800000); 46 try test__floatsisf(-1, 0xbf800000); 47 try test__floatsisf(0x7FFFFFFF, 0x4f000000); 48 try test__floatsisf(@bitCast(@as(u32, @intCast(0x80000000))), 0xcf000000); 49 } 50 51 test "floatunsisf" { 52 // Test the produced bit pattern 53 try test_one_floatunsisf(0, 0); 54 try test_one_floatunsisf(1, 0x3f800000); 55 try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000); 56 try test_one_floatunsisf(0x80000000, 0x4f000000); 57 try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000); 58 } 59 60 fn test__floatdisf(a: i64, expected: f32) !void { 61 const x = __floatdisf(a); 62 try testing.expect(x == expected); 63 } 64 65 fn test__floatundisf(a: u64, expected: f32) !void { 66 try std.testing.expectEqual(expected, __floatundisf(a)); 67 } 68 69 test "floatdisf" { 70 try test__floatdisf(0, 0.0); 71 try test__floatdisf(1, 1.0); 72 try test__floatdisf(2, 2.0); 73 try test__floatdisf(-1, -1.0); 74 try test__floatdisf(-2, -2.0); 75 try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 76 try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 77 try test__floatdisf(@bitCast(@as(u64, 0x8000008000000000)), -0x1.FFFFFEp+62); 78 try test__floatdisf(@bitCast(@as(u64, 0x8000010000000000)), -0x1.FFFFFCp+62); 79 try test__floatdisf(@bitCast(@as(u64, 0x8000000000000000)), -0x1.000000p+63); 80 try test__floatdisf(@bitCast(@as(u64, 0x8000000000000001)), -0x1.000000p+63); 81 try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 82 try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); 83 try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); 84 try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 85 try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); 86 try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); 87 try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); 88 try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); 89 try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 90 try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); 91 try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); 92 } 93 94 test "floatundisf" { 95 try test__floatundisf(0, 0.0); 96 try test__floatundisf(1, 1.0); 97 try test__floatundisf(2, 2.0); 98 try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 99 try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 100 try test__floatundisf(0x8000008000000000, 0x1p+63); 101 try test__floatundisf(0x8000010000000000, 0x1.000002p+63); 102 try test__floatundisf(0x8000000000000000, 0x1p+63); 103 try test__floatundisf(0x8000000000000001, 0x1p+63); 104 try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); 105 try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); 106 try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 107 try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); 108 try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); 109 try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 110 try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); 111 try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); 112 try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); 113 try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); 114 try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 115 try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); 116 try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); 117 } 118 119 fn test__floattisf(a: i128, expected: f32) !void { 120 const x = __floattisf(a); 121 try testing.expect(x == expected); 122 } 123 124 fn test__floatuntisf(a: u128, expected: f32) !void { 125 const x = __floatuntisf(a); 126 try testing.expect(x == expected); 127 } 128 129 test "floattisf" { 130 try test__floattisf(0, 0.0); 131 132 try test__floattisf(1, 1.0); 133 try test__floattisf(2, 2.0); 134 try test__floattisf(-1, -1.0); 135 try test__floattisf(-2, -2.0); 136 137 try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 138 try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 139 140 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62); 141 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62); 142 143 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63); 144 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63); 145 146 try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 147 148 try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); 149 try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); 150 try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 151 try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); 152 try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); 153 154 try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); 155 try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); 156 try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 157 try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); 158 try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); 159 160 try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114); 161 162 try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114); 163 try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114); 164 try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114); 165 try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114); 166 try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114); 167 168 try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114); 169 try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114); 170 try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114); 171 try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114); 172 try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114); 173 } 174 175 test "floatuntisf" { 176 try test__floatuntisf(0, 0.0); 177 178 try test__floatuntisf(1, 1.0); 179 try test__floatuntisf(2, 2.0); 180 try test__floatuntisf(20, 20.0); 181 182 try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 183 try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 184 185 try test__floatuntisf(make_uti(0x8000008000000000, 0), 0x1.000001p+127); 186 try test__floatuntisf(make_uti(0x8000000000000800, 0), 0x1.0p+127); 187 try test__floatuntisf(make_uti(0x8000010000000000, 0), 0x1.000002p+127); 188 189 try test__floatuntisf(make_uti(0x8000000000000000, 0), 0x1.000000p+127); 190 191 try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 192 193 try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 194 try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50); 195 196 try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50); 197 198 try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50); 199 try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 200 try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50); 201 202 try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); 203 try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); 204 205 try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 206 207 try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); 208 try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); 209 try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); 210 try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); 211 try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); 212 213 try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); 214 try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); 215 try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); 216 try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); 217 try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); 218 219 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76); 220 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76); 221 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76); 222 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76); 223 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76); 224 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76); 225 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76); 226 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76); 227 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76); 228 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76); 229 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76); 230 try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76); 231 232 // Test overflow to infinity 233 try test__floatuntisf(math.maxInt(u128), @bitCast(math.inf(f32))); 234 } 235 236 fn test_floateisf(expected: u32, comptime T: type, a: T) !void { 237 const int = @typeInfo(T).int; 238 const r = switch (int.signedness) { 239 .signed => __floateisf, 240 .unsigned => __floatuneisf, 241 }(@ptrCast(&a), int.bits); 242 try testing.expect(expected == @as(u32, @bitCast(r))); 243 } 244 245 test "floateisf" { 246 try test_floateisf(0xFF000000, i256, -1 << 127); 247 try test_floateisf(0xFF000000, i256, -math.maxInt(u127)); 248 try test_floateisf(0xDF012347, i256, -0x8123468100000000); 249 try test_floateisf(0xDF012347, i256, -0x8123468000000001); 250 try test_floateisf(0xDF012346, i256, -0x8123468000000000); 251 try test_floateisf(0xDF012346, i256, -0x8123458100000000); 252 try test_floateisf(0xDF012346, i256, -0x8123458000000001); 253 try test_floateisf(0xDF012346, i256, -0x8123458000000000); 254 try test_floateisf(0xDF012345, i256, -0x8123456789ABCDEF); 255 try test_floateisf(0xBF800000, i256, -1); 256 try test_floateisf(0x00000000, i256, 0); 257 try test_floateisf(0x5F012345, i256, 0x8123456789ABCDEF); 258 try test_floateisf(0x5F012346, i256, 0x8123458000000000); 259 try test_floateisf(0x5F012346, i256, 0x8123458000000001); 260 try test_floateisf(0x5F012346, i256, 0x8123458100000000); 261 try test_floateisf(0x5F012346, i256, 0x8123468000000000); 262 try test_floateisf(0x5F012347, i256, 0x8123468000000001); 263 try test_floateisf(0x5F012347, i256, 0x8123468100000000); 264 try test_floateisf(0x7F000000, i256, math.maxInt(u127)); 265 try test_floateisf(0x7F000000, i256, 1 << 127); 266 } 267 268 test "floatuneisf" { 269 try test_floateisf(0x00000000, u256, 0); 270 try test_floateisf(0x5F012345, u256, 0x8123456789ABCDEF); 271 try test_floateisf(0x5F012346, u256, 0x8123458000000000); 272 try test_floateisf(0x5F012346, u256, 0x8123458000000001); 273 try test_floateisf(0x5F012346, u256, 0x8123458080000000); 274 try test_floateisf(0x5F012346, u256, 0x8123468000000000); 275 try test_floateisf(0x5F012347, u256, 0x8123468000000001); 276 try test_floateisf(0x5F012347, u256, 0x8123468080000000); 277 try test_floateisf(0x7F000000, u256, math.maxInt(u127)); 278 try test_floateisf(0x7F000000, u256, 1 << 127); 279 try test_floateisf(0x7F800000, u256, math.maxInt(u256)); 280 } 281 282 fn test_one_floatsidf(a: i32, expected: u64) !void { 283 const r = __floatsidf(a); 284 try std.testing.expect(@as(u64, @bitCast(r)) == expected); 285 } 286 287 fn test_one_floatunsidf(a: u32, expected: u64) !void { 288 const r = __floatunsidf(a); 289 try std.testing.expect(@as(u64, @bitCast(r)) == expected); 290 } 291 292 test "floatsidf" { 293 try test_one_floatsidf(0, 0x0000000000000000); 294 try test_one_floatsidf(1, 0x3ff0000000000000); 295 try test_one_floatsidf(-1, 0xbff0000000000000); 296 try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000); 297 try test_one_floatsidf(@bitCast(@as(u32, @intCast(0x80000000))), 0xc1e0000000000000); 298 } 299 300 test "floatunsidf" { 301 try test_one_floatunsidf(0, 0x0000000000000000); 302 try test_one_floatunsidf(1, 0x3ff0000000000000); 303 try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000); 304 try test_one_floatunsidf(@intCast(0x80000000), 0x41e0000000000000); 305 try test_one_floatunsidf(@intCast(0xFFFFFFFF), 0x41efffffffe00000); 306 } 307 308 fn test__floatdidf(a: i64, expected: f64) !void { 309 const r = __floatdidf(a); 310 try testing.expect(r == expected); 311 } 312 313 fn test__floatundidf(a: u64, expected: f64) !void { 314 const r = __floatundidf(a); 315 try testing.expect(r == expected); 316 } 317 318 test "floatdidf" { 319 try test__floatdidf(0, 0.0); 320 try test__floatdidf(1, 1.0); 321 try test__floatdidf(2, 2.0); 322 try test__floatdidf(20, 20.0); 323 try test__floatdidf(-1, -1.0); 324 try test__floatdidf(-2, -2.0); 325 try test__floatdidf(-20, -20.0); 326 try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 327 try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 328 try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 329 try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 330 try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000008000000000))), -0x1.FFFFFEp+62); 331 try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000000800))), -0x1.FFFFFFFFFFFFEp+62); 332 try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000010000000000))), -0x1.FFFFFCp+62); 333 try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000001000))), -0x1.FFFFFFFFFFFFCp+62); 334 try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000000000))), -0x1.000000p+63); 335 try test__floatdidf(@bitCast(@as(u64, @intCast(0x8000000000000001))), -0x1.000000p+63); // 0x8000000000000001 336 try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 337 try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 338 try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); 339 try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 340 try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); 341 try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 342 try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); 343 try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 344 try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 345 try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 346 try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); 347 try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 348 try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 349 try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 350 try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 351 try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 352 try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 353 try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 354 try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 355 try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 356 try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 357 try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 358 try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 359 try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 360 try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 361 try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 362 } 363 364 test "floatundidf" { 365 try test__floatundidf(0, 0.0); 366 try test__floatundidf(1, 1.0); 367 try test__floatundidf(2, 2.0); 368 try test__floatundidf(20, 20.0); 369 try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 370 try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 371 try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 372 try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 373 try test__floatundidf(0x8000008000000000, 0x1.000001p+63); 374 try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63); 375 try test__floatundidf(0x8000010000000000, 0x1.000002p+63); 376 try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63); 377 try test__floatundidf(0x8000000000000000, 0x1p+63); 378 try test__floatundidf(0x8000000000000001, 0x1p+63); 379 try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 380 try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 381 try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); 382 try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 383 try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); 384 try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 385 try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); 386 try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 387 try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 388 try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 389 try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); 390 try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 391 try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 392 try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 393 try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 394 try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 395 try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 396 try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 397 try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 398 try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 399 try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 400 try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 401 try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 402 try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 403 try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 404 try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 405 } 406 407 fn test__floattidf(a: i128, expected: f64) !void { 408 const x = __floattidf(a); 409 try testing.expect(x == expected); 410 } 411 412 fn test__floatuntidf(a: u128, expected: f64) !void { 413 const x = __floatuntidf(a); 414 try testing.expect(x == expected); 415 } 416 417 test "floattidf" { 418 try test__floattidf(0, 0.0); 419 420 try test__floattidf(1, 1.0); 421 try test__floattidf(2, 2.0); 422 try test__floattidf(20, 20.0); 423 try test__floattidf(-1, -1.0); 424 try test__floattidf(-2, -2.0); 425 try test__floattidf(-20, -20.0); 426 427 try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 428 try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 429 try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 430 try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 431 432 try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); 433 try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); 434 try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); 435 try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); 436 437 try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); 438 try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127); 439 440 try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 441 442 try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 443 try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); 444 try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 445 try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); 446 try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 447 448 try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); 449 try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 450 try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 451 try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 452 try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); 453 454 try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 455 try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 456 try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 457 try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 458 try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 459 try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 460 try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 461 try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 462 try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 463 try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 464 try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 465 try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 466 try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 467 try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 468 try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 469 470 try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 471 try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); 472 try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); 473 try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); 474 try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); 475 try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); 476 try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); 477 try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); 478 try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); 479 try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); 480 try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); 481 try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); 482 try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); 483 try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); 484 try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 485 } 486 487 test "floatuntidf" { 488 try test__floatuntidf(0, 0.0); 489 490 try test__floatuntidf(1, 1.0); 491 try test__floatuntidf(2, 2.0); 492 try test__floatuntidf(20, 20.0); 493 494 try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 495 try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 496 try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 497 try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 498 499 try test__floatuntidf(make_uti(0x8000008000000000, 0), 0x1.000001p+127); 500 try test__floatuntidf(make_uti(0x8000000000000800, 0), 0x1.0000000000001p+127); 501 try test__floatuntidf(make_uti(0x8000010000000000, 0), 0x1.000002p+127); 502 try test__floatuntidf(make_uti(0x8000000000001000, 0), 0x1.0000000000002p+127); 503 504 try test__floatuntidf(make_uti(0x8000000000000000, 0), 0x1.000000p+127); 505 try test__floatuntidf(make_uti(0x8000000000000001, 0), 0x1.0000000000000002p+127); 506 507 try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 508 509 try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 510 try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); 511 try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 512 try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); 513 try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 514 515 try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); 516 try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 517 try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 518 try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 519 try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); 520 521 try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 522 try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); 523 try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); 524 try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); 525 try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); 526 try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); 527 try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); 528 try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); 529 try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); 530 try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); 531 try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); 532 try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); 533 try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); 534 try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); 535 try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 536 537 try test__floatuntidf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 538 try test__floatuntidf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); 539 try test__floatuntidf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); 540 try test__floatuntidf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); 541 try test__floatuntidf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); 542 try test__floatuntidf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); 543 try test__floatuntidf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); 544 try test__floatuntidf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); 545 try test__floatuntidf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); 546 try test__floatuntidf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); 547 try test__floatuntidf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); 548 try test__floatuntidf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); 549 try test__floatuntidf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); 550 try test__floatuntidf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); 551 try test__floatuntidf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 552 } 553 554 fn test__floatsitf(a: i32, expected: u128) !void { 555 const r = __floatsitf(a); 556 try std.testing.expect(@as(u128, @bitCast(r)) == expected); 557 } 558 559 test "floatsitf" { 560 try test__floatsitf(0, 0); 561 try test__floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000); 562 try test__floatsitf(0x12345678, 0x401b2345678000000000000000000000); 563 try test__floatsitf(-0x12345678, 0xc01b2345678000000000000000000000); 564 try test__floatsitf(@bitCast(@as(u32, @intCast(0xffffffff))), 0xbfff0000000000000000000000000000); 565 try test__floatsitf(@bitCast(@as(u32, @intCast(0x80000000))), 0xc01e0000000000000000000000000000); 566 } 567 568 fn test__floatunsitf(a: u32, expected_hi: u64, expected_lo: u64) !void { 569 const x = __floatunsitf(a); 570 571 const x_repr: u128 = @bitCast(x); 572 const x_hi: u64 = @intCast(x_repr >> 64); 573 const x_lo: u64 = @truncate(x_repr); 574 575 if (x_hi == expected_hi and x_lo == expected_lo) { 576 return; 577 } 578 // nan repr 579 else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { 580 if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { 581 return; 582 } 583 } 584 585 @panic("__floatunsitf test failure"); 586 } 587 588 test "floatunsitf" { 589 try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0); 590 try test__floatunsitf(0, 0x0, 0x0); 591 try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0); 592 try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0); 593 } 594 595 fn test__floatditf(a: i64, expected: f128) !void { 596 const x = __floatditf(a); 597 try testing.expect(x == expected); 598 } 599 600 fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void { 601 const x = __floatunditf(a); 602 603 const x_repr: u128 = @bitCast(x); 604 const x_hi: u64 = @intCast(x_repr >> 64); 605 const x_lo: u64 = @truncate(x_repr); 606 607 if (x_hi == expected_hi and x_lo == expected_lo) { 608 return; 609 } 610 // nan repr 611 else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { 612 if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { 613 return; 614 } 615 } 616 617 @panic("__floatunditf test failure"); 618 } 619 620 test "floatditf" { 621 try test__floatditf(0x7fffffffffffffff, make_tf(0x403dffffffffffff, 0xfffc000000000000)); 622 try test__floatditf(0x123456789abcdef1, make_tf(0x403b23456789abcd, 0xef10000000000000)); 623 try test__floatditf(0x2, make_tf(0x4000000000000000, 0x0)); 624 try test__floatditf(0x1, make_tf(0x3fff000000000000, 0x0)); 625 try test__floatditf(0x0, make_tf(0x0, 0x0)); 626 try test__floatditf(@bitCast(@as(u64, 0xffffffffffffffff)), make_tf(0xbfff000000000000, 0x0)); 627 try test__floatditf(@bitCast(@as(u64, 0xfffffffffffffffe)), make_tf(0xc000000000000000, 0x0)); 628 try test__floatditf(-0x123456789abcdef1, make_tf(0xc03b23456789abcd, 0xef10000000000000)); 629 try test__floatditf(@bitCast(@as(u64, 0x8000000000000000)), make_tf(0xc03e000000000000, 0x0)); 630 } 631 632 test "floatunditf" { 633 try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000); 634 try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000); 635 try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0); 636 try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000); 637 try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000); 638 try test__floatunditf(0x2, 0x4000000000000000, 0x0); 639 try test__floatunditf(0x1, 0x3fff000000000000, 0x0); 640 try test__floatunditf(0x0, 0x0, 0x0); 641 } 642 643 fn test__floattitf(a: i128, expected: f128) !void { 644 const x = __floattitf(a); 645 try testing.expect(x == expected); 646 } 647 648 fn test__floatuntitf(a: u128, expected: f128) !void { 649 const x = __floatuntitf(a); 650 try testing.expect(x == expected); 651 } 652 653 test "floattitf" { 654 try test__floattitf(0, 0.0); 655 656 try test__floattitf(1, 1.0); 657 try test__floattitf(2, 2.0); 658 try test__floattitf(20, 20.0); 659 try test__floattitf(-1, -1.0); 660 try test__floattitf(-2, -2.0); 661 try test__floattitf(-20, -20.0); 662 663 try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 664 try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 665 try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 666 try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 667 668 try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); 669 try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); 670 try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); 671 try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); 672 673 try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); 674 try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126); 675 676 try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 677 678 try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 679 try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); 680 try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 681 try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); 682 try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 683 684 try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); 685 try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 686 try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 687 try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 688 try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); 689 690 try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 691 try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); 692 try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); 693 try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); 694 try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); 695 try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); 696 try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); 697 try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); 698 try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); 699 try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); 700 try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); 701 try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); 702 try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); 703 try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); 704 try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 705 706 try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 707 try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); 708 try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); 709 try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); 710 try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); 711 try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); 712 try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); 713 try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); 714 try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); 715 try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); 716 try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); 717 try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); 718 try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); 719 try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); 720 try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 721 722 try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); 723 724 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); 725 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); 726 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); 727 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); 728 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); 729 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); 730 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); 731 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); 732 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); 733 } 734 735 test "floatuntitf" { 736 try test__floatuntitf(0, 0.0); 737 738 try test__floatuntitf(1, 1.0); 739 try test__floatuntitf(2, 2.0); 740 try test__floatuntitf(20, 20.0); 741 742 try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); 743 try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); 744 try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); 745 try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); 746 try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59); 747 try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60); 748 try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60); 749 750 try test__floatuntitf(0x8000008000000000, 0x8.000008p+60); 751 try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60); 752 try test__floatuntitf(0x8000010000000000, 0x8.00001p+60); 753 try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60); 754 755 try test__floatuntitf(0x8000000000000000, 0x8p+60); 756 try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60); 757 758 try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); 759 760 try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); 761 try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); 762 try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); 763 try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); 764 try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); 765 766 try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); 767 try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); 768 try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); 769 try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); 770 try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); 771 772 try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); 773 try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); 774 try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); 775 try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); 776 try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); 777 try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); 778 try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); 779 try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); 780 try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); 781 try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); 782 try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); 783 try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); 784 try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); 785 try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); 786 try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); 787 788 try test__floatuntitf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); 789 try test__floatuntitf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); 790 try test__floatuntitf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); 791 try test__floatuntitf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); 792 try test__floatuntitf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); 793 try test__floatuntitf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); 794 try test__floatuntitf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); 795 try test__floatuntitf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); 796 try test__floatuntitf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); 797 try test__floatuntitf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); 798 try test__floatuntitf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); 799 try test__floatuntitf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); 800 try test__floatuntitf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); 801 try test__floatuntitf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); 802 try test__floatuntitf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); 803 804 try test__floatuntitf(make_uti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); 805 806 try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127); 807 try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128); 808 809 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); 810 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); 811 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); 812 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); 813 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); 814 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); 815 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); 816 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); 817 try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); 818 } 819 820 fn make_ti(high: u64, low: u64) i128 { 821 var result: u128 = high; 822 result <<= 64; 823 result |= low; 824 return @bitCast(result); 825 } 826 827 fn make_uti(high: u64, low: u64) u128 { 828 var result: u128 = high; 829 result <<= 64; 830 result |= low; 831 return result; 832 } 833 834 fn make_tf(high: u64, low: u64) f128 { 835 var result: u128 = high; 836 result <<= 64; 837 result |= low; 838 return @bitCast(result); 839 } 840 841 test "conversion to f16" { 842 try testing.expect(__floatunsihf(@as(u32, 0)) == 0.0); 843 try testing.expect(__floatunsihf(@as(u32, 1)) == 1.0); 844 try testing.expect(__floatunsihf(@as(u32, 65504)) == 65504); 845 try testing.expect(__floatunsihf(@as(u32, 65504 + (1 << 4))) == math.inf(f16)); 846 } 847 848 test "conversion to f32" { 849 try testing.expect(__floatunsisf(@as(u32, 0)) == 0.0); 850 try testing.expect(__floatunsisf(@as(u32, math.maxInt(u32))) != 1.0); 851 try testing.expect(__floatsisf(@as(i32, math.minInt(i32))) != 1.0); 852 try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24))) == math.maxInt(u24)); 853 try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 1) == math.maxInt(u24) + 1); // 0x100_0000 - Exact 854 try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 2) == math.maxInt(u24) + 1); // 0x100_0001 - Tie: Rounds down to even 855 try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 3) == math.maxInt(u24) + 3); // 0x100_0002 - Exact 856 try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 4) == math.maxInt(u24) + 5); // 0x100_0003 - Tie: Rounds up to even 857 try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 5) == math.maxInt(u24) + 5); // 0x100_0004 - Exact 858 } 859 860 test "conversion to f80" { 861 const floatFromInt = @import("./float_from_int.zig").floatFromInt; 862 863 try testing.expect(floatFromInt(f80, @as(i80, -12)) == -12); 864 try testing.expect(@as(u80, @intFromFloat(floatFromInt(f80, @as(u64, math.maxInt(u64)) + 0))) == math.maxInt(u64) + 0); 865 try testing.expect(@as(u80, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u64)) + 1))) == math.maxInt(u64) + 1); 866 867 try testing.expect(floatFromInt(f80, @as(u32, 0)) == 0.0); 868 try testing.expect(floatFromInt(f80, @as(u32, 1)) == 1.0); 869 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u32, math.maxInt(u24)) + 0))) == math.maxInt(u24)); 870 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u64)) + 0))) == math.maxInt(u64)); 871 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u64)) + 1))) == math.maxInt(u64) + 1); // Exact 872 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u64)) + 2))) == math.maxInt(u64) + 1); // Rounds down 873 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u64)) + 3))) == math.maxInt(u64) + 3); // Tie - Exact 874 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u64)) + 4))) == math.maxInt(u64) + 5); // Rounds up 875 876 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u65)) + 0))) == math.maxInt(u65) + 1); // Rounds up 877 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u65)) + 1))) == math.maxInt(u65) + 1); // Exact 878 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u65)) + 2))) == math.maxInt(u65) + 1); // Rounds down 879 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u65)) + 3))) == math.maxInt(u65) + 1); // Tie - Rounds down 880 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u65)) + 4))) == math.maxInt(u65) + 5); // Rounds up 881 try testing.expect(@as(u128, @intFromFloat(floatFromInt(f80, @as(u80, math.maxInt(u65)) + 5))) == math.maxInt(u65) + 5); // Exact 882 }