================
@@ -9860,6 +9898,298 @@ TEST(APFloatTest, ConvertDoubleToE8M0FNU) {
EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
}
+TEST(APFloatTest, Float8E5M3FNUValues) {
+ // High end of the range
+ auto test = APFloat(APFloat::Float8E5M3FNU(), "0x1.c0p16");
+ EXPECT_EQ(0x1.c0p16, test.convertToDouble());
+
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.c0p15");
+ EXPECT_EQ(0x1.cp15, test.convertToDouble());
+
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p14");
+ EXPECT_EQ(0x1.0p14, test.convertToDouble());
+
+ // tests the fix in makeLargest()
+ test = APFloat::getLargest(APFloat::Float8E5M3FNU());
+ EXPECT_EQ(0x1.cp16, test.convertToDouble());
+
+ // tests overflow to nan
+ APFloat nan = APFloat(APFloat::Float8E5M3FNU(), "nan");
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.e0p+16");
+ EXPECT_TRUE(test.bitwiseIsEqual(nan));
+
+ // Mid of the range
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p0");
+ EXPECT_EQ(1.0, test.convertToDouble());
+
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p1");
+ EXPECT_EQ(2.0, test.convertToDouble());
+
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p2");
+ EXPECT_EQ(4.0, test.convertToDouble());
+
+ // Low end of the range
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-12");
+ EXPECT_EQ(0x1.0p-12, test.convertToDouble());
+
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-13");
+ EXPECT_EQ(0x1.0p-13, test.convertToDouble());
+
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-14");
+ EXPECT_EQ(0x1.0p-14, test.convertToDouble());
+ EXPECT_TRUE(test.isSmallestNormalized());
+
+ // Smallest value
+ test = APFloat::getSmallest(APFloat::Float8E5M3FNU());
+ EXPECT_EQ(0x1.0p-17, test.convertToDouble());
+
+ // Value below the smallest, but clamped to the smallest
+ test = APFloat(APFloat::Float8E5M3FNU(), "0x1.0p-18");
+ EXPECT_EQ(0, test.convertToDouble());
+}
+
+TEST(APFloatTest, Float8E5M3FNUFromString) {
+ // Exactly representable
+ EXPECT_EQ(64, APFloat(APFloat::Float8E5M3FNU(), "64").convertToDouble());
+ // Overflow to NaN
+ EXPECT_TRUE(APFloat(APFloat::Float8E5M3FNU(), "0x1.0p17").isNaN());
+ // Inf converted to NaN
+ EXPECT_TRUE(APFloat(APFloat::Float8E5M3FNU(), "inf").isNaN());
+ // NaN converted to NaN
+ EXPECT_TRUE(APFloat(APFloat::Float8E5M3FNU(), "nan").isNaN());
+}
+
+TEST(APFloatTest, Float8E5M3FNUDivideByZero) {
+ APFloat x(APFloat::Float8E5M3FNU(), "1");
+ APFloat zero(APFloat::Float8E5M3FNU(), "0");
+ EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven),
APFloat::opDivByZero);
+ EXPECT_TRUE(x.isNaN());
+}
+
+TEST(APFloatTest, Float8E5M3FNUGetSignedValues) {
+#ifdef GTEST_HAS_DEATH_TEST
+#ifndef NDEBUG
+ EXPECT_DEATH(APFloat(APFloat::Float8E5M3FNU(), "-64"),
+ "This floating point format does not support signed values");
+ EXPECT_DEATH(APFloat(APFloat::Float8E5M3FNU(), "-0x1.0p17"),
+ "This floating point format does not support signed values");
+ EXPECT_DEATH(APFloat(APFloat::Float8E5M3FNU(), "-inf"),
+ "This floating point format does not support signed values");
+ EXPECT_DEATH(APFloat::getNaN(APFloat::Float8E5M3FNU(), true),
+ "This floating point format does not support signed values");
+ EXPECT_DEATH(APFloat::getInf(APFloat::Float8E5M3FNU(), true),
+ "This floating point format does not support signed values");
+ EXPECT_DEATH(APFloat::getSmallest(APFloat::Float8E5M3FNU(), true),
+ "This floating point format does not support signed values");
+ EXPECT_DEATH(APFloat::getSmallestNormalized(APFloat::Float8E5M3FNU(), true),
+ "This floating point format does not support signed values");
+ EXPECT_DEATH(APFloat::getLargest(APFloat::Float8E5M3FNU(), true),
+ "This floating point format does not support signed values");
+ APFloat x = APFloat(APFloat::Float8E5M3FNU(), "4");
+ APFloat y = APFloat(APFloat::Float8E5M3FNU(), "8");
+ EXPECT_DEATH(x.subtract(y, APFloat::rmNearestTiesToEven),
+ "This floating point format does not support signed values");
+#endif // NDEBUG
+#endif // GTEST_HAS_DEATH_TEST
+}
+
+TEST(APFloatTest, Float8E5M3FNUGetInf) {
+ // The Float8E5M3FNU format does not support infinity and the all ones
+ // representation is treated as NaN.
+ APFloat t = APFloat::getInf(APFloat::Float8E5M3FNU());
+ EXPECT_TRUE(t.isNaN());
+ EXPECT_FALSE(t.isInfinity());
+}
+
+TEST(APFloatTest, Float8E5M3FNUSmallest) {
+ APFloat test(APFloat::getSmallest(APFloat::Float8E5M3FNU()));
+ EXPECT_EQ(0x1.0p-17, test.convertToDouble());
+
+ EXPECT_TRUE(test.isSmallest());
+ EXPECT_EQ(fcPosSubnormal, test.classify());
+
+ test = APFloat::getAllOnesValue(APFloat::Float8E5M3FNU());
+ EXPECT_TRUE(test.isNaN());
+}
+
+TEST(APFloatTest, Float8E5M3FNUExhaustivePair) {
+ APFloat::Semantics Sem = APFloat::S_Float8E5M3FNU;
+ const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
+ for (int i = 0; i < 256; ++i) {
+ for (int j = 0; j < 256; ++j) {
+ SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
+ ",j=" + std::to_string(j));
+ APFloat x(S, APInt(8, i));
+ APFloat y(S, APInt(8, j));
+
+ bool losesInfo;
+ APFloat xd = x;
+ xd.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
+ &losesInfo);
+ EXPECT_FALSE(losesInfo);
+ APFloat yd = y;
+ yd.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
+ &losesInfo);
+ EXPECT_FALSE(losesInfo);
+
+ APFloat z = x;
+ z.add(y, APFloat::rmNearestTiesToEven);
+ APFloat zd = xd;
+ zd.add(yd, APFloat::rmNearestTiesToEven);
+ zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
+ EXPECT_TRUE(z.bitwiseIsEqual(zd))
+ << "sem=" << Sem << ", i=" << i << ", j=" << j;
+
+ if (i >= j) {
+ z = x;
+ z.subtract(y, APFloat::rmNearestTiesToEven);
+ zd = xd;
+ zd.subtract(yd, APFloat::rmNearestTiesToEven);
+ zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
+ EXPECT_TRUE(z.bitwiseIsEqual(zd))
+ << "sem=" << Sem << ", i=" << i << ", j=" << j;
+ }
+
+ z = x;
+ z.multiply(y, APFloat::rmNearestTiesToEven);
+ zd = xd;
+ zd.multiply(yd, APFloat::rmNearestTiesToEven);
+ zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
+ EXPECT_TRUE(z.bitwiseIsEqual(zd))
+ << "sem=" << Sem << ", i=" << i << ", j=" << j;
+
+ z = x;
+ z.divide(y, APFloat::rmNearestTiesToEven);
+ zd = xd;
+ zd.divide(yd, APFloat::rmNearestTiesToEven);
+ zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
+ EXPECT_TRUE(z.bitwiseIsEqual(zd))
+ << "sem=" << Sem << ", i=" << i << ", j=" << j;
+
+ z = x;
+ z.mod(y);
+ zd = xd;
+ zd.mod(yd);
+ zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
+ EXPECT_TRUE(z.bitwiseIsEqual(zd))
+ << "sem=" << Sem << ", i=" << i << ", j=" << j;
+
+ // Remainder: IEEE remainder can produce negative results, which this
+ // unsigned format cannot represent. Only test when the reference
+ // result is non-negative.
+ zd = xd;
+ zd.remainder(yd);
+ if (!zd.isNegative()) {
+ z = x;
+ z.remainder(y);
+ zd.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
+ EXPECT_TRUE(z.bitwiseIsEqual(zd))
+ << "sem=" << Sem << ", i=" << i << ", j=" << j;
+ }
+ }
+ }
+}
+
+TEST(APFloatTest, Float8E5M3FNUExhaustive) {
+ // Test each of the 256 Float8E5M3FNU values.
+ // Layout: 5 exponent bits + 3 mantissa bits, bias = 15, NaN = 0xFF
+ // (all-ones).
----------------
durga4github wrote:
Lines 10095/10096 not required.
https://github.com/llvm/llvm-project/pull/210720
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
