authorgravatar for hi@viri.moeviri <hi@viri.moe> 2022-04-06 20:49:05-06:00
committergravatar for hi@viri.moeviri <hi@viri.moe> 2022-04-07 05:04:38-06:00
loge46c61250332e615afc5aed6e4ebe57b8e6713eb
tree5ffbc2acac6c03becd253c7d4308eb33a4721025
parent5d6a5a123676ada3ccd229f31dc8855aabaf8057
signature Commit is signed but in an unrecognized format.

use math/float.zig everywhere

26 files changed, 177 insertions(+), 173 deletions(-)

lib/std/fmt.zig+16-16
......@@ -2228,8 +2228,8 @@ test "float.special" {
22282228 if (builtin.target.cpu.arch != .arm) {
22292229 try expectFmt("f64: -nan", "f64: {}", .{-math.nan_f64});
22302230 }
2231 try expectFmt("f64: inf", "f64: {}", .{math.inf_f64});
2232 try expectFmt("f64: -inf", "f64: {}", .{-math.inf_f64});
2231 try expectFmt("f64: inf", "f64: {}", .{math.inf(f64)});
2232 try expectFmt("f64: -inf", "f64: {}", .{-math.inf(f64)});
22332233}
22342234
22352235test "float.hexadecimal.special" {
......@@ -2239,8 +2239,8 @@ test "float.hexadecimal.special" {
22392239 if (builtin.target.cpu.arch != .arm) {
22402240 try expectFmt("f64: -nan", "f64: {x}", .{-math.nan_f64});
22412241 }
2242 try expectFmt("f64: inf", "f64: {x}", .{math.inf_f64});
2243 try expectFmt("f64: -inf", "f64: {x}", .{-math.inf_f64});
2242 try expectFmt("f64: inf", "f64: {x}", .{math.inf(f64)});
2243 try expectFmt("f64: -inf", "f64: {x}", .{-math.inf(f64)});
22442244
22452245 try expectFmt("f64: 0x0.0p0", "f64: {x}", .{@as(f64, 0)});
22462246 try expectFmt("f64: -0x0.0p0", "f64: {x}", .{-@as(f64, 0)});
......@@ -2252,20 +2252,20 @@ test "float.hexadecimal" {
22522252 try expectFmt("f64: 0x1.5555555555555p-2", "f64: {x}", .{@as(f64, 1.0 / 3.0)});
22532253 try expectFmt("f128: 0x1.5555555555555555555555555555p-2", "f128: {x}", .{@as(f128, 1.0 / 3.0)});
22542254
2255 try expectFmt("f16: 0x1p-14", "f16: {x}", .{@as(f16, math.f16_min)});
2256 try expectFmt("f32: 0x1p-126", "f32: {x}", .{@as(f32, math.f32_min)});
2257 try expectFmt("f64: 0x1p-1022", "f64: {x}", .{@as(f64, math.f64_min)});
2258 try expectFmt("f128: 0x1p-16382", "f128: {x}", .{@as(f128, math.f128_min)});
2255 try expectFmt("f16: 0x1p-14", "f16: {x}", .{math.floatMin(f16)});
2256 try expectFmt("f32: 0x1p-126", "f32: {x}", .{math.floatMin(f32)});
2257 try expectFmt("f64: 0x1p-1022", "f64: {x}", .{math.floatMin(f64)});
2258 try expectFmt("f128: 0x1p-16382", "f128: {x}", .{math.floatMin(f128)});
22592259
2260 try expectFmt("f16: 0x0.004p-14", "f16: {x}", .{@as(f16, math.f16_true_min)});
2261 try expectFmt("f32: 0x0.000002p-126", "f32: {x}", .{@as(f32, math.f32_true_min)});
2262 try expectFmt("f64: 0x0.0000000000001p-1022", "f64: {x}", .{@as(f64, math.f64_true_min)});
2263 try expectFmt("f128: 0x0.0000000000000000000000000001p-16382", "f128: {x}", .{@as(f128, math.f128_true_min)});
2260 try expectFmt("f16: 0x0.004p-14", "f16: {x}", .{math.floatTrueMin(f16)});
2261 try expectFmt("f32: 0x0.000002p-126", "f32: {x}", .{math.floatTrueMin(f32)});
2262 try expectFmt("f64: 0x0.0000000000001p-1022", "f64: {x}", .{math.floatTrueMin(f64)});
2263 try expectFmt("f128: 0x0.0000000000000000000000000001p-16382", "f128: {x}", .{math.floatTrueMin(f128)});
22642264
2265 try expectFmt("f16: 0x1.ffcp15", "f16: {x}", .{@as(f16, math.f16_max)});
2266 try expectFmt("f32: 0x1.fffffep127", "f32: {x}", .{@as(f32, math.f32_max)});
2267 try expectFmt("f64: 0x1.fffffffffffffp1023", "f64: {x}", .{@as(f64, math.f64_max)});
2268 try expectFmt("f128: 0x1.ffffffffffffffffffffffffffffp16383", "f128: {x}", .{@as(f128, math.f128_max)});
2265 try expectFmt("f16: 0x1.ffcp15", "f16: {x}", .{math.floatMax(f16)});
2266 try expectFmt("f32: 0x1.fffffep127", "f32: {x}", .{math.floatMax(f32)});
2267 try expectFmt("f64: 0x1.fffffffffffffp1023", "f64: {x}", .{math.floatMax(f64)});
2268 try expectFmt("f128: 0x1.ffffffffffffffffffffffffffffp16383", "f128: {x}", .{math.floatMax(f128)});
22692269}
22702270
22712271test "float.hexadecimal.precision" {
lib/std/fmt/parse_hex_float.zig+24-24
......@@ -262,14 +262,14 @@ test "f16" {
262262 .{ .s = "0x10p+10", .v = 16384.0 },
263263 .{ .s = "0x10p-10", .v = 0.015625 },
264264 // Max normalized value.
265 .{ .s = "0x1.ffcp+15", .v = math.f16_max },
266 .{ .s = "-0x1.ffcp+15", .v = -math.f16_max },
265 .{ .s = "0x1.ffcp+15", .v = math.floatMax(f16) },
266 .{ .s = "-0x1.ffcp+15", .v = -math.floatMax(f16) },
267267 // Min normalized value.
268 .{ .s = "0x1p-14", .v = math.f16_min },
269 .{ .s = "-0x1p-14", .v = -math.f16_min },
268 .{ .s = "0x1p-14", .v = math.floatMin(f16) },
269 .{ .s = "-0x1p-14", .v = -math.floatMin(f16) },
270270 // Min denormal value.
271 .{ .s = "0x1p-24", .v = math.f16_true_min },
272 .{ .s = "-0x1p-24", .v = -math.f16_true_min },
271 .{ .s = "0x1p-24", .v = math.floatTrueMin(f16) },
272 .{ .s = "-0x1p-24", .v = -math.floatTrueMin(f16) },
273273 };
274274
275275 for (cases) |case| {
......@@ -286,14 +286,14 @@ test "f32" {
286286 .{ .s = "0x0.ffffffp128", .v = 0x0.ffffffp128 },
287287 .{ .s = "0x0.1234570p-125", .v = 0x0.1234570p-125 },
288288 // Max normalized value.
289 .{ .s = "0x1.fffffeP+127", .v = math.f32_max },
290 .{ .s = "-0x1.fffffeP+127", .v = -math.f32_max },
289 .{ .s = "0x1.fffffeP+127", .v = math.floatMax(f32) },
290 .{ .s = "-0x1.fffffeP+127", .v = -math.floatMax(f32) },
291291 // Min normalized value.
292 .{ .s = "0x1p-126", .v = math.f32_min },
293 .{ .s = "-0x1p-126", .v = -math.f32_min },
292 .{ .s = "0x1p-126", .v = math.floatMin(f32) },
293 .{ .s = "-0x1p-126", .v = -math.floatMin(f32) },
294294 // Min denormal value.
295 .{ .s = "0x1P-149", .v = math.f32_true_min },
296 .{ .s = "-0x1P-149", .v = -math.f32_true_min },
295 .{ .s = "0x1P-149", .v = math.floatTrueMin(f32) },
296 .{ .s = "-0x1P-149", .v = -math.floatTrueMin(f32) },
297297 };
298298
299299 for (cases) |case| {
......@@ -308,14 +308,14 @@ test "f64" {
308308 .{ .s = "0x10p+10", .v = 16384.0 },
309309 .{ .s = "0x10p-10", .v = 0.015625 },
310310 // Max normalized value.
311 .{ .s = "0x1.fffffffffffffp+1023", .v = math.f64_max },
312 .{ .s = "-0x1.fffffffffffffp1023", .v = -math.f64_max },
311 .{ .s = "0x1.fffffffffffffp+1023", .v = math.floatMax(f64) },
312 .{ .s = "-0x1.fffffffffffffp1023", .v = -math.floatMax(f64) },
313313 // Min normalized value.
314 .{ .s = "0x1p-1022", .v = math.f64_min },
315 .{ .s = "-0x1p-1022", .v = -math.f64_min },
314 .{ .s = "0x1p-1022", .v = math.floatMin(f64) },
315 .{ .s = "-0x1p-1022", .v = -math.floatMin(f64) },
316316 // Min denormalized value.
317 .{ .s = "0x1p-1074", .v = math.f64_true_min },
318 .{ .s = "-0x1p-1074", .v = -math.f64_true_min },
317 .{ .s = "0x1p-1074", .v = math.floatTrueMin(f64) },
318 .{ .s = "-0x1p-1074", .v = -math.floatTrueMin(f64) },
319319 };
320320
321321 for (cases) |case| {
......@@ -330,14 +330,14 @@ test "f128" {
330330 .{ .s = "0x10p+10", .v = 16384.0 },
331331 .{ .s = "0x10p-10", .v = 0.015625 },
332332 // Max normalized value.
333 .{ .s = "0xf.fffffffffffffffffffffffffff8p+16380", .v = math.f128_max },
334 .{ .s = "-0xf.fffffffffffffffffffffffffff8p+16380", .v = -math.f128_max },
333 .{ .s = "0xf.fffffffffffffffffffffffffff8p+16380", .v = math.floatMax(f128) },
334 .{ .s = "-0xf.fffffffffffffffffffffffffff8p+16380", .v = -math.floatMax(f128) },
335335 // Min normalized value.
336 .{ .s = "0x1p-16382", .v = math.f128_min },
337 .{ .s = "-0x1p-16382", .v = -math.f128_min },
336 .{ .s = "0x1p-16382", .v = math.floatMin(f128) },
337 .{ .s = "-0x1p-16382", .v = -math.floatMin(f128) },
338338 // // Min denormalized value.
339 .{ .s = "0x1p-16494", .v = math.f128_true_min },
340 .{ .s = "-0x1p-16494", .v = -math.f128_true_min },
339 .{ .s = "0x1p-16494", .v = math.floatTrueMin(f128) },
340 .{ .s = "-0x1p-16494", .v = -math.floatTrueMin(f128) },
341341 .{ .s = "0x1.edcb34a235253948765432134674fp-1", .v = 0x1.edcb34a235253948765432134674fp-1 },
342342 };
343343
lib/std/math.zig+6-18
......@@ -121,7 +121,7 @@ pub const snan = @import("math/nan.zig").snan;
121121///
122122/// The `tolerance` parameter is the absolute tolerance used when determining if
123123/// the two numbers are close enough; a good value for this parameter is a small
124/// multiple of `epsilon(T)`.
124/// multiple of `floatEps(T)`.
125125///
126126/// Note that this function is recommended for comparing small numbers
127127/// around zero; using `approxEqRel` is suggested otherwise.
......@@ -148,7 +148,7 @@ pub fn approxEqAbs(comptime T: type, x: T, y: T, tolerance: T) bool {
148148///
149149/// The `tolerance` parameter is the relative tolerance used when determining if
150150/// the two numbers are close enough; a good value for this parameter is usually
151/// `sqrt(epsilon(T))`, meaning that the two numbers are considered equal if at
151/// `sqrt(floatEps(T))`, meaning that the two numbers are considered equal if at
152152/// least half of the digits are equal.
153153///
154154/// Note that for comparisons of small numbers around zero this function won't
......@@ -179,25 +179,19 @@ pub fn approxEq(comptime T: type, x: T, y: T, tolerance: T) bool {
179179
180180test "approxEqAbs and approxEqRel" {
181181 inline for ([_]type{ f16, f32, f64, f128 }) |T| {
182 const eps_value = comptime epsilon(T);
182 const eps_value = comptime floatEps(T);
183183 const sqrt_eps_value = comptime sqrt(eps_value);
184184 const nan_value = comptime nan(T);
185185 const inf_value = comptime inf(T);
186 const min_value: T = switch (T) {
187 f16 => f16_min,
188 f32 => f32_min,
189 f64 => f64_min,
190 f128 => f128_min,
191 else => unreachable,
192 };
186 const min_value = comptime floatMin(T);
193187
194188 try testing.expect(approxEqAbs(T, 0.0, 0.0, eps_value));
195189 try testing.expect(approxEqAbs(T, -0.0, -0.0, eps_value));
196190 try testing.expect(approxEqAbs(T, 0.0, -0.0, eps_value));
197191 try testing.expect(approxEqRel(T, 1.0, 1.0, sqrt_eps_value));
198192 try testing.expect(!approxEqRel(T, 1.0, 0.0, sqrt_eps_value));
199 try testing.expect(!approxEqAbs(T, 1.0 + 2 * epsilon(T), 1.0, eps_value));
200 try testing.expect(approxEqAbs(T, 1.0 + 1 * epsilon(T), 1.0, eps_value));
193 try testing.expect(!approxEqAbs(T, 1.0 + 2 * eps_value, 1.0, eps_value));
194 try testing.expect(approxEqAbs(T, 1.0 + 1 * eps_value, 1.0, eps_value));
201195 try testing.expect(!approxEqRel(T, 1.0, nan_value, sqrt_eps_value));
202196 try testing.expect(!approxEqRel(T, nan_value, nan_value, sqrt_eps_value));
203197 try testing.expect(approxEqRel(T, inf_value, inf_value, sqrt_eps_value));
......@@ -1193,12 +1187,6 @@ test "lossyCast" {
11931187 try testing.expect(lossyCast(u32, @as(f32, maxInt(u32))) == maxInt(u32));
11941188}
11951189
1196test "f64_min" {
1197 const f64_min_u64 = 0x0010000000000000;
1198 const fmin: f64 = f64_min;
1199 try testing.expect(@bitCast(u64, fmin) == f64_min_u64);
1200}
1201
12021190/// Returns the maximum value of integer type T.
12031191pub fn maxInt(comptime T: type) comptime_int {
12041192 const info = @typeInfo(T);
lib/std/math/__rem_pio2.zig+1-1
......@@ -7,7 +7,7 @@ const std = @import("../std.zig");
77const __rem_pio2_large = @import("__rem_pio2_large.zig").__rem_pio2_large;
88const math = std.math;
99
10const toint = 1.5 / math.epsilon(f64);
10const toint = 1.5 / math.floatEps(f64);
1111// pi/4
1212const pio4 = 0x1.921fb54442d18p-1;
1313// invpio2: 53 bits of 2/pi
lib/std/math/__rem_pio2f.zig+1-1
......@@ -7,7 +7,7 @@ const std = @import("../std.zig");
77const __rem_pio2_large = @import("__rem_pio2_large.zig").__rem_pio2_large;
88const math = std.math;
99
10const toint = 1.5 / math.epsilon(f64);
10const toint = 1.5 / math.floatEps(f64);
1111// pi/4
1212const pio4 = 0x1.921fb6p-1;
1313// invpio2: 53 bits of 2/pi
lib/std/math/ceil.zig+8-4
......@@ -62,6 +62,8 @@ fn ceil32(x: f32) f32 {
6262}
6363
6464fn ceil64(x: f64) f64 {
65 const f64_toint = 1.0 / math.floatEps(f64);
66
6567 const u = @bitCast(u64, x);
6668 const e = (u >> 52) & 0x7FF;
6769 var y: f64 = undefined;
......@@ -71,9 +73,9 @@ fn ceil64(x: f64) f64 {
7173 }
7274
7375 if (u >> 63 != 0) {
74 y = x - math.f64_toint + math.f64_toint - x;
76 y = x - f64_toint + f64_toint - x;
7577 } else {
76 y = x + math.f64_toint - math.f64_toint - x;
78 y = x + f64_toint - f64_toint - x;
7779 }
7880
7981 if (e <= 0x3FF - 1) {
......@@ -91,6 +93,8 @@ fn ceil64(x: f64) f64 {
9193}
9294
9395fn ceil128(x: f128) f128 {
96 const f128_toint = 1.0 / math.floatEps(f128);
97
9498 const u = @bitCast(u128, x);
9599 const e = (u >> 112) & 0x7FFF;
96100 var y: f128 = undefined;
......@@ -98,9 +102,9 @@ fn ceil128(x: f128) f128 {
98102 if (e >= 0x3FFF + 112 or x == 0) return x;
99103
100104 if (u >> 127 != 0) {
101 y = x - math.f128_toint + math.f128_toint - x;
105 y = x - f128_toint + f128_toint - x;
102106 } else {
103 y = x + math.f128_toint - math.f128_toint - x;
107 y = x + f128_toint - f128_toint - x;
104108 }
105109
106110 if (e <= 0x3FFF - 1) {
lib/std/math/complex/exp.zig+2-2
......@@ -120,7 +120,7 @@ fn exp64(z: Complex(f64)) Complex(f64) {
120120}
121121
122122test "complex.cexp32" {
123 const tolerance_f32 = math.sqrt(math.epsilon(f32));
123 const tolerance_f32 = math.sqrt(math.floatEps(f32));
124124
125125 {
126126 const a = Complex(f32).init(5, 3);
......@@ -140,7 +140,7 @@ test "complex.cexp32" {
140140}
141141
142142test "complex.cexp64" {
143 const tolerance_f64 = math.sqrt(math.epsilon(f64));
143 const tolerance_f64 = math.sqrt(math.floatEps(f64));
144144
145145 {
146146 const a = Complex(f64).init(5, 3);
lib/std/math/complex/sinh.zig+2-2
......@@ -79,7 +79,7 @@ fn sinh32(z: Complex(f32)) Complex(f32) {
7979 if (iy >= 0x7f800000) {
8080 return Complex(f32).init(x * x, x * (y - y));
8181 }
82 return Complex(f32).init(x * math.cos(y), math.inf_f32 * math.sin(y));
82 return Complex(f32).init(x * math.cos(y), math.inf(f32) * math.sin(y));
8383 }
8484
8585 return Complex(f32).init((x * x) * (y - y), (x + x) * (y - y));
......@@ -146,7 +146,7 @@ fn sinh64(z: Complex(f64)) Complex(f64) {
146146 if (iy >= 0x7ff00000) {
147147 return Complex(f64).init(x * x, x * (y - y));
148148 }
149 return Complex(f64).init(x * math.cos(y), math.inf_f64 * math.sin(y));
149 return Complex(f64).init(x * math.cos(y), math.inf(f64) * math.sin(y));
150150 }
151151
152152 return Complex(f64).init((x * x) * (y - y), (x + x) * (y - y));
lib/std/math/floor.zig+8-4
......@@ -98,6 +98,8 @@ fn floor32(x: f32) f32 {
9898}
9999
100100fn floor64(x: f64) f64 {
101 const f64_toint = 1.0 / math.floatEps(f64);
102
101103 const u = @bitCast(u64, x);
102104 const e = (u >> 52) & 0x7FF;
103105 var y: f64 = undefined;
......@@ -107,9 +109,9 @@ fn floor64(x: f64) f64 {
107109 }
108110
109111 if (u >> 63 != 0) {
110 y = x - math.f64_toint + math.f64_toint - x;
112 y = x - f64_toint + f64_toint - x;
111113 } else {
112 y = x + math.f64_toint - math.f64_toint - x;
114 y = x + f64_toint - f64_toint - x;
113115 }
114116
115117 if (e <= 0x3FF - 1) {
......@@ -127,6 +129,8 @@ fn floor64(x: f64) f64 {
127129}
128130
129131fn floor128(x: f128) f128 {
132 const f128_toint = 1.0 / math.floatEps(f128);
133
130134 const u = @bitCast(u128, x);
131135 const e = (u >> 112) & 0x7FFF;
132136 var y: f128 = undefined;
......@@ -134,9 +138,9 @@ fn floor128(x: f128) f128 {
134138 if (e >= 0x3FFF + 112 or x == 0) return x;
135139
136140 if (u >> 127 != 0) {
137 y = x - math.f128_toint + math.f128_toint - x;
141 y = x - f128_toint + f128_toint - x;
138142 } else {
139 y = x + math.f128_toint - math.f128_toint - x;
143 y = x + f128_toint - f128_toint - x;
140144 }
141145
142146 if (e <= 0x3FFF - 1) {
lib/std/math/fma.zig+2-2
......@@ -68,7 +68,7 @@ fn fma64(x: f64, y: f64, z: f64) f64 {
6868 if (spread <= 53 * 2) {
6969 zs = math.scalbn(zs, -spread);
7070 } else {
71 zs = math.copysign(f64, math.f64_min, zs);
71 zs = math.copysign(f64, math.floatMin(f64), zs);
7272 }
7373
7474 const xy = dd_mul(xs, ys);
......@@ -277,7 +277,7 @@ fn fma128(x: f128, y: f128, z: f128) f128 {
277277 if (spread <= 113 * 2) {
278278 zs = math.scalbn(zs, -spread);
279279 } else {
280 zs = math.copysign(f128, math.f128_min, zs);
280 zs = math.copysign(f128, math.floatMin(f128), zs);
281281 }
282282
283283 const xy = dd_mul128(xs, ys);
lib/std/math/ldexp.zig+16-14
......@@ -57,6 +57,8 @@ pub fn ldexp(x: anytype, n: i32) @TypeOf(x) {
5757}
5858
5959test "math.ldexp" {
60 // TODO derive the various constants here with new maths API
61
6062 // basic usage
6163 try expect(ldexp(@as(f16, 1.5), 4) == 24.0);
6264 try expect(ldexp(@as(f32, 1.5), 4) == 24.0);
......@@ -73,20 +75,20 @@ test "math.ldexp" {
7375 try expect(math.isNormal(ldexp(@as(f128, 1.0), -16382)));
7476 try expect(!math.isNormal(ldexp(@as(f128, 1.0), -16383)));
7577 // unreliable due to lack of native f16 support, see talk on PR #8733
76 // try expect(ldexp(@as(f16, 0x1.1FFp-1), -14 - 9) == math.f16_true_min);
77 try expect(ldexp(@as(f32, 0x1.3FFFFFp-1), -126 - 22) == math.f32_true_min);
78 try expect(ldexp(@as(f64, 0x1.7FFFFFFFFFFFFp-1), -1022 - 51) == math.f64_true_min);
79 try expect(ldexp(@as(f128, 0x1.7FFFFFFFFFFFFFFFFFFFFFFFFFFFp-1), -16382 - 111) == math.f128_true_min);
78 // try expect(ldexp(@as(f16, 0x1.1FFp-1), -14 - 9) == math.floatTrueMin(f16));
79 try expect(ldexp(@as(f32, 0x1.3FFFFFp-1), -126 - 22) == math.floatTrueMin(f32));
80 try expect(ldexp(@as(f64, 0x1.7FFFFFFFFFFFFp-1), -1022 - 51) == math.floatTrueMin(f64));
81 try expect(ldexp(@as(f128, 0x1.7FFFFFFFFFFFFFFFFFFFFFFFFFFFp-1), -16382 - 111) == math.floatTrueMin(f128));
8082
8183 // float limits
82 try expect(ldexp(@as(f32, math.f32_max), -128 - 149) > 0.0);
83 try expect(ldexp(@as(f32, math.f32_max), -128 - 149 - 1) == 0.0);
84 try expect(!math.isPositiveInf(ldexp(@as(f16, math.f16_true_min), 15 + 24)));
85 try expect(math.isPositiveInf(ldexp(@as(f16, math.f16_true_min), 15 + 24 + 1)));
86 try expect(!math.isPositiveInf(ldexp(@as(f32, math.f32_true_min), 127 + 149)));
87 try expect(math.isPositiveInf(ldexp(@as(f32, math.f32_true_min), 127 + 149 + 1)));
88 try expect(!math.isPositiveInf(ldexp(@as(f64, math.f64_true_min), 1023 + 1074)));
89 try expect(math.isPositiveInf(ldexp(@as(f64, math.f64_true_min), 1023 + 1074 + 1)));
90 try expect(!math.isPositiveInf(ldexp(@as(f128, math.f128_true_min), 16383 + 16494)));
91 try expect(math.isPositiveInf(ldexp(@as(f128, math.f128_true_min), 16383 + 16494 + 1)));
84 try expect(ldexp(math.floatMax(f32), -128 - 149) > 0.0);
85 try expect(ldexp(math.floatMax(f32), -128 - 149 - 1) == 0.0);
86 try expect(!math.isPositiveInf(ldexp(math.floatTrueMin(f16), 15 + 24)));
87 try expect(math.isPositiveInf(ldexp(math.floatTrueMin(f16), 15 + 24 + 1)));
88 try expect(!math.isPositiveInf(ldexp(math.floatTrueMin(f32), 127 + 149)));
89 try expect(math.isPositiveInf(ldexp(math.floatTrueMin(f32), 127 + 149 + 1)));
90 try expect(!math.isPositiveInf(ldexp(math.floatTrueMin(f64), 1023 + 1074)));
91 try expect(math.isPositiveInf(ldexp(math.floatTrueMin(f64), 1023 + 1074 + 1)));
92 try expect(!math.isPositiveInf(ldexp(math.floatTrueMin(f128), 16383 + 16494)));
93 try expect(math.isPositiveInf(ldexp(math.floatTrueMin(f128), 16383 + 16494 + 1)));
9294}
lib/std/math/round.zig+12-6
......@@ -29,6 +29,8 @@ pub fn round(x: anytype) @TypeOf(x) {
2929}
3030
3131fn round32(x_: f32) f32 {
32 const f32_toint = 1.0 / math.floatEps(f32);
33
3234 var x = x_;
3335 const u = @bitCast(u32, x);
3436 const e = (u >> 23) & 0xFF;
......@@ -41,11 +43,11 @@ fn round32(x_: f32) f32 {
4143 x = -x;
4244 }
4345 if (e < 0x7F - 1) {
44 math.doNotOptimizeAway(x + math.f32_toint);
46 math.doNotOptimizeAway(x + f32_toint);
4547 return 0 * @bitCast(f32, u);
4648 }
4749
48 y = x + math.f32_toint - math.f32_toint - x;
50 y = x + f32_toint - f32_toint - x;
4951 if (y > 0.5) {
5052 y = y + x - 1;
5153 } else if (y <= -0.5) {
......@@ -62,6 +64,8 @@ fn round32(x_: f32) f32 {
6264}
6365
6466fn round64(x_: f64) f64 {
67 const f64_toint = 1.0 / math.floatEps(f64);
68
6569 var x = x_;
6670 const u = @bitCast(u64, x);
6771 const e = (u >> 52) & 0x7FF;
......@@ -74,11 +78,11 @@ fn round64(x_: f64) f64 {
7478 x = -x;
7579 }
7680 if (e < 0x3ff - 1) {
77 math.doNotOptimizeAway(x + math.f64_toint);
81 math.doNotOptimizeAway(x + f64_toint);
7882 return 0 * @bitCast(f64, u);
7983 }
8084
81 y = x + math.f64_toint - math.f64_toint - x;
85 y = x + f64_toint - f64_toint - x;
8286 if (y > 0.5) {
8387 y = y + x - 1;
8488 } else if (y <= -0.5) {
......@@ -95,6 +99,8 @@ fn round64(x_: f64) f64 {
9599}
96100
97101fn round128(x_: f128) f128 {
102 const f128_toint = 1.0 / math.floatEps(f128);
103
98104 var x = x_;
99105 const u = @bitCast(u128, x);
100106 const e = (u >> 112) & 0x7FFF;
......@@ -107,11 +113,11 @@ fn round128(x_: f128) f128 {
107113 x = -x;
108114 }
109115 if (e < 0x3FFF - 1) {
110 math.doNotOptimizeAway(x + math.f64_toint);
116 math.doNotOptimizeAway(x + f128_toint);
111117 return 0 * @bitCast(f128, u);
112118 }
113119
114 y = x + math.f128_toint - math.f128_toint - x;
120 y = x + f128_toint - f128_toint - x;
115121 if (y > 0.5) {
116122 y = y + x - 1;
117123 } else if (y <= -0.5) {
lib/std/rand/ziggurat.zig+1-1
......@@ -28,7 +28,7 @@ pub fn next_f64(random: Random, comptime tables: ZigTable) f64 {
2828 } else {
2929 // Generate a value in the range [1, 2) and scale into (0, 1)
3030 const repr = (0x3ff << 52) | (bits >> 12);
31 break :blk @bitCast(f64, repr) - (1.0 - math.f64_epsilon / 2.0);
31 break :blk @bitCast(f64, repr) - (1.0 - math.floatEps(f64) / 2.0);
3232 }
3333 };
3434
lib/std/special/compiler_rt/divtf3_test.zig+1-1
......@@ -35,7 +35,7 @@ test "divtf3" {
3535 // NaN / any = NaN
3636 try test__divtf3(math.nan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
3737 // inf / any = inf
38 try test__divtf3(math.inf_f128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0);
38 try test__divtf3(math.inf(f128), 0x1.23456789abcdefp+5, 0x7fff000000000000, 0);
3939
4040 try test__divtf3(0x1.a23b45362464523375893ab4cdefp+5, 0x1.eedcbaba3a94546558237654321fp-1, 0x4004b0b72924d407, 0x0717e84356c6eba2);
4141 try test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50, 0x1.ed2c3ba15935332532287654321fp-9, 0x3fd5b2af3f828c9b, 0x40e51f64cde8b1f2);
lib/std/special/compiler_rt/fixdfdi_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixdfdi(a: f64, expected: i64) !void {
99}
1010
1111test "fixdfdi" {
12 try test__fixdfdi(-math.f64_max, math.minInt(i64));
12 try test__fixdfdi(-math.floatMax(f64), math.minInt(i64));
1313
1414 try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
1515 try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
......@@ -32,9 +32,9 @@ test "fixdfdi" {
3232 try test__fixdfdi(-1.0, -1);
3333 try test__fixdfdi(-0.99, 0);
3434 try test__fixdfdi(-0.5, 0);
35 try test__fixdfdi(-math.f64_min, 0);
35 try test__fixdfdi(-math.floatMin(f64), 0);
3636 try test__fixdfdi(0.0, 0);
37 try test__fixdfdi(math.f64_min, 0);
37 try test__fixdfdi(math.floatMin(f64), 0);
3838 try test__fixdfdi(0.5, 0);
3939 try test__fixdfdi(0.99, 0);
4040 try test__fixdfdi(1.0, 1);
......@@ -58,5 +58,5 @@ test "fixdfdi" {
5858 try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
5959 try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
6060
61 try test__fixdfdi(math.f64_max, math.maxInt(i64));
61 try test__fixdfdi(math.floatMax(f64), math.maxInt(i64));
6262}
lib/std/special/compiler_rt/fixdfsi_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixdfsi(a: f64, expected: i32) !void {
99}
1010
1111test "fixdfsi" {
12 try test__fixdfsi(-math.f64_max, math.minInt(i32));
12 try test__fixdfsi(-math.floatMax(f64), math.minInt(i32));
1313
1414 try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
1515 try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
......@@ -36,9 +36,9 @@ test "fixdfsi" {
3636 try test__fixdfsi(-1.0, -1);
3737 try test__fixdfsi(-0.99, 0);
3838 try test__fixdfsi(-0.5, 0);
39 try test__fixdfsi(-math.f64_min, 0);
39 try test__fixdfsi(-math.floatMin(f64), 0);
4040 try test__fixdfsi(0.0, 0);
41 try test__fixdfsi(math.f64_min, 0);
41 try test__fixdfsi(math.floatMin(f64), 0);
4242 try test__fixdfsi(0.5, 0);
4343 try test__fixdfsi(0.99, 0);
4444 try test__fixdfsi(1.0, 1);
......@@ -66,5 +66,5 @@ test "fixdfsi" {
6666 try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
6767 try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
6868
69 try test__fixdfsi(math.f64_max, math.maxInt(i32));
69 try test__fixdfsi(math.floatMax(f64), math.maxInt(i32));
7070}
lib/std/special/compiler_rt/fixdfti_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixdfti(a: f64, expected: i128) !void {
99}
1010
1111test "fixdfti" {
12 try test__fixdfti(-math.f64_max, math.minInt(i128));
12 try test__fixdfti(-math.floatMax(f64), math.minInt(i128));
1313
1414 try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
1515 try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
......@@ -32,9 +32,9 @@ test "fixdfti" {
3232 try test__fixdfti(-1.0, -1);
3333 try test__fixdfti(-0.99, 0);
3434 try test__fixdfti(-0.5, 0);
35 try test__fixdfti(-math.f64_min, 0);
35 try test__fixdfti(-math.floatMin(f64), 0);
3636 try test__fixdfti(0.0, 0);
37 try test__fixdfti(math.f64_min, 0);
37 try test__fixdfti(math.floatMin(f64), 0);
3838 try test__fixdfti(0.5, 0);
3939 try test__fixdfti(0.99, 0);
4040 try test__fixdfti(1.0, 1);
......@@ -58,5 +58,5 @@ test "fixdfti" {
5858 try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
5959 try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
6060
61 try test__fixdfti(math.f64_max, math.maxInt(i128));
61 try test__fixdfti(math.floatMax(f64), math.maxInt(i128));
6262}
lib/std/special/compiler_rt/fixint_test.zig+36-36
......@@ -11,49 +11,49 @@ fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected:
1111}
1212
1313test "fixint.i1" {
14 try test__fixint(f32, i1, -math.inf_f32, -1);
15 try test__fixint(f32, i1, -math.f32_max, -1);
14 try test__fixint(f32, i1, -math.inf(f32), -1);
15 try test__fixint(f32, i1, -math.floatMax(f32), -1);
1616 try test__fixint(f32, i1, -2.0, -1);
1717 try test__fixint(f32, i1, -1.1, -1);
1818 try test__fixint(f32, i1, -1.0, -1);
1919 try test__fixint(f32, i1, -0.9, 0);
2020 try test__fixint(f32, i1, -0.1, 0);
21 try test__fixint(f32, i1, -math.f32_min, 0);
21 try test__fixint(f32, i1, -math.floatMin(f32), 0);
2222 try test__fixint(f32, i1, -0.0, 0);
2323 try test__fixint(f32, i1, 0.0, 0);
24 try test__fixint(f32, i1, math.f32_min, 0);
24 try test__fixint(f32, i1, math.floatMin(f32), 0);
2525 try test__fixint(f32, i1, 0.1, 0);
2626 try test__fixint(f32, i1, 0.9, 0);
2727 try test__fixint(f32, i1, 1.0, 0);
2828 try test__fixint(f32, i1, 2.0, 0);
29 try test__fixint(f32, i1, math.f32_max, 0);
30 try test__fixint(f32, i1, math.inf_f32, 0);
29 try test__fixint(f32, i1, math.floatMax(f32), 0);
30 try test__fixint(f32, i1, math.inf(f32), 0);
3131}
3232
3333test "fixint.i2" {
34 try test__fixint(f32, i2, -math.inf_f32, -2);
35 try test__fixint(f32, i2, -math.f32_max, -2);
34 try test__fixint(f32, i2, -math.inf(f32), -2);
35 try test__fixint(f32, i2, -math.floatMax(f32), -2);
3636 try test__fixint(f32, i2, -2.0, -2);
3737 try test__fixint(f32, i2, -1.9, -1);
3838 try test__fixint(f32, i2, -1.1, -1);
3939 try test__fixint(f32, i2, -1.0, -1);
4040 try test__fixint(f32, i2, -0.9, 0);
4141 try test__fixint(f32, i2, -0.1, 0);
42 try test__fixint(f32, i2, -math.f32_min, 0);
42 try test__fixint(f32, i2, -math.floatMin(f32), 0);
4343 try test__fixint(f32, i2, -0.0, 0);
4444 try test__fixint(f32, i2, 0.0, 0);
45 try test__fixint(f32, i2, math.f32_min, 0);
45 try test__fixint(f32, i2, math.floatMin(f32), 0);
4646 try test__fixint(f32, i2, 0.1, 0);
4747 try test__fixint(f32, i2, 0.9, 0);
4848 try test__fixint(f32, i2, 1.0, 1);
4949 try test__fixint(f32, i2, 2.0, 1);
50 try test__fixint(f32, i2, math.f32_max, 1);
51 try test__fixint(f32, i2, math.inf_f32, 1);
50 try test__fixint(f32, i2, math.floatMax(f32), 1);
51 try test__fixint(f32, i2, math.inf(f32), 1);
5252}
5353
5454test "fixint.i3" {
55 try test__fixint(f32, i3, -math.inf_f32, -4);
56 try test__fixint(f32, i3, -math.f32_max, -4);
55 try test__fixint(f32, i3, -math.inf(f32), -4);
56 try test__fixint(f32, i3, -math.floatMax(f32), -4);
5757 try test__fixint(f32, i3, -4.0, -4);
5858 try test__fixint(f32, i3, -3.0, -3);
5959 try test__fixint(f32, i3, -2.0, -2);
......@@ -62,23 +62,23 @@ test "fixint.i3" {
6262 try test__fixint(f32, i3, -1.0, -1);
6363 try test__fixint(f32, i3, -0.9, 0);
6464 try test__fixint(f32, i3, -0.1, 0);
65 try test__fixint(f32, i3, -math.f32_min, 0);
65 try test__fixint(f32, i3, -math.floatMin(f32), 0);
6666 try test__fixint(f32, i3, -0.0, 0);
6767 try test__fixint(f32, i3, 0.0, 0);
68 try test__fixint(f32, i3, math.f32_min, 0);
68 try test__fixint(f32, i3, math.floatMin(f32), 0);
6969 try test__fixint(f32, i3, 0.1, 0);
7070 try test__fixint(f32, i3, 0.9, 0);
7171 try test__fixint(f32, i3, 1.0, 1);
7272 try test__fixint(f32, i3, 2.0, 2);
7373 try test__fixint(f32, i3, 3.0, 3);
7474 try test__fixint(f32, i3, 4.0, 3);
75 try test__fixint(f32, i3, math.f32_max, 3);
76 try test__fixint(f32, i3, math.inf_f32, 3);
75 try test__fixint(f32, i3, math.floatMax(f32), 3);
76 try test__fixint(f32, i3, math.inf(f32), 3);
7777}
7878
7979test "fixint.i32" {
80 try test__fixint(f64, i32, -math.inf_f64, math.minInt(i32));
81 try test__fixint(f64, i32, -math.f64_max, math.minInt(i32));
80 try test__fixint(f64, i32, -math.inf(f64), math.minInt(i32));
81 try test__fixint(f64, i32, -math.floatMax(f64), math.minInt(i32));
8282 try test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32));
8383 try test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1);
8484 try test__fixint(f64, i32, -2.0, -2);
......@@ -87,22 +87,22 @@ test "fixint.i32" {
8787 try test__fixint(f64, i32, -1.0, -1);
8888 try test__fixint(f64, i32, -0.9, 0);
8989 try test__fixint(f64, i32, -0.1, 0);
90 try test__fixint(f64, i32, -math.f32_min, 0);
90 try test__fixint(f64, i32, -@as(f64, math.floatMin(f32)), 0);
9191 try test__fixint(f64, i32, -0.0, 0);
9292 try test__fixint(f64, i32, 0.0, 0);
93 try test__fixint(f64, i32, math.f32_min, 0);
93 try test__fixint(f64, i32, @as(f64, math.floatMin(f32)), 0);
9494 try test__fixint(f64, i32, 0.1, 0);
9595 try test__fixint(f64, i32, 0.9, 0);
9696 try test__fixint(f64, i32, 1.0, 1);
9797 try test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1);
9898 try test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32));
99 try test__fixint(f64, i32, math.f64_max, math.maxInt(i32));
100 try test__fixint(f64, i32, math.inf_f64, math.maxInt(i32));
99 try test__fixint(f64, i32, math.floatMax(f64), math.maxInt(i32));
100 try test__fixint(f64, i32, math.inf(f64), math.maxInt(i32));
101101}
102102
103103test "fixint.i64" {
104 try test__fixint(f64, i64, -math.inf_f64, math.minInt(i64));
105 try test__fixint(f64, i64, -math.f64_max, math.minInt(i64));
104 try test__fixint(f64, i64, -math.inf(f64), math.minInt(i64));
105 try test__fixint(f64, i64, -math.floatMax(f64), math.minInt(i64));
106106 try test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64));
107107 try test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64));
108108 try test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2);
......@@ -112,22 +112,22 @@ test "fixint.i64" {
112112 try test__fixint(f64, i64, -1.0, -1);
113113 try test__fixint(f64, i64, -0.9, 0);
114114 try test__fixint(f64, i64, -0.1, 0);
115 try test__fixint(f64, i64, -math.f32_min, 0);
115 try test__fixint(f64, i64, -@as(f64, math.floatMin(f32)), 0);
116116 try test__fixint(f64, i64, -0.0, 0);
117117 try test__fixint(f64, i64, 0.0, 0);
118 try test__fixint(f64, i64, math.f32_min, 0);
118 try test__fixint(f64, i64, @as(f64, math.floatMin(f32)), 0);
119119 try test__fixint(f64, i64, 0.1, 0);
120120 try test__fixint(f64, i64, 0.9, 0);
121121 try test__fixint(f64, i64, 1.0, 1);
122122 try test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64));
123123 try test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64));
124 try test__fixint(f64, i64, math.f64_max, math.maxInt(i64));
125 try test__fixint(f64, i64, math.inf_f64, math.maxInt(i64));
124 try test__fixint(f64, i64, math.floatMax(f64), math.maxInt(i64));
125 try test__fixint(f64, i64, math.inf(f64), math.maxInt(i64));
126126}
127127
128128test "fixint.i128" {
129 try test__fixint(f64, i128, -math.inf_f64, math.minInt(i128));
130 try test__fixint(f64, i128, -math.f64_max, math.minInt(i128));
129 try test__fixint(f64, i128, -math.inf(f64), math.minInt(i128));
130 try test__fixint(f64, i128, -math.floatMax(f64), math.minInt(i128));
131131 try test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128));
132132 try test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128));
133133 try test__fixint(f64, i128, -2.0, -2);
......@@ -136,15 +136,15 @@ test "fixint.i128" {
136136 try test__fixint(f64, i128, -1.0, -1);
137137 try test__fixint(f64, i128, -0.9, 0);
138138 try test__fixint(f64, i128, -0.1, 0);
139 try test__fixint(f64, i128, -math.f32_min, 0);
139 try test__fixint(f64, i128, -@as(f64, math.floatMin(f32)), 0);
140140 try test__fixint(f64, i128, -0.0, 0);
141141 try test__fixint(f64, i128, 0.0, 0);
142 try test__fixint(f64, i128, math.f32_min, 0);
142 try test__fixint(f64, i128, @as(f64, math.floatMin(f32)), 0);
143143 try test__fixint(f64, i128, 0.1, 0);
144144 try test__fixint(f64, i128, 0.9, 0);
145145 try test__fixint(f64, i128, 1.0, 1);
146146 try test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128));
147147 try test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128));
148 try test__fixint(f64, i128, math.f64_max, math.maxInt(i128));
149 try test__fixint(f64, i128, math.inf_f64, math.maxInt(i128));
148 try test__fixint(f64, i128, math.floatMax(f64), math.maxInt(i128));
149 try test__fixint(f64, i128, math.inf(f64), math.maxInt(i128));
150150}
lib/std/special/compiler_rt/fixsfdi_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixsfdi(a: f32, expected: i64) !void {
99}
1010
1111test "fixsfdi" {
12 try test__fixsfdi(-math.f32_max, math.minInt(i64));
12 try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
1313
1414 try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
1515 try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
......@@ -33,9 +33,9 @@ test "fixsfdi" {
3333 try test__fixsfdi(-1.0, -1);
3434 try test__fixsfdi(-0.99, 0);
3535 try test__fixsfdi(-0.5, 0);
36 try test__fixsfdi(-math.f32_min, 0);
36 try test__fixsfdi(-math.floatMin(f32), 0);
3737 try test__fixsfdi(0.0, 0);
38 try test__fixsfdi(math.f32_min, 0);
38 try test__fixsfdi(math.floatMin(f32), 0);
3939 try test__fixsfdi(0.5, 0);
4040 try test__fixsfdi(0.99, 0);
4141 try test__fixsfdi(1.0, 1);
......@@ -60,5 +60,5 @@ test "fixsfdi" {
6060 try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
6161 try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
6262
63 try test__fixsfdi(math.f64_max, math.maxInt(i64));
63 try test__fixsfdi(math.floatMax(f32), math.maxInt(i64));
6464}
lib/std/special/compiler_rt/fixsfsi_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixsfsi(a: f32, expected: i32) !void {
99}
1010
1111test "fixsfsi" {
12 try test__fixsfsi(-math.f32_max, math.minInt(i32));
12 try test__fixsfsi(-math.floatMax(f32), math.minInt(i32));
1313
1414 try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
1515 try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
......@@ -37,9 +37,9 @@ test "fixsfsi" {
3737 try test__fixsfsi(-1.0, -1);
3838 try test__fixsfsi(-0.99, 0);
3939 try test__fixsfsi(-0.5, 0);
40 try test__fixsfsi(-math.f32_min, 0);
40 try test__fixsfsi(-math.floatMin(f32), 0);
4141 try test__fixsfsi(0.0, 0);
42 try test__fixsfsi(math.f32_min, 0);
42 try test__fixsfsi(math.floatMin(f32), 0);
4343 try test__fixsfsi(0.5, 0);
4444 try test__fixsfsi(0.99, 0);
4545 try test__fixsfsi(1.0, 1);
......@@ -68,5 +68,5 @@ test "fixsfsi" {
6868 try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
6969 try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
7070
71 try test__fixsfsi(math.f32_max, math.maxInt(i32));
71 try test__fixsfsi(math.floatMax(f32), math.maxInt(i32));
7272}
lib/std/special/compiler_rt/fixsfti_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixsfti(a: f32, expected: i128) !void {
99}
1010
1111test "fixsfti" {
12 try test__fixsfti(-math.f32_max, math.minInt(i128));
12 try test__fixsfti(-math.floatMax(f32), math.minInt(i128));
1313
1414 try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
1515 try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
......@@ -41,9 +41,9 @@ test "fixsfti" {
4141 try test__fixsfti(-1.0, -1);
4242 try test__fixsfti(-0.99, 0);
4343 try test__fixsfti(-0.5, 0);
44 try test__fixsfti(-math.f32_min, 0);
44 try test__fixsfti(-math.floatMin(f32), 0);
4545 try test__fixsfti(0.0, 0);
46 try test__fixsfti(math.f32_min, 0);
46 try test__fixsfti(math.floatMin(f32), 0);
4747 try test__fixsfti(0.5, 0);
4848 try test__fixsfti(0.99, 0);
4949 try test__fixsfti(1.0, 1);
......@@ -76,5 +76,5 @@ test "fixsfti" {
7676 try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
7777 try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
7878
79 try test__fixsfti(math.f32_max, math.maxInt(i128));
79 try test__fixsfti(math.floatMax(f32), math.maxInt(i128));
8080}
lib/std/special/compiler_rt/fixtfdi_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixtfdi(a: f128, expected: i64) !void {
99}
1010
1111test "fixtfdi" {
12 try test__fixtfdi(-math.f128_max, math.minInt(i64));
12 try test__fixtfdi(-math.floatMax(f128), math.minInt(i64));
1313
1414 try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
1515 try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
......@@ -37,9 +37,9 @@ test "fixtfdi" {
3737 try test__fixtfdi(-1.0, -1);
3838 try test__fixtfdi(-0.99, 0);
3939 try test__fixtfdi(-0.5, 0);
40 try test__fixtfdi(-math.f64_min, 0);
40 try test__fixtfdi(-@as(f128, math.floatMin(f64)), 0);
4141 try test__fixtfdi(0.0, 0);
42 try test__fixtfdi(math.f64_min, 0);
42 try test__fixtfdi(@as(f128, math.floatMin(f64)), 0);
4343 try test__fixtfdi(0.5, 0);
4444 try test__fixtfdi(0.99, 0);
4545 try test__fixtfdi(1.0, 1);
......@@ -68,5 +68,5 @@ test "fixtfdi" {
6868 try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
6969 try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
7070
71 try test__fixtfdi(math.f128_max, math.maxInt(i64));
71 try test__fixtfdi(math.floatMax(f128), math.maxInt(i64));
7272}
lib/std/special/compiler_rt/fixtfsi_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixtfsi(a: f128, expected: i32) !void {
99}
1010
1111test "fixtfsi" {
12 try test__fixtfsi(-math.f128_max, math.minInt(i32));
12 try test__fixtfsi(-math.floatMax(f128), math.minInt(i32));
1313
1414 try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
1515 try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
......@@ -37,9 +37,9 @@ test "fixtfsi" {
3737 try test__fixtfsi(-1.0, -1);
3838 try test__fixtfsi(-0.99, 0);
3939 try test__fixtfsi(-0.5, 0);
40 try test__fixtfsi(-math.f32_min, 0);
40 try test__fixtfsi(-@as(f128, math.floatMin(f32)), 0);
4141 try test__fixtfsi(0.0, 0);
42 try test__fixtfsi(math.f32_min, 0);
42 try test__fixtfsi(@as(f128, math.floatMin(f32)), 0);
4343 try test__fixtfsi(0.5, 0);
4444 try test__fixtfsi(0.99, 0);
4545 try test__fixtfsi(1.0, 1);
......@@ -68,5 +68,5 @@ test "fixtfsi" {
6868 try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
6969 try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
7070
71 try test__fixtfsi(math.f128_max, math.maxInt(i32));
71 try test__fixtfsi(math.floatMax(f128), math.maxInt(i32));
7272}
lib/std/special/compiler_rt/fixtfti_test.zig+4-4
......@@ -9,7 +9,7 @@ fn test__fixtfti(a: f128, expected: i128) !void {
99}
1010
1111test "fixtfti" {
12 try test__fixtfti(-math.f128_max, math.minInt(i128));
12 try test__fixtfti(-math.floatMax(f128), math.minInt(i128));
1313
1414 try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
1515 try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
......@@ -32,9 +32,9 @@ test "fixtfti" {
3232 try test__fixtfti(-1.0, -1);
3333 try test__fixtfti(-0.99, 0);
3434 try test__fixtfti(-0.5, 0);
35 try test__fixtfti(-math.f128_min, 0);
35 try test__fixtfti(-math.floatMin(f128), 0);
3636 try test__fixtfti(0.0, 0);
37 try test__fixtfti(math.f128_min, 0);
37 try test__fixtfti(math.floatMin(f128), 0);
3838 try test__fixtfti(0.5, 0);
3939 try test__fixtfti(0.99, 0);
4040 try test__fixtfti(1.0, 1);
......@@ -58,5 +58,5 @@ test "fixtfti" {
5858 try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
5959 try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
6060
61 try test__fixtfti(math.f128_max, math.maxInt(i128));
61 try test__fixtfti(math.floatMax(f128), math.maxInt(i128));
6262}
lib/std/special/compiler_rt/floatfmodl_test.zig+4-4
......@@ -15,10 +15,10 @@ fn test_fmodl_nans() !void {
1515}
1616
1717fn test_fmodl_infs() !void {
18 try testing.expect(fmodl.fmodl(1.0, std.math.inf_f128) == 1.0);
19 try testing.expect(fmodl.fmodl(1.0, -std.math.inf_f128) == 1.0);
20 try testing.expect(std.math.isNan(fmodl.fmodl(std.math.inf_f128, 1.0)));
21 try testing.expect(std.math.isNan(fmodl.fmodl(-std.math.inf_f128, 1.0)));
18 try testing.expect(fmodl.fmodl(1.0, std.math.inf(f128)) == 1.0);
19 try testing.expect(fmodl.fmodl(1.0, -std.math.inf(f128)) == 1.0);
20 try testing.expect(std.math.isNan(fmodl.fmodl(std.math.inf(f128), 1.0)));
21 try testing.expect(std.math.isNan(fmodl.fmodl(-std.math.inf(f128), 1.0)));
2222}
2323
2424test "fmodl" {
test/behavior/vector.zig+1-1
......@@ -641,7 +641,7 @@ test "vector reduce operation" {
641641 // equal.
642642 } else {
643643 const F = @TypeOf(expected);
644 const tolerance = @sqrt(math.epsilon(TX));
644 const tolerance = @sqrt(math.floatEps(TX));
645645 try expect(std.math.approxEqRel(F, expected, r, tolerance));
646646 }
647647 },