Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-03-06 01:19:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[libc][obvious] Switch nearest integer function tests to the new matchers.

Browse Source
This commit is contained in:
Siva Chandra 2020-08-11 22:13:59 -07:00
parent d73be5af0a
commit 01b99c6e1d
12 changed files with 561 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
libc/test/src/math/ceil_test.cpp
View File

@ -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_FP_EQ(inf, __llvm_libc::ceil(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::ceil(negInf));
EXPECT_EQ(BitPatterns::aSignallingNaN,
valueAsBits(
__llvm_libc::ceil(valueFromBits(BitPatterns::aSignallingNaN))));
EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
valueAsBits(__llvm_libc::ceil(
valueFromBits(BitPatterns::aNegativeSignallingNaN))));
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::ceil(valueFromBits(BitPatterns::inf))));
EXPECT_EQ(BitPatterns::negInf,
valueAsBits(__llvm_libc::ceil(valueFromBits(BitPatterns::negInf))));
EXPECT_EQ(BitPatterns::zero,
valueAsBits(__llvm_libc::ceil(valueFromBits(BitPatterns::zero))));
EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::ceil(
valueFromBits(BitPatterns::negZero))));
ASSERT_NE(isnan(nan), 0);
ASSERT_NE(isnan(__llvm_libc::ceil(nan)), 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, 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, 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, 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 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);
}

93
libc/test/src/math/ceilf_test.cpp
View File

@ -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_FP_EQ(zero, __llvm_libc::ceilf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::ceilf(negZero));
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(inf, __llvm_libc::ceilf(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::ceilf(negInf));
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::ceilf(valueFromBits(BitPatterns::inf))));
EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::ceilf(
valueFromBits(BitPatterns::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);
}

64
libc/test/src/math/ceill_test.cpp
View File

@ -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) {

97
libc/test/src/math/floor_test.cpp
View File

@ -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))));
EXPECT_EQ(BitPatterns::zero,
valueAsBits(__llvm_libc::floor(valueFromBits(BitPatterns::zero))));
EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::floor(
valueFromBits(BitPatterns::negZero))));
ASSERT_NE(isnan(nan), 0);
ASSERT_NE(isnan(__llvm_libc::floor(nan)), 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, 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, 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, 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 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);
}

94
libc/test/src/math/floorf_test.cpp
View File

@ -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_FP_EQ(zero, __llvm_libc::floorf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::floorf(negZero));
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(inf, __llvm_libc::floorf(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::floorf(negInf));
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::floorf(valueFromBits(BitPatterns::inf))));
EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::floorf(
valueFromBits(BitPatterns::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);
}

64
libc/test/src/math/floorl_test.cpp
View File

@ -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) {

98
libc/test/src/math/round_test.cpp
View File

@ -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);
}

99
libc/test/src/math/roundf_test.cpp
View File

@ -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);
}

62
libc/test/src/math/roundl_test.cpp
View File

@ -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) {

95
libc/test/src/math/trunc_test.cpp
View File

@ -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_FP_EQ(zero, __llvm_libc::trunc(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::trunc(negZero));
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(inf, __llvm_libc::trunc(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::trunc(negInf));
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::trunc(valueFromBits(BitPatterns::inf))));
EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::trunc(
valueFromBits(BitPatterns::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);
}

93
libc/test/src/math/truncf_test.cpp
View File

@ -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);
}

59
libc/test/src/math/truncl_test.cpp
View File

@ -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) {