[libc-commits] [libc] 01b99c6 - [libc][obvious] Switch nearest integer function tests to the new matchers.
Siva Chandra via libc-commits
libc-commits at lists.llvm.org
Tue Aug 11 23:34:03 PDT 2020
Author: Siva Chandra
Date: 2020-08-11T23:33:15-07:00
New Revision: 01b99c6e1d96467ab1b78a5beebc20eb7f04ab96
URL: https://github.com/llvm/llvm-project/commit/01b99c6e1d96467ab1b78a5beebc20eb7f04ab96
DIFF: https://github.com/llvm/llvm-project/commit/01b99c6e1d96467ab1b78a5beebc20eb7f04ab96.diff
LOG: [libc][obvious] Switch nearest integer function tests to the new matchers.
Added:
Modified:
libc/test/src/math/ceil_test.cpp
libc/test/src/math/ceilf_test.cpp
libc/test/src/math/ceill_test.cpp
libc/test/src/math/floor_test.cpp
libc/test/src/math/floorf_test.cpp
libc/test/src/math/floorl_test.cpp
libc/test/src/math/round_test.cpp
libc/test/src/math/roundf_test.cpp
libc/test/src/math/roundl_test.cpp
libc/test/src/math/trunc_test.cpp
libc/test/src/math/truncf_test.cpp
libc/test/src/math/truncl_test.cpp
Removed:
################################################################################
diff --git a/libc/test/src/math/ceil_test.cpp b/libc/test/src/math/ceil_test.cpp
index fdb45a81db97..e012655638ab 100644
--- a/libc/test/src/math/ceil_test.cpp
+++ b/libc/test/src/math/ceil_test.cpp
@@ -8,67 +8,76 @@
#include "include/math.h"
#include "src/math/ceil.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
-using Properties = __llvm_libc::fputil::FloatProperties<double>;
+using FPBits = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const double zero = FPBits::zero();
+static const double negZero = FPBits::negZero();
+static const double nan = FPBits::buildNaN(1);
+static const double inf = FPBits::inf();
+static const double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
+TEST(CeilTest, SpecialNumbers) {
+ EXPECT_FP_EQ(zero, __llvm_libc::ceil(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::ceil(negZero));
-TEST(ceilTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::ceil(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::ceil(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
-
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(
- __llvm_libc::ceil(valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::ceil(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(inf, __llvm_libc::ceil(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::ceil(negInf));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::ceil(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf,
- valueAsBits(__llvm_libc::ceil(valueFromBits(BitPatterns::negInf))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::ceil(nan)), 0);
+}
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::ceil(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::ceil(
- valueFromBits(BitPatterns::negZero))));
+TEST(CeilTest, RoundedNumbers) {
+ EXPECT_FP_EQ(1.0, __llvm_libc::ceil(1.0));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.0));
+ EXPECT_FP_EQ(10.0, __llvm_libc::ceil(10.0));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::ceil(-10.0));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::ceil(1234.0));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.0));
}
-TEST(ceilTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::ceil(1.0)));
- EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::ceil(-1.0)));
- EXPECT_EQ(valueAsBits(10.0), valueAsBits(__llvm_libc::ceil(10.0)));
- EXPECT_EQ(valueAsBits(-10.0), valueAsBits(__llvm_libc::ceil(-10.0)));
- EXPECT_EQ(valueAsBits(12345.0), valueAsBits(__llvm_libc::ceil(12345.0)));
- EXPECT_EQ(valueAsBits(-12345.0), valueAsBits(__llvm_libc::ceil(-12345.0)));
+TEST(CeilTest, Fractions) {
+ EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.5));
+ EXPECT_FP_EQ(-0.0, __llvm_libc::ceil(-0.5));
+ EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.115));
+ EXPECT_FP_EQ(-0.0, __llvm_libc::ceil(-0.115));
+ EXPECT_FP_EQ(1.0, __llvm_libc::ceil(0.715));
+ EXPECT_FP_EQ(-0.0, __llvm_libc::ceil(-0.715));
+ EXPECT_FP_EQ(2.0, __llvm_libc::ceil(1.3));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.3));
+ EXPECT_FP_EQ(2.0, __llvm_libc::ceil(1.5));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.5));
+ EXPECT_FP_EQ(2.0, __llvm_libc::ceil(1.75));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::ceil(-1.75));
+ EXPECT_FP_EQ(11.0, __llvm_libc::ceil(10.32));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::ceil(-10.32));
+ EXPECT_FP_EQ(11.0, __llvm_libc::ceil(10.65));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::ceil(-10.65));
+ EXPECT_FP_EQ(1235.0, __llvm_libc::ceil(1234.38));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.38));
+ EXPECT_FP_EQ(1235.0, __llvm_libc::ceil(1234.96));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::ceil(-1234.96));
}
-TEST(ceilTest, InDoubleRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT64_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+TEST(CeilTest, InDoubleRange) {
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceil(x),
tolerance);
}
diff --git a/libc/test/src/math/ceilf_test.cpp b/libc/test/src/math/ceilf_test.cpp
index 3db004e65542..2ad3770fcb9a 100644
--- a/libc/test/src/math/ceilf_test.cpp
+++ b/libc/test/src/math/ceilf_test.cpp
@@ -8,67 +8,76 @@
#include "include/math.h"
#include "src/math/ceilf.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
-using Properties = __llvm_libc::fputil::FloatProperties<float>;
+using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const float zero = FPBits::zero();
+static const float negZero = FPBits::negZero();
+static const float nan = FPBits::buildNaN(1);
+static const float inf = FPBits::inf();
+static const float negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
TEST(CeilfTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::ceilf(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::ceilf(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
-
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(__llvm_libc::ceilf(
- valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::ceilf(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(zero, __llvm_libc::ceilf(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::ceilf(negZero));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::ceilf(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::ceilf(
- valueFromBits(BitPatterns::negInf))));
+ EXPECT_FP_EQ(inf, __llvm_libc::ceilf(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::ceilf(negInf));
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::ceilf(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::ceilf(
- valueFromBits(BitPatterns::negZero))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::ceilf(nan)), 0);
}
TEST(CeilfTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::ceilf(1.0f)));
- EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::ceilf(-1.0f)));
- EXPECT_EQ(valueAsBits(10.0f), valueAsBits(__llvm_libc::ceilf(10.0f)));
- EXPECT_EQ(valueAsBits(-10.0f), valueAsBits(__llvm_libc::ceilf(-10.0f)));
- EXPECT_EQ(valueAsBits(12345.0f), valueAsBits(__llvm_libc::ceilf(12345.0f)));
- EXPECT_EQ(valueAsBits(-12345.0f), valueAsBits(__llvm_libc::ceilf(-12345.0f)));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(1.0f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.0f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::ceilf(10.0f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::ceilf(-10.0f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::ceilf(1234.0f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.0f));
+}
+
+TEST(CeilfTest, Fractions) {
+ EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.5f));
+ EXPECT_FP_EQ(-0.0f, __llvm_libc::ceilf(-0.5f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.115f));
+ EXPECT_FP_EQ(-0.0f, __llvm_libc::ceilf(-0.115f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::ceilf(0.715f));
+ EXPECT_FP_EQ(-0.0f, __llvm_libc::ceilf(-0.715f));
+ EXPECT_FP_EQ(2.0f, __llvm_libc::ceilf(1.3f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.3f));
+ EXPECT_FP_EQ(2.0f, __llvm_libc::ceilf(1.5f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.5f));
+ EXPECT_FP_EQ(2.0f, __llvm_libc::ceilf(1.75f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::ceilf(-1.75f));
+ EXPECT_FP_EQ(11.0f, __llvm_libc::ceilf(10.32f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::ceilf(-10.32f));
+ EXPECT_FP_EQ(11.0f, __llvm_libc::ceilf(10.65f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::ceilf(-10.65f));
+ EXPECT_FP_EQ(1235.0f, __llvm_libc::ceilf(1234.38f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.38f));
+ EXPECT_FP_EQ(1235.0f, __llvm_libc::ceilf(1234.96f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::ceilf(-1234.96f));
}
TEST(CeilfTest, InFloatRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT32_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 1000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ float x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceilf(x),
tolerance);
}
diff --git a/libc/test/src/math/ceill_test.cpp b/libc/test/src/math/ceill_test.cpp
index 6be34a23db3c..ad1e16b57359 100644
--- a/libc/test/src/math/ceill_test.cpp
+++ b/libc/test/src/math/ceill_test.cpp
@@ -9,6 +9,7 @@
#include "include/math.h"
#include "src/math/ceill.h"
#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
@@ -16,45 +17,56 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const long double zero = FPBits::zero();
+static const long double negZero = FPBits::negZero();
+static const long double nan = FPBits::buildNaN(1);
+static const long double inf = FPBits::inf();
+static const long double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
TEST(CeillTest, SpecialNumbers) {
- ASSERT_TRUE(FPBits::zero() == __llvm_libc::ceill(FPBits::zero()));
- ASSERT_TRUE(FPBits::negZero() == __llvm_libc::ceill(FPBits::negZero()));
+ EXPECT_FP_EQ(zero, __llvm_libc::ceill(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::ceill(negZero));
- ASSERT_TRUE(FPBits::inf() == __llvm_libc::ceill(FPBits::inf()));
- ASSERT_TRUE(FPBits::negInf() == __llvm_libc::ceill(FPBits::negInf()));
+ EXPECT_FP_EQ(inf, __llvm_libc::ceill(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::ceill(negInf));
- long double nan = FPBits::buildNaN(1);
ASSERT_NE(isnan(nan), 0);
ASSERT_NE(isnan(__llvm_libc::ceill(nan)), 0);
}
TEST(CeillTest, RoundedNumbers) {
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::ceill(1.0l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.0l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::ceill(10.0l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::ceill(-10.0l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::ceill(1234.0l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::ceill(-1234.0l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(1.0l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.0l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::ceill(10.0l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.0l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::ceill(1234.0l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.0l));
}
TEST(CeillTest, Fractions) {
- ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::ceill(1.3l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.3l));
- ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::ceill(1.5l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.5l));
- ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::ceill(1.75l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::ceill(-1.75l));
- ASSERT_TRUE(FPBits(11.0l) == __llvm_libc::ceill(10.32l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::ceill(-10.32l));
- ASSERT_TRUE(FPBits(11.0l) == __llvm_libc::ceill(10.65l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::ceill(-10.65l));
- ASSERT_TRUE(FPBits(1235.0l) == __llvm_libc::ceill(1234.18l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::ceill(-1234.18l));
- ASSERT_TRUE(FPBits(1235.0l) == __llvm_libc::ceill(1234.96l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::ceill(-1234.96l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::ceill(0.5l));
+ EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.5l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::ceill(0.115l));
+ EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.115l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::ceill(0.715l));
+ EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.715l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(1.3l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.3l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(1.5l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.5l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(1.75l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.75l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::ceill(10.32l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.32l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::ceill(10.65l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.65l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::ceill(1234.38l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.38l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::ceill(1234.96l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.96l));
}
TEST(CeillTest, InLongDoubleRange) {
diff --git a/libc/test/src/math/floor_test.cpp b/libc/test/src/math/floor_test.cpp
index a45d75710b8a..34b9bec11858 100644
--- a/libc/test/src/math/floor_test.cpp
+++ b/libc/test/src/math/floor_test.cpp
@@ -8,67 +8,76 @@
#include "include/math.h"
#include "src/math/floor.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
-using Properties = __llvm_libc::fputil::FloatProperties<double>;
+using FPBits = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const double zero = FPBits::zero();
+static const double negZero = FPBits::negZero();
+static const double nan = FPBits::buildNaN(1);
+static const double inf = FPBits::inf();
+static const double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
TEST(FloorTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::floor(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::floor(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
+ EXPECT_FP_EQ(zero, __llvm_libc::floor(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::floor(negZero));
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(__llvm_libc::floor(
- valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::floor(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(inf, __llvm_libc::floor(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::floor(negInf));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::floor(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::floor(
- valueFromBits(BitPatterns::negInf))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::floor(nan)), 0);
+}
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::floor(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::floor(
- valueFromBits(BitPatterns::negZero))));
+TEST(FloorTest, RoundedNumbers) {
+ EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.0));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-1.0));
+ EXPECT_FP_EQ(10.0, __llvm_libc::floor(10.0));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::floor(-10.0));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::floor(1234.0));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::floor(-1234.0));
}
-TEST(floorTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::floor(1.0)));
- EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::floor(-1.0)));
- EXPECT_EQ(valueAsBits(10.0), valueAsBits(__llvm_libc::floor(10.0)));
- EXPECT_EQ(valueAsBits(-10.0), valueAsBits(__llvm_libc::floor(-10.0)));
- EXPECT_EQ(valueAsBits(12345.0), valueAsBits(__llvm_libc::floor(12345.0)));
- EXPECT_EQ(valueAsBits(-12345.0), valueAsBits(__llvm_libc::floor(-12345.0)));
+TEST(FloorTest, Fractions) {
+ EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.5));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-0.5));
+ EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.115));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-0.115));
+ EXPECT_FP_EQ(0.0, __llvm_libc::floor(0.715));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::floor(-0.715));
+ EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.3));
+ EXPECT_FP_EQ(-2.0, __llvm_libc::floor(-1.3));
+ EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.5));
+ EXPECT_FP_EQ(-2.0, __llvm_libc::floor(-1.5));
+ EXPECT_FP_EQ(1.0, __llvm_libc::floor(1.75));
+ EXPECT_FP_EQ(-2.0, __llvm_libc::floor(-1.75));
+ EXPECT_FP_EQ(10.0, __llvm_libc::floor(10.32));
+ EXPECT_FP_EQ(-11.0, __llvm_libc::floor(-10.32));
+ EXPECT_FP_EQ(10.0, __llvm_libc::floor(10.65));
+ EXPECT_FP_EQ(-11.0, __llvm_libc::floor(-10.65));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::floor(1234.38));
+ EXPECT_FP_EQ(-1235.0, __llvm_libc::floor(-1234.38));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::floor(1234.96));
+ EXPECT_FP_EQ(-1235.0, __llvm_libc::floor(-1234.96));
}
-TEST(floorTest, InDoubleRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT64_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+TEST(FloorTest, InDoubleRange) {
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floor(x),
tolerance);
}
diff --git a/libc/test/src/math/floorf_test.cpp b/libc/test/src/math/floorf_test.cpp
index 1e05dcfccd1d..0eb6b1f3bda3 100644
--- a/libc/test/src/math/floorf_test.cpp
+++ b/libc/test/src/math/floorf_test.cpp
@@ -8,68 +8,76 @@
#include "include/math.h"
#include "src/math/floorf.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
-using Properties = __llvm_libc::fputil::FloatProperties<float>;
+using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const float zero = FPBits::zero();
+static const float negZero = FPBits::negZero();
+static const float nan = FPBits::buildNaN(1);
+static const float inf = FPBits::inf();
+static const float negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
TEST(FloorfTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::floorf(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::floorf(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
-
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(__llvm_libc::floorf(
- valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::floorf(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(zero, __llvm_libc::floorf(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::floorf(negZero));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::floorf(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::floorf(
- valueFromBits(BitPatterns::negInf))));
+ EXPECT_FP_EQ(inf, __llvm_libc::floorf(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::floorf(negInf));
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::floorf(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::floorf(
- valueFromBits(BitPatterns::negZero))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::floorf(nan)), 0);
}
TEST(FloorfTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::floorf(1.0f)));
- EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::floorf(-1.0f)));
- EXPECT_EQ(valueAsBits(10.0f), valueAsBits(__llvm_libc::floorf(10.0f)));
- EXPECT_EQ(valueAsBits(-10.0f), valueAsBits(__llvm_libc::floorf(-10.0f)));
- EXPECT_EQ(valueAsBits(12345.0f), valueAsBits(__llvm_libc::floorf(12345.0f)));
- EXPECT_EQ(valueAsBits(-12345.0f),
- valueAsBits(__llvm_libc::floorf(-12345.0f)));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.0f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-1.0f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::floorf(10.0f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::floorf(-10.0f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::floorf(1234.0f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::floorf(-1234.0f));
+}
+
+TEST(FloorfTest, Fractions) {
+ EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.5f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-0.5f));
+ EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.115f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-0.115f));
+ EXPECT_FP_EQ(0.0f, __llvm_libc::floorf(0.715f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::floorf(-0.715f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.3f));
+ EXPECT_FP_EQ(-2.0f, __llvm_libc::floorf(-1.3f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.5f));
+ EXPECT_FP_EQ(-2.0f, __llvm_libc::floorf(-1.5f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::floorf(1.75f));
+ EXPECT_FP_EQ(-2.0f, __llvm_libc::floorf(-1.75f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::floorf(10.32f));
+ EXPECT_FP_EQ(-11.0f, __llvm_libc::floorf(-10.32f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::floorf(10.65f));
+ EXPECT_FP_EQ(-11.0f, __llvm_libc::floorf(-10.65f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::floorf(1234.38f));
+ EXPECT_FP_EQ(-1235.0f, __llvm_libc::floorf(-1234.38f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::floorf(1234.96f));
+ EXPECT_FP_EQ(-1235.0f, __llvm_libc::floorf(-1234.96f));
}
TEST(FloorfTest, InFloatRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT32_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 1000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ float x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorf(x),
tolerance);
}
diff --git a/libc/test/src/math/floorl_test.cpp b/libc/test/src/math/floorl_test.cpp
index e7c9513245af..3ed2435f3f48 100644
--- a/libc/test/src/math/floorl_test.cpp
+++ b/libc/test/src/math/floorl_test.cpp
@@ -9,6 +9,7 @@
#include "include/math.h"
#include "src/math/floorl.h"
#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
@@ -16,45 +17,56 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const long double zero = FPBits::zero();
+static const long double negZero = FPBits::negZero();
+static const long double nan = FPBits::buildNaN(1);
+static const long double inf = FPBits::inf();
+static const long double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
TEST(FloorlTest, SpecialNumbers) {
- ASSERT_TRUE(FPBits::zero() == __llvm_libc::floorl(FPBits::zero()));
- ASSERT_TRUE(FPBits::negZero() == __llvm_libc::floorl(FPBits::negZero()));
+ EXPECT_FP_EQ(zero, __llvm_libc::floorl(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::floorl(negZero));
- ASSERT_TRUE(FPBits::inf() == __llvm_libc::floorl(FPBits::inf()));
- ASSERT_TRUE(FPBits::negInf() == __llvm_libc::floorl(FPBits::negInf()));
+ EXPECT_FP_EQ(inf, __llvm_libc::floorl(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::floorl(negInf));
- long double nan = FPBits::buildNaN(1);
ASSERT_NE(isnan(nan), 0);
ASSERT_NE(isnan(__llvm_libc::floorl(nan)), 0);
}
TEST(FloorlTest, RoundedNumbers) {
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.0l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::floorl(-1.0l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::floorl(10.0l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::floorl(-10.0l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::floorl(1234.0l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::floorl(-1234.0l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.0l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-1.0l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::floorl(10.0l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::floorl(-10.0l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::floorl(1234.0l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::floorl(-1234.0l));
}
TEST(FloorlTest, Fractions) {
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.3l));
- ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::floorl(-1.3l));
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.5l));
- ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::floorl(-1.5l));
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::floorl(1.75l));
- ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::floorl(-1.75l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::floorl(10.32l));
- ASSERT_TRUE(FPBits(-11.0l) == __llvm_libc::floorl(-10.32l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::floorl(10.65l));
- ASSERT_TRUE(FPBits(-11.0l) == __llvm_libc::floorl(-10.65l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::floorl(1234.18l));
- ASSERT_TRUE(FPBits(-1235.0l) == __llvm_libc::floorl(-1234.18l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::floorl(1234.96l));
- ASSERT_TRUE(FPBits(-1235.0l) == __llvm_libc::floorl(-1234.96l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.5l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-0.5l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.115l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-0.115l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::floorl(0.715l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::floorl(-0.715l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.3l));
+ EXPECT_FP_EQ(-2.0l, __llvm_libc::floorl(-1.3l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.5l));
+ EXPECT_FP_EQ(-2.0l, __llvm_libc::floorl(-1.5l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::floorl(1.75l));
+ EXPECT_FP_EQ(-2.0l, __llvm_libc::floorl(-1.75l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::floorl(10.32l));
+ EXPECT_FP_EQ(-11.0l, __llvm_libc::floorl(-10.32l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::floorl(10.65l));
+ EXPECT_FP_EQ(-11.0l, __llvm_libc::floorl(-10.65l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::floorl(1234.38l));
+ EXPECT_FP_EQ(-1235.0l, __llvm_libc::floorl(-1234.38l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::floorl(1234.96l));
+ EXPECT_FP_EQ(-1235.0l, __llvm_libc::floorl(-1234.96l));
}
TEST(FloorlTest, InLongDoubleRange) {
diff --git a/libc/test/src/math/round_test.cpp b/libc/test/src/math/round_test.cpp
index 9816b1feea7c..0cfaead1dc3b 100644
--- a/libc/test/src/math/round_test.cpp
+++ b/libc/test/src/math/round_test.cpp
@@ -8,76 +8,76 @@
#include "include/math.h"
#include "src/math/round.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
-using Properties = __llvm_libc::fputil::FloatProperties<double>;
+using FPBits = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const double zero = FPBits::zero();
+static const double negZero = FPBits::negZero();
+static const double nan = FPBits::buildNaN(1);
+static const double inf = FPBits::inf();
+static const double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
TEST(RoundTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::round(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::round(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
+ EXPECT_FP_EQ(zero, __llvm_libc::round(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::round(negZero));
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(__llvm_libc::round(
- valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::round(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(inf, __llvm_libc::round(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::round(negInf));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::round(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::round(
- valueFromBits(BitPatterns::negInf))));
-
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::round(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::round(
- valueFromBits(BitPatterns::negZero))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::round(nan)), 0);
}
TEST(RoundTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::round(1.0)));
- EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::round(-1.0)));
- EXPECT_EQ(valueAsBits(10.0), valueAsBits(__llvm_libc::round(10.0)));
- EXPECT_EQ(valueAsBits(-10.0), valueAsBits(__llvm_libc::round(-10.0)));
- EXPECT_EQ(valueAsBits(12345.0), valueAsBits(__llvm_libc::round(12345.0)));
- EXPECT_EQ(valueAsBits(-12345.0), valueAsBits(__llvm_libc::round(-12345.0)));
+ EXPECT_FP_EQ(1.0, __llvm_libc::round(1.0));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::round(-1.0));
+ EXPECT_FP_EQ(10.0, __llvm_libc::round(10.0));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::round(-10.0));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::round(1234.0));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::round(-1234.0));
}
-TEST(RoundTest, CloseToZeroNumbers) {
- EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::round(0.5)));
- EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::round(-0.5)));
- EXPECT_EQ(valueAsBits(0.0), valueAsBits(__llvm_libc::round(0.115)));
- EXPECT_EQ(valueAsBits(-0.0), valueAsBits(__llvm_libc::round(-0.115)));
- EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::round(0.715)));
- EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::round(-0.715)));
+TEST(RoundTest, Fractions) {
+ EXPECT_FP_EQ(1.0, __llvm_libc::round(0.5));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::round(-0.5));
+ EXPECT_FP_EQ(0.0, __llvm_libc::round(0.115));
+ EXPECT_FP_EQ(-0.0, __llvm_libc::round(-0.115));
+ EXPECT_FP_EQ(1.0, __llvm_libc::round(0.715));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::round(-0.715));
+ EXPECT_FP_EQ(1.0, __llvm_libc::round(1.3));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::round(-1.3));
+ EXPECT_FP_EQ(2.0, __llvm_libc::round(1.5));
+ EXPECT_FP_EQ(-2.0, __llvm_libc::round(-1.5));
+ EXPECT_FP_EQ(2.0, __llvm_libc::round(1.75));
+ EXPECT_FP_EQ(-2.0, __llvm_libc::round(-1.75));
+ EXPECT_FP_EQ(10.0, __llvm_libc::round(10.32));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::round(-10.32));
+ EXPECT_FP_EQ(11.0, __llvm_libc::round(10.65));
+ EXPECT_FP_EQ(-11.0, __llvm_libc::round(-10.65));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::round(1234.38));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::round(-1234.38));
+ EXPECT_FP_EQ(1235.0, __llvm_libc::round(1234.96));
+ EXPECT_FP_EQ(-1235.0, __llvm_libc::round(-1234.96));
}
TEST(RoundTest, InDoubleRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT64_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::round(x),
tolerance);
}
diff --git a/libc/test/src/math/roundf_test.cpp b/libc/test/src/math/roundf_test.cpp
index ae8008a0340f..6771b3fd2288 100644
--- a/libc/test/src/math/roundf_test.cpp
+++ b/libc/test/src/math/roundf_test.cpp
@@ -8,77 +8,76 @@
#include "include/math.h"
#include "src/math/roundf.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
-using Properties = __llvm_libc::fputil::FloatProperties<float>;
+using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const float zero = FPBits::zero();
+static const float negZero = FPBits::negZero();
+static const float nan = FPBits::buildNaN(1);
+static const float inf = FPBits::inf();
+static const float negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
TEST(RoundfTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::roundf(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::roundf(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
+ EXPECT_FP_EQ(zero, __llvm_libc::roundf(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::roundf(negZero));
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(__llvm_libc::roundf(
- valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::roundf(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(inf, __llvm_libc::roundf(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::roundf(negInf));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::roundf(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::roundf(
- valueFromBits(BitPatterns::negInf))));
-
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::roundf(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::roundf(
- valueFromBits(BitPatterns::negZero))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::roundf(nan)), 0);
}
TEST(RoundfTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::roundf(1.0f)));
- EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::roundf(-1.0f)));
- EXPECT_EQ(valueAsBits(10.0f), valueAsBits(__llvm_libc::roundf(10.0f)));
- EXPECT_EQ(valueAsBits(-10.0f), valueAsBits(__llvm_libc::roundf(-10.0f)));
- EXPECT_EQ(valueAsBits(12345.0f), valueAsBits(__llvm_libc::roundf(12345.0f)));
- EXPECT_EQ(valueAsBits(-12345.0f),
- valueAsBits(__llvm_libc::roundf(-12345.0f)));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(1.0f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-1.0f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::roundf(10.0f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::roundf(-10.0f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::roundf(1234.0f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::roundf(-1234.0f));
}
-TEST(RoundfTest, CloseToZeroNumbers) {
- EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::roundf(0.5f)));
- EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::roundf(-0.5f)));
- EXPECT_EQ(valueAsBits(0.0f), valueAsBits(__llvm_libc::roundf(0.115f)));
- EXPECT_EQ(valueAsBits(-0.0f), valueAsBits(__llvm_libc::roundf(-0.115f)));
- EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::roundf(0.715f)));
- EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::roundf(-0.715f)));
+TEST(RoundfTest, Fractions) {
+ EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(0.5f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-0.5f));
+ EXPECT_FP_EQ(0.0f, __llvm_libc::roundf(0.115f));
+ EXPECT_FP_EQ(-0.0f, __llvm_libc::roundf(-0.115f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(0.715f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-0.715f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::roundf(1.3f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::roundf(-1.3f));
+ EXPECT_FP_EQ(2.0f, __llvm_libc::roundf(1.5f));
+ EXPECT_FP_EQ(-2.0f, __llvm_libc::roundf(-1.5f));
+ EXPECT_FP_EQ(2.0f, __llvm_libc::roundf(1.75f));
+ EXPECT_FP_EQ(-2.0f, __llvm_libc::roundf(-1.75f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::roundf(10.32f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::roundf(-10.32f));
+ EXPECT_FP_EQ(11.0f, __llvm_libc::roundf(10.65f));
+ EXPECT_FP_EQ(-11.0f, __llvm_libc::roundf(-10.65f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::roundf(1234.38f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::roundf(-1234.38f));
+ EXPECT_FP_EQ(1235.0f, __llvm_libc::roundf(1234.96f));
+ EXPECT_FP_EQ(-1235.0f, __llvm_libc::roundf(-1234.96f));
}
TEST(RoundfTest, InFloatRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT32_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 1000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ float x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundf(x),
tolerance);
}
diff --git a/libc/test/src/math/roundl_test.cpp b/libc/test/src/math/roundl_test.cpp
index 38545a842d15..ff5d799319f4 100644
--- a/libc/test/src/math/roundl_test.cpp
+++ b/libc/test/src/math/roundl_test.cpp
@@ -9,6 +9,7 @@
#include "include/math.h"
#include "src/math/roundl.h"
#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
@@ -16,45 +17,56 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const long double zero = FPBits::zero();
+static const long double negZero = FPBits::negZero();
+static const long double nan = FPBits::buildNaN(1);
+static const long double inf = FPBits::inf();
+static const long double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
TEST(RoundlTest, SpecialNumbers) {
- ASSERT_TRUE(FPBits::zero() == __llvm_libc::roundl(FPBits::zero()));
- ASSERT_TRUE(FPBits::negZero() == __llvm_libc::roundl(FPBits::negZero()));
+ EXPECT_FP_EQ(zero, __llvm_libc::roundl(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::roundl(negZero));
- ASSERT_TRUE(FPBits::inf() == __llvm_libc::roundl(FPBits::inf()));
- ASSERT_TRUE(FPBits::negInf() == __llvm_libc::roundl(FPBits::negInf()));
+ EXPECT_FP_EQ(inf, __llvm_libc::roundl(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::roundl(negInf));
- long double nan = FPBits::buildNaN(1);
ASSERT_NE(isnan(nan), 0);
ASSERT_NE(isnan(__llvm_libc::roundl(nan)), 0);
}
TEST(RoundlTest, RoundedNumbers) {
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::roundl(1.0l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::roundl(-1.0l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::roundl(10.0l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::roundl(-10.0l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::roundl(1234.0l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::roundl(-1234.0l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(1.0l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-1.0l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::roundl(10.0l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::roundl(-10.0l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::roundl(1234.0l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::roundl(-1234.0l));
}
TEST(RoundlTest, Fractions) {
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::roundl(1.3l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::roundl(-1.3l));
- ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::roundl(1.5l));
- ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::roundl(-1.5l));
- ASSERT_TRUE(FPBits(2.0l) == __llvm_libc::roundl(1.75l));
- ASSERT_TRUE(FPBits(-2.0l) == __llvm_libc::roundl(-1.75l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::roundl(10.32l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::roundl(-10.32l));
- ASSERT_TRUE(FPBits(11.0l) == __llvm_libc::roundl(10.65l));
- ASSERT_TRUE(FPBits(-11.0l) == __llvm_libc::roundl(-10.65l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::roundl(1234.38l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::roundl(-1234.38l));
- ASSERT_TRUE(FPBits(1235.0l) == __llvm_libc::roundl(1234.96l));
- ASSERT_TRUE(FPBits(-1235.0l) == __llvm_libc::roundl(-1234.96l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(0.5l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-0.5l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::roundl(0.115l));
+ EXPECT_FP_EQ(-0.0l, __llvm_libc::roundl(-0.115l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(0.715l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-0.715l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::roundl(1.3l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::roundl(-1.3l));
+ EXPECT_FP_EQ(2.0l, __llvm_libc::roundl(1.5l));
+ EXPECT_FP_EQ(-2.0l, __llvm_libc::roundl(-1.5l));
+ EXPECT_FP_EQ(2.0l, __llvm_libc::roundl(1.75l));
+ EXPECT_FP_EQ(-2.0l, __llvm_libc::roundl(-1.75l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::roundl(10.32l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::roundl(-10.32l));
+ EXPECT_FP_EQ(11.0l, __llvm_libc::roundl(10.65l));
+ EXPECT_FP_EQ(-11.0l, __llvm_libc::roundl(-10.65l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::roundl(1234.38l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::roundl(-1234.38l));
+ EXPECT_FP_EQ(1235.0l, __llvm_libc::roundl(1234.96l));
+ EXPECT_FP_EQ(-1235.0l, __llvm_libc::roundl(-1234.96l));
}
TEST(RoundlTest, InLongDoubleRange) {
diff --git a/libc/test/src/math/trunc_test.cpp b/libc/test/src/math/trunc_test.cpp
index 55f34a649e9f..855492ab4cb8 100644
--- a/libc/test/src/math/trunc_test.cpp
+++ b/libc/test/src/math/trunc_test.cpp
@@ -8,67 +8,76 @@
#include "include/math.h"
#include "src/math/trunc.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
-using Properties = __llvm_libc::fputil::FloatProperties<double>;
+using FPBits = __llvm_libc::fputil::FPBits<double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const double zero = FPBits::zero();
+static const double negZero = FPBits::negZero();
+static const double nan = FPBits::buildNaN(1);
+static const double inf = FPBits::inf();
+static const double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
-static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
+static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
TEST(TruncTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::trunc(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::trunc(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
-
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(__llvm_libc::trunc(
- valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::trunc(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(zero, __llvm_libc::trunc(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::trunc(negZero));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::trunc(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::trunc(
- valueFromBits(BitPatterns::negInf))));
+ EXPECT_FP_EQ(inf, __llvm_libc::trunc(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::trunc(negInf));
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::trunc(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::trunc(
- valueFromBits(BitPatterns::negZero))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::trunc(nan)), 0);
}
TEST(TruncTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::trunc(1.0)));
- EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::trunc(-1.0)));
- EXPECT_EQ(valueAsBits(10.0), valueAsBits(__llvm_libc::trunc(10.0)));
- EXPECT_EQ(valueAsBits(-10.0), valueAsBits(__llvm_libc::trunc(-10.0)));
- EXPECT_EQ(valueAsBits(12345.0), valueAsBits(__llvm_libc::trunc(12345.0)));
- EXPECT_EQ(valueAsBits(-12345.0), valueAsBits(__llvm_libc::trunc(-12345.0)));
+ EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.0));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.0));
+ EXPECT_FP_EQ(10.0, __llvm_libc::trunc(10.0));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::trunc(-10.0));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::trunc(1234.0));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.0));
}
-TEST(truncTest, InDoubleRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT64_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+TEST(TruncTest, Fractions) {
+ EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.5));
+ EXPECT_FP_EQ(-0.0, __llvm_libc::trunc(-0.5));
+ EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.115));
+ EXPECT_FP_EQ(-0.0, __llvm_libc::trunc(-0.115));
+ EXPECT_FP_EQ(0.0, __llvm_libc::trunc(0.715));
+ EXPECT_FP_EQ(-0.0, __llvm_libc::trunc(-0.715));
+ EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.3));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.3));
+ EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.5));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.5));
+ EXPECT_FP_EQ(1.0, __llvm_libc::trunc(1.75));
+ EXPECT_FP_EQ(-1.0, __llvm_libc::trunc(-1.75));
+ EXPECT_FP_EQ(10.0, __llvm_libc::trunc(10.32));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::trunc(-10.32));
+ EXPECT_FP_EQ(10.0, __llvm_libc::trunc(10.65));
+ EXPECT_FP_EQ(-10.0, __llvm_libc::trunc(-10.65));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::trunc(1234.38));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.38));
+ EXPECT_FP_EQ(1234.0, __llvm_libc::trunc(1234.96));
+ EXPECT_FP_EQ(-1234.0, __llvm_libc::trunc(-1234.96));
+}
+
+TEST(TruncTest, InDoubleRange) {
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 10000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::trunc(x),
tolerance);
}
diff --git a/libc/test/src/math/truncf_test.cpp b/libc/test/src/math/truncf_test.cpp
index 2ace51632af7..a87cb14b1503 100644
--- a/libc/test/src/math/truncf_test.cpp
+++ b/libc/test/src/math/truncf_test.cpp
@@ -8,69 +8,76 @@
#include "include/math.h"
#include "src/math/truncf.h"
-#include "utils/FPUtil/BitPatterns.h"
-#include "utils/FPUtil/FloatOperations.h"
-#include "utils/FPUtil/FloatProperties.h"
+#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
-using __llvm_libc::fputil::valueAsBits;
-using __llvm_libc::fputil::valueFromBits;
-
-using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
-using Properties = __llvm_libc::fputil::FloatProperties<float>;
+using FPBits = __llvm_libc::fputil::FPBits<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const float zero = FPBits::zero();
+static const float negZero = FPBits::negZero();
+static const float nan = FPBits::buildNaN(1);
+static const float inf = FPBits::inf();
+static const float negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
-namespace mpfr = __llvm_libc::testing::mpfr;
TEST(TruncfTest, SpecialNumbers) {
- EXPECT_EQ(
- BitPatterns::aQuietNaN,
- valueAsBits(__llvm_libc::truncf(valueFromBits(BitPatterns::aQuietNaN))));
- EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
- valueAsBits(__llvm_libc::truncf(
- valueFromBits(BitPatterns::aNegativeQuietNaN))));
+ EXPECT_FP_EQ(zero, __llvm_libc::truncf(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::truncf(negZero));
- EXPECT_EQ(BitPatterns::aSignallingNaN,
- valueAsBits(__llvm_libc::truncf(
- valueFromBits(BitPatterns::aSignallingNaN))));
- EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
- valueAsBits(__llvm_libc::truncf(
- valueFromBits(BitPatterns::aNegativeSignallingNaN))));
+ EXPECT_FP_EQ(inf, __llvm_libc::truncf(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::truncf(negInf));
- EXPECT_EQ(BitPatterns::inf,
- valueAsBits(__llvm_libc::truncf(valueFromBits(BitPatterns::inf))));
- EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::truncf(
- valueFromBits(BitPatterns::negInf))));
-
- EXPECT_EQ(BitPatterns::zero,
- valueAsBits(__llvm_libc::truncf(valueFromBits(BitPatterns::zero))));
- EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::truncf(
- valueFromBits(BitPatterns::negZero))));
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::truncf(nan)), 0);
}
TEST(TruncfTest, RoundedNumbers) {
- EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::truncf(1.0f)));
- EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::truncf(-1.0f)));
- EXPECT_EQ(valueAsBits(10.0f), valueAsBits(__llvm_libc::truncf(10.0f)));
- EXPECT_EQ(valueAsBits(-10.0f), valueAsBits(__llvm_libc::truncf(-10.0f)));
- EXPECT_EQ(valueAsBits(12345.0f), valueAsBits(__llvm_libc::truncf(12345.0f)));
- EXPECT_EQ(valueAsBits(-12345.0f),
- valueAsBits(__llvm_libc::truncf(-12345.0f)));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.0f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.0f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::truncf(10.0f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::truncf(-10.0f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::truncf(1234.0f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.0f));
+}
+
+TEST(TruncfTest, Fractions) {
+ EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.5f));
+ EXPECT_FP_EQ(-0.0f, __llvm_libc::truncf(-0.5f));
+ EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.115f));
+ EXPECT_FP_EQ(-0.0f, __llvm_libc::truncf(-0.115f));
+ EXPECT_FP_EQ(0.0f, __llvm_libc::truncf(0.715f));
+ EXPECT_FP_EQ(-0.0f, __llvm_libc::truncf(-0.715f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.3f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.3f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.5f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.5f));
+ EXPECT_FP_EQ(1.0f, __llvm_libc::truncf(1.75f));
+ EXPECT_FP_EQ(-1.0f, __llvm_libc::truncf(-1.75f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::truncf(10.32f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::truncf(-10.32f));
+ EXPECT_FP_EQ(10.0f, __llvm_libc::truncf(10.65f));
+ EXPECT_FP_EQ(-10.0f, __llvm_libc::truncf(-10.65f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::truncf(1234.38f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.38f));
+ EXPECT_FP_EQ(1234.0f, __llvm_libc::truncf(1234.96f));
+ EXPECT_FP_EQ(-1234.0f, __llvm_libc::truncf(-1234.96f));
}
TEST(TruncfTest, InFloatRange) {
- using BitsType = Properties::BitsType;
- constexpr BitsType count = 1000000;
- constexpr BitsType step = UINT32_MAX / count;
- for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
- double x = valueFromBits(v);
+ using UIntType = FPBits::UIntType;
+ constexpr UIntType count = 1000000;
+ constexpr UIntType step = UIntType(-1) / count;
+ for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
+ float x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
+
ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncf(x),
tolerance);
}
diff --git a/libc/test/src/math/truncl_test.cpp b/libc/test/src/math/truncl_test.cpp
index 37f9be74eb42..2ea6fe58a63d 100644
--- a/libc/test/src/math/truncl_test.cpp
+++ b/libc/test/src/math/truncl_test.cpp
@@ -9,6 +9,7 @@
#include "include/math.h"
#include "src/math/truncl.h"
#include "utils/FPUtil/FPBits.h"
+#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
@@ -16,38 +17,56 @@ using FPBits = __llvm_libc::fputil::FPBits<long double>;
namespace mpfr = __llvm_libc::testing::mpfr;
+static const long double zero = FPBits::zero();
+static const long double negZero = FPBits::negZero();
+static const long double nan = FPBits::buildNaN(1);
+static const long double inf = FPBits::inf();
+static const long double negInf = FPBits::negInf();
+
// Zero tolerance; As in, exact match with MPFR result.
static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::floatPrecision, 0,
0};
-
TEST(TrunclTest, SpecialNumbers) {
- ASSERT_TRUE(FPBits::zero() == __llvm_libc::truncl(FPBits::zero()));
- ASSERT_TRUE(FPBits::negZero() == __llvm_libc::truncl(FPBits::negZero()));
+ EXPECT_FP_EQ(zero, __llvm_libc::truncl(zero));
+ EXPECT_FP_EQ(negZero, __llvm_libc::truncl(negZero));
- ASSERT_TRUE(FPBits::inf() == __llvm_libc::truncl(FPBits::inf()));
- ASSERT_TRUE(FPBits::negInf() == __llvm_libc::truncl(FPBits::negInf()));
+ EXPECT_FP_EQ(inf, __llvm_libc::truncl(inf));
+ EXPECT_FP_EQ(negInf, __llvm_libc::truncl(negInf));
- long double nan = FPBits::buildNaN(1);
- ASSERT_TRUE(isnan(nan) != 0);
- ASSERT_TRUE(isnan(__llvm_libc::truncl(nan)) != 0);
+ ASSERT_NE(isnan(nan), 0);
+ ASSERT_NE(isnan(__llvm_libc::truncl(nan)), 0);
}
TEST(TrunclTest, RoundedNumbers) {
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::truncl(1.0l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::truncl(-1.0l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::truncl(10.0l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::truncl(-10.0l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::truncl(1234.0l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::truncl(-1234.0l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.0l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.0l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::truncl(10.0l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::truncl(-10.0l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::truncl(1234.0l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.0l));
}
TEST(TrunclTest, Fractions) {
- ASSERT_TRUE(FPBits(1.0l) == __llvm_libc::truncl(1.5l));
- ASSERT_TRUE(FPBits(-1.0l) == __llvm_libc::truncl(-1.75l));
- ASSERT_TRUE(FPBits(10.0l) == __llvm_libc::truncl(10.32l));
- ASSERT_TRUE(FPBits(-10.0l) == __llvm_libc::truncl(-10.65l));
- ASSERT_TRUE(FPBits(1234.0l) == __llvm_libc::truncl(1234.78l));
- ASSERT_TRUE(FPBits(-1234.0l) == __llvm_libc::truncl(-1234.96l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.5l));
+ EXPECT_FP_EQ(-0.0l, __llvm_libc::truncl(-0.5l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.115l));
+ EXPECT_FP_EQ(-0.0l, __llvm_libc::truncl(-0.115l));
+ EXPECT_FP_EQ(0.0l, __llvm_libc::truncl(0.715l));
+ EXPECT_FP_EQ(-0.0l, __llvm_libc::truncl(-0.715l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.3l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.3l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.5l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.5l));
+ EXPECT_FP_EQ(1.0l, __llvm_libc::truncl(1.75l));
+ EXPECT_FP_EQ(-1.0l, __llvm_libc::truncl(-1.75l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::truncl(10.32l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::truncl(-10.32l));
+ EXPECT_FP_EQ(10.0l, __llvm_libc::truncl(10.65l));
+ EXPECT_FP_EQ(-10.0l, __llvm_libc::truncl(-10.65l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::truncl(1234.38l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.38l));
+ EXPECT_FP_EQ(1234.0l, __llvm_libc::truncl(1234.96l));
+ EXPECT_FP_EQ(-1234.0l, __llvm_libc::truncl(-1234.96l));
}
TEST(TrunclTest, InLongDoubleRange) {
More information about the libc-commits
mailing list