fix isfinite

src/include/migraphx/float8.hpp

@@ -273,9 +273,8 @@ using fp8e5m2fnuz = float8<migraphx::fp8::f8_type::bf8, true>;
 template <>
 class numeric_limits<fp8e4m3fnuz>
 {
-    static constexpr bool has_infinity = false;
-
     public:
+    static constexpr bool has_infinity = false;
     static constexpr fp8e4m3fnuz epsilon() { return fp8e4m3fnuz(0x28, fp8e4m3fnuz::from_bits()); }
     // NOLINTNEXTLINE
     static constexpr fp8e4m3fnuz quiet_NaN() { return fp8e4m3fnuz(0x80, fp8e4m3fnuz::from_bits()); }
@@ -290,9 +289,8 @@ class numeric_limits<fp8e4m3fnuz>
 template <>
 class numeric_limits<fp8e4m3fn>
 {
-    static constexpr bool has_infinity = false;
-
     public:
+    static constexpr bool has_infinity = false;
     static constexpr fp8e4m3fn epsilon() { return fp8e4m3fn(0x20, fp8e4m3fn::from_bits()); }
     // NOLINTNEXTLINE
     static constexpr fp8e4m3fn quiet_NaN() { return fp8e4m3fn(0x7F, fp8e4m3fn::from_bits()); }
@@ -307,9 +305,8 @@ class numeric_limits<fp8e4m3fn>
 template <>
 class numeric_limits<fp8e5m2fnuz>
 {
-    static constexpr bool has_infinity = false;
-
     public:
+    static constexpr bool has_infinity = false;
     static constexpr fp8e5m2fnuz epsilon() { return fp8e5m2fnuz(0x34, fp8e5m2fnuz::from_bits()); }
 
     static constexpr fp8e5m2fnuz quiet_NaN() // NOLINT
@@ -329,6 +326,7 @@ template <>
 class numeric_limits<fp8e5m2>
 {
     public:
+    static constexpr bool has_infinity = true;
     static constexpr fp8e5m2 epsilon() { return fp8e5m2(0x34, fp8e5m2::from_bits()); }
     // 7D, 7E, 7F are positive NaNs and FD, FE, FF are negative NaNs
     static constexpr fp8e5m2 quiet_NaN() { return fp8e5m2(0xFF, fp8e5m2::from_bits()); } // NOLINT

test/fp8e4m3fn.cpp

@@ -212,4 +212,18 @@ TEST_CASE(test_max_eq_lowest)
     EXPECT(migraphx::float_equal(std::numeric_limits<migraphx::fp8::fp8e4m3fn>::lowest(),
                                  -1 * std::numeric_limits<migraphx::fp8::fp8e4m3fn>::max()));
 }
+
+TEST_CASE(test_isfinite)
+{
+    EXPECT(std::isfinite(migraphx::fp8::fp8e4m3fn(0.0)));
+    EXPECT(std::isfinite(migraphx::fp8::fp8e4m3fn(-0.0)));
+    EXPECT(not std::isfinite(
+        migraphx::fp8::fp8e4m3fn(std::numeric_limits<migraphx::fp8::fp8e4m3fn>::quiet_NaN())));
+}
+
+TEST_CASE(test_no_infinity)
+{
+    EXPECT(not bool{std::numeric_limits<migraphx::fp8::fp8e4m3fn>::has_infinity});
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/fp8e4m3fnuz.cpp

@@ -227,4 +227,18 @@ TEST_CASE(test_max_eq_lowest)
     EXPECT(migraphx::float_equal(std::numeric_limits<migraphx::fp8::fp8e4m3fnuz>::lowest(),
                                  -1 * std::numeric_limits<migraphx::fp8::fp8e4m3fnuz>::max()));
 }
+
+TEST_CASE(test_isfinite)
+{
+    EXPECT(std::isfinite(migraphx::fp8::fp8e4m3fnuz(0.0)));
+    EXPECT(std::isfinite(migraphx::fp8::fp8e4m3fnuz(-0.0)));
+    EXPECT(not std::isfinite(
+        migraphx::fp8::fp8e4m3fnuz(std::numeric_limits<migraphx::fp8::fp8e4m3fnuz>::quiet_NaN())));
+}
+
+TEST_CASE(test_no_infinity)
+{
+    EXPECT(not bool{std::numeric_limits<migraphx::fp8::fp8e4m3fnuz>::has_infinity});
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/fp8e5m2.cpp

@@ -409,4 +409,17 @@ TEST_CASE(test_max_eq_lowest)
     EXPECT(migraphx::float_equal(std::numeric_limits<migraphx::fp8::fp8e5m2>::lowest(),
                                  -1 * std::numeric_limits<migraphx::fp8::fp8e5m2>::max()));
 }
+
+TEST_CASE(test_isfinite)
+{
+    EXPECT(std::isfinite(migraphx::fp8::fp8e5m2(0.0)));
+    EXPECT(std::isfinite(migraphx::fp8::fp8e5m2(-0.0)));
+    EXPECT(not std::isfinite(
+        migraphx::fp8::fp8e5m2(std::numeric_limits<migraphx::fp8::fp8e5m2>::infinity())));
+    EXPECT(not std::isfinite(
+        migraphx::fp8::fp8e5m2(-1.0 * std::numeric_limits<migraphx::fp8::fp8e5m2>::infinity())));
+    EXPECT(not std::isfinite(
+        migraphx::fp8::fp8e5m2(std::numeric_limits<migraphx::fp8::fp8e5m2>::quiet_NaN())));
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/fp8e5m2fnuz.cpp

@@ -397,4 +397,18 @@ TEST_CASE(test_max_eq_lowest)
     EXPECT(migraphx::float_equal(std::numeric_limits<migraphx::fp8::fp8e5m2fnuz>::lowest(),
                                  -1 * std::numeric_limits<migraphx::fp8::fp8e5m2fnuz>::max()));
 }
+
+TEST_CASE(test_isfinite)
+{
+    EXPECT(std::isfinite(migraphx::fp8::fp8e5m2fnuz(0.0)));
+    EXPECT(std::isfinite(migraphx::fp8::fp8e5m2fnuz(-0.0)));
+    EXPECT(not std::isfinite(
+        migraphx::fp8::fp8e5m2fnuz(std::numeric_limits<migraphx::fp8::fp8e5m2fnuz>::quiet_NaN())));
+}
+
+TEST_CASE(test_no_infinity)
+{
+    EXPECT(not bool{std::numeric_limits<migraphx::fp8::fp8e5m2fnuz>::has_infinity});
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }