std.math: allow comptime_floats in isInf and isNan

Currently constants passed to these functions trigger an obtuse:
`error: access of union field 'float' while field 'comptime_float' is active`
where the work-around is to cast the constant into a runtime float.

From ziglang#21205, I'm leveraging the fact
that `comptime_float` won't (eventually) support NaN or infinity, so the
`isNan` and `isInf` methods can unilaterally return false for
`comptime_float` parameters.

Add tests for comptime floats passed to isNan, isInf*.

See ziglang#23258 for the motivation.

Fixes ziglang#22107

Author: rootbeer

lib/std/math/isinf.zig

@@ -2,22 +2,38 @@ const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
 
-/// Returns whether x is an infinity, ignoring sign.
-pub inline fn isInf(x: anytype) bool {
+/// Returns whether float argument is an infinity, ignoring sign.
+pub fn isInf(x: anytype) bool {
     const T = @TypeOf(x);
-    const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
-    const remove_sign = ~@as(TBits, 0) >> 1;
-    return @as(TBits, @bitCast(x)) & remove_sign == @as(TBits, @bitCast(math.inf(T)));
+    switch (@typeInfo(T)) {
+        .comptime_float => return false, // comptime does not allow inf
+        .float => {
+            const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits);
+            const remove_sign = ~@as(TBits, 0) >> 1;
+            return @as(TBits, @bitCast(x)) & remove_sign == @as(TBits, @bitCast(math.inf(T)));
+        },
+        else => @compileError("isInf unsupported for " ++ @typeName(T)),
+    }
 }
 
-/// Returns whether x is an infinity with a positive sign.
-pub inline fn isPositiveInf(x: anytype) bool {
-    return x == math.inf(@TypeOf(x));
+/// Returns whether float argument is an infinity with a positive sign.
+pub fn isPositiveInf(x: anytype) bool {
+    const T = @TypeOf(x);
+    switch (@typeInfo(T)) {
+        .comptime_float => return false, // comptime does not allow inf
+        .float => return x == math.inf(T),
+        else => @compileError("isPositiveInf unsupported for " ++ @typeName(T)),
+    }
 }
 
-/// Returns whether x is an infinity with a negative sign.
-pub inline fn isNegativeInf(x: anytype) bool {
-    return x == -math.inf(@TypeOf(x));
+/// Returns whether float argument is an infinity with a negative sign.
+pub fn isNegativeInf(x: anytype) bool {
+    const T = @TypeOf(x);
+    switch (@typeInfo(T)) {
+        .comptime_float => return false, // comptime does not allow inf
+        .float => return x == -math.inf(T),
+        else => @compileError("isNegativeInf unsupported for " ++ @typeName(T)),
+    }
 }
 
 test isInf {
@@ -29,6 +45,7 @@ test isInf {
         try expect(!isInf(math.nan(T)));
         try expect(!isInf(-math.nan(T)));
     }
+    try expect(!isInf(0.0));
 }
 
 test isPositiveInf {
@@ -37,9 +54,10 @@ test isPositiveInf {
         try expect(!isPositiveInf(@as(T, -0.0)));
         try expect(isPositiveInf(math.inf(T)));
         try expect(!isPositiveInf(-math.inf(T)));
-        try expect(!isInf(math.nan(T)));
-        try expect(!isInf(-math.nan(T)));
+        try expect(!isPositiveInf(math.nan(T)));
+        try expect(!isPositiveInf(-math.nan(T)));
     }
+    try expect(!isPositiveInf(0.0));
 }
 
 test isNegativeInf {
@@ -48,7 +66,8 @@ test isNegativeInf {
         try expect(!isNegativeInf(@as(T, -0.0)));
         try expect(!isNegativeInf(math.inf(T)));
         try expect(isNegativeInf(-math.inf(T)));
-        try expect(!isInf(math.nan(T)));
-        try expect(!isInf(-math.nan(T)));
+        try expect(!isNegativeInf(math.nan(T)));
+        try expect(!isNegativeInf(-math.nan(T)));
     }
+    try expect(!isNegativeInf(0.0));
 }

lib/std/math/isnan.zig

@@ -5,16 +5,27 @@ const meta = std.meta;
 const expect = std.testing.expect;
 
 pub fn isNan(x: anytype) bool {
-    return x != x;
+    const T = @TypeOf(x);
+    switch (@typeInfo(T)) {
+        .comptime_float => return false, // comptime does not allow NaN
+        .float => return x != x,
+        else => @compileError("isNan unsupported for " ++ @typeName(T)),
+    }
 }
 
 /// TODO: LLVM is known to miscompile on some architectures to quiet NaN -
 ///       this is tracked by https://github.com/ziglang/zig/issues/14366
 pub fn isSignalNan(x: anytype) bool {
     const T = @TypeOf(x);
-    const U = meta.Int(.unsigned, @bitSizeOf(T));
-    const quiet_signal_bit_mask = 1 << (math.floatFractionalBits(T) - 1);
-    return isNan(x) and (@as(U, @bitCast(x)) & quiet_signal_bit_mask == 0);
+    switch (@typeInfo(T)) {
+        .comptime_float => return false, // comptime does not allow NaN
+        .float => {
+            const U = meta.Int(.unsigned, @bitSizeOf(T));
+            const quiet_signal_bit_mask = 1 << (math.floatFractionalBits(T) - 1);
+            return isNan(x) and (@as(U, @bitCast(x)) & quiet_signal_bit_mask == 0);
+        },
+        else => @compileError("isSignalNan unsupported for " ++ @typeName(T)),
+    }
 }
 
 test isNan {
@@ -23,8 +34,9 @@ test isNan {
         try expect(isNan(-math.nan(T)));
         try expect(isNan(math.snan(T)));
         try expect(!isNan(@as(T, 1.0)));
-        try expect(!isNan(@as(T, math.inf(T))));
+        try expect(!isNan(math.inf(T)));
     }
+    try expect(!isNan(1.0));
 }
 
 test isSignalNan {
@@ -39,9 +51,13 @@ test isSignalNan {
             builtin.zig_backend != .stage2_c)
         {
             try expect(isSignalNan(math.snan(T)));
+        } else {
+            // if this fails, the underlying bug is fixed and above work-around can be removed.
+            try expect(!isSignalNan(math.snan(T)));
         }
         try expect(!isSignalNan(math.nan(T)));
         try expect(!isSignalNan(@as(T, 1.0)));
         try expect(!isSignalNan(math.inf(T)));
     }
+    try expect(!isSignalNan(1.0));
 }