c2db077574
Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
133 lines
2.9 KiB
Zig
133 lines
2.9 KiB
Zig
// Special Cases:
|
|
//
|
|
// - ilogb(+-inf) = maxInt(i32)
|
|
// - ilogb(0) = maxInt(i32)
|
|
// - ilogb(nan) = maxInt(i32)
|
|
|
|
const std = @import("../index.zig");
|
|
const math = std.math;
|
|
const expect = std.testing.expect;
|
|
const maxInt = std.math.maxInt;
|
|
const minInt = std.math.minInt;
|
|
|
|
pub fn ilogb(x: var) i32 {
|
|
const T = @typeOf(x);
|
|
return switch (T) {
|
|
f32 => ilogb32(x),
|
|
f64 => ilogb64(x),
|
|
else => @compileError("ilogb not implemented for " ++ @typeName(T)),
|
|
};
|
|
}
|
|
|
|
// NOTE: Should these be exposed publicly?
|
|
const fp_ilogbnan = -1 - i32(maxInt(u32) >> 1);
|
|
const fp_ilogb0 = fp_ilogbnan;
|
|
|
|
fn ilogb32(x: f32) i32 {
|
|
var u = @bitCast(u32, x);
|
|
var e = @intCast(i32, (u >> 23) & 0xFF);
|
|
|
|
// TODO: We should be able to merge this with the lower check.
|
|
if (math.isNan(x)) {
|
|
return maxInt(i32);
|
|
}
|
|
|
|
if (e == 0) {
|
|
u <<= 9;
|
|
if (u == 0) {
|
|
math.raiseInvalid();
|
|
return fp_ilogb0;
|
|
}
|
|
|
|
// subnormal
|
|
e = -0x7F;
|
|
while (u >> 31 == 0) : (u <<= 1) {
|
|
e -= 1;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
if (e == 0xFF) {
|
|
math.raiseInvalid();
|
|
if (u << 9 != 0) {
|
|
return fp_ilogbnan;
|
|
} else {
|
|
return maxInt(i32);
|
|
}
|
|
}
|
|
|
|
return e - 0x7F;
|
|
}
|
|
|
|
fn ilogb64(x: f64) i32 {
|
|
var u = @bitCast(u64, x);
|
|
var e = @intCast(i32, (u >> 52) & 0x7FF);
|
|
|
|
if (math.isNan(x)) {
|
|
return maxInt(i32);
|
|
}
|
|
|
|
if (e == 0) {
|
|
u <<= 12;
|
|
if (u == 0) {
|
|
math.raiseInvalid();
|
|
return fp_ilogb0;
|
|
}
|
|
|
|
// subnormal
|
|
e = -0x3FF;
|
|
while (u >> 63 == 0) : (u <<= 1) {
|
|
e -= 1;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
if (e == 0x7FF) {
|
|
math.raiseInvalid();
|
|
if (u << 12 != 0) {
|
|
return fp_ilogbnan;
|
|
} else {
|
|
return maxInt(i32);
|
|
}
|
|
}
|
|
|
|
return e - 0x3FF;
|
|
}
|
|
|
|
test "math.ilogb" {
|
|
expect(ilogb(f32(0.2)) == ilogb32(0.2));
|
|
expect(ilogb(f64(0.2)) == ilogb64(0.2));
|
|
}
|
|
|
|
test "math.ilogb32" {
|
|
expect(ilogb32(0.0) == fp_ilogb0);
|
|
expect(ilogb32(0.5) == -1);
|
|
expect(ilogb32(0.8923) == -1);
|
|
expect(ilogb32(10.0) == 3);
|
|
expect(ilogb32(-123984) == 16);
|
|
expect(ilogb32(2398.23) == 11);
|
|
}
|
|
|
|
test "math.ilogb64" {
|
|
expect(ilogb64(0.0) == fp_ilogb0);
|
|
expect(ilogb64(0.5) == -1);
|
|
expect(ilogb64(0.8923) == -1);
|
|
expect(ilogb64(10.0) == 3);
|
|
expect(ilogb64(-123984) == 16);
|
|
expect(ilogb64(2398.23) == 11);
|
|
}
|
|
|
|
test "math.ilogb32.special" {
|
|
expect(ilogb32(math.inf(f32)) == maxInt(i32));
|
|
expect(ilogb32(-math.inf(f32)) == maxInt(i32));
|
|
expect(ilogb32(0.0) == minInt(i32));
|
|
expect(ilogb32(math.nan(f32)) == maxInt(i32));
|
|
}
|
|
|
|
test "math.ilogb64.special" {
|
|
expect(ilogb64(math.inf(f64)) == maxInt(i32));
|
|
expect(ilogb64(-math.inf(f64)) == maxInt(i32));
|
|
expect(ilogb64(0.0) == minInt(i32));
|
|
expect(ilogb64(math.nan(f64)) == maxInt(i32));
|
|
}
|