49 changes: 49 additions & 0 deletions libc/test/src/math/FAbsTest.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,49 @@
//===-- Utility class to test fabs[f|l] -------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"

#include <math.h>

namespace mpfr = __llvm_libc::testing::mpfr;

template <typename T> class FAbsTest : public __llvm_libc::testing::Test {

DECLARE_SPECIAL_CONSTANTS(T)

public:
typedef T (*FabsFunc)(T);

void testSpecialNumbers(FabsFunc func) {
EXPECT_FP_EQ(aNaN, func(aNaN));

EXPECT_FP_EQ(inf, func(inf));
EXPECT_FP_EQ(inf, func(negInf));

EXPECT_FP_EQ(zero, func(zero));
EXPECT_FP_EQ(zero, func(negZero));
}

void testRange(FabsFunc func) {
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0);
}
}
};

#define LIST_FABS_TESTS(T, func) \
using LlvmLibcFAbsTest = FAbsTest<T>; \
TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); }
85 changes: 85 additions & 0 deletions libc/test/src/math/FMaxTest.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,85 @@
//===-- Utility class to test fmin[f|l] -------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"

#include <math.h>

namespace mpfr = __llvm_libc::testing::mpfr;

template <typename T> class FMaxTest : public __llvm_libc::testing::Test {

DECLARE_SPECIAL_CONSTANTS(T)

public:
typedef T (*FMaxFunc)(T, T);

void testNaN(FMaxFunc func) {
EXPECT_FP_EQ(inf, func(aNaN, inf));
EXPECT_FP_EQ(negInf, func(negInf, aNaN));
EXPECT_FP_EQ(0.0, func(aNaN, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, aNaN));
EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345)));
EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
}

void testInfArg(FMaxFunc func) {
EXPECT_FP_EQ(inf, func(negInf, inf));
EXPECT_FP_EQ(inf, func(inf, 0.0));
EXPECT_FP_EQ(inf, func(-0.0, inf));
EXPECT_FP_EQ(inf, func(inf, T(1.2345)));
EXPECT_FP_EQ(inf, func(T(-1.2345), inf));
}

void testNegInfArg(FMaxFunc func) {
EXPECT_FP_EQ(inf, func(inf, negInf));
EXPECT_FP_EQ(0.0, func(negInf, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, negInf));
EXPECT_FP_EQ(T(-1.2345), func(negInf, T(-1.2345)));
EXPECT_FP_EQ(T(1.2345), func(T(1.2345), negInf));
}

void testBothZero(FMaxFunc func) {
EXPECT_FP_EQ(0.0, func(0.0, 0.0));
EXPECT_FP_EQ(0.0, func(-0.0, 0.0));
EXPECT_FP_EQ(0.0, func(0.0, -0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
}

void testRange(FMaxFunc func) {
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;

if (x > y) {
EXPECT_FP_EQ(x, func(x, y));
} else {
EXPECT_FP_EQ(y, func(x, y));
}
}
}
};

#define LIST_FMAX_TESTS(T, func) \
using LlvmLibcFMaxTest = FMaxTest<T>; \
TEST_F(LlvmLibcFMaxTest, NaN) { testNaN(&func); } \
TEST_F(LlvmLibcFMaxTest, InfArg) { testInfArg(&func); } \
TEST_F(LlvmLibcFMaxTest, NegInfArg) { testNegInfArg(&func); } \
TEST_F(LlvmLibcFMaxTest, BothZero) { testBothZero(&func); } \
TEST_F(LlvmLibcFMaxTest, Range) { testRange(&func); }
85 changes: 85 additions & 0 deletions libc/test/src/math/FMinTest.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,85 @@
//===-- Utility class to test fmin[f|l] -------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"

#include <math.h>

namespace mpfr = __llvm_libc::testing::mpfr;

template <typename T> class FMinTest : public __llvm_libc::testing::Test {

DECLARE_SPECIAL_CONSTANTS(T)

public:
typedef T (*FMinFunc)(T, T);

void testNaN(FMinFunc func) {
EXPECT_FP_EQ(inf, func(aNaN, inf));
EXPECT_FP_EQ(negInf, func(negInf, aNaN));
EXPECT_FP_EQ(0.0, func(aNaN, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, aNaN));
EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345)));
EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN));
EXPECT_FP_EQ(aNaN, func(aNaN, aNaN));
}

void testInfArg(FMinFunc func) {
EXPECT_FP_EQ(negInf, func(negInf, inf));
EXPECT_FP_EQ(0.0, func(inf, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, inf));
EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345)));
EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf));
}

void testNegInfArg(FMinFunc func) {
EXPECT_FP_EQ(negInf, func(inf, negInf));
EXPECT_FP_EQ(negInf, func(negInf, 0.0));
EXPECT_FP_EQ(negInf, func(-0.0, negInf));
EXPECT_FP_EQ(negInf, func(negInf, T(-1.2345)));
EXPECT_FP_EQ(negInf, func(T(1.2345), negInf));
}

void testBothZero(FMinFunc func) {
EXPECT_FP_EQ(0.0, func(0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
}

void testRange(FMinFunc func) {
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
T x = T(FPBits(v)), y = T(FPBits(w));
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;

if (x > y) {
EXPECT_FP_EQ(y, func(x, y));
} else {
EXPECT_FP_EQ(x, func(x, y));
}
}
}
};

#define LIST_FMIN_TESTS(T, func) \
using LlvmLibcFMinTest = FMinTest<T>; \
TEST_F(LlvmLibcFMinTest, NaN) { testNaN(&func); } \
TEST_F(LlvmLibcFMinTest, InfArg) { testInfArg(&func); } \
TEST_F(LlvmLibcFMinTest, NegInfArg) { testNegInfArg(&func); } \
TEST_F(LlvmLibcFMinTest, BothZero) { testBothZero(&func); } \
TEST_F(LlvmLibcFMinTest, Range) { testRange(&func); }
84 changes: 84 additions & 0 deletions libc/test/src/math/FloorTest.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,84 @@
//===-- Utility class to test floor[f|l] ------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"

#include <math.h>

namespace mpfr = __llvm_libc::testing::mpfr;

template <typename T> class FloorTest : public __llvm_libc::testing::Test {

DECLARE_SPECIAL_CONSTANTS(T)

public:
typedef T (*FloorFunc)(T);

void testSpecialNumbers(FloorFunc func) {
EXPECT_FP_EQ(zero, func(zero));
EXPECT_FP_EQ(negZero, func(negZero));

EXPECT_FP_EQ(inf, func(inf));
EXPECT_FP_EQ(negInf, func(negInf));

EXPECT_FP_EQ(aNaN, func(aNaN));
}

void testRoundedNumbers(FloorFunc func) {
EXPECT_FP_EQ(T(1.0), func(T(1.0)));
EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
EXPECT_FP_EQ(T(10.0), func(T(10.0)));
EXPECT_FP_EQ(T(-10.0), func(T(-10.0)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.0)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.0)));
}

void testFractions(FloorFunc func) {
EXPECT_FP_EQ(T(0.0), func(T(0.5)));
EXPECT_FP_EQ(T(-1.0), func(T(-0.5)));
EXPECT_FP_EQ(T(0.0), func(T(0.115)));
EXPECT_FP_EQ(T(-1.0), func(T(-0.115)));
EXPECT_FP_EQ(T(0.0), func(T(0.715)));
EXPECT_FP_EQ(T(-1.0), func(T(-0.715)));
EXPECT_FP_EQ(T(1.0), func(T(1.3)));
EXPECT_FP_EQ(T(-2.0), func(T(-1.3)));
EXPECT_FP_EQ(T(1.0), func(T(1.5)));
EXPECT_FP_EQ(T(-2.0), func(T(-1.5)));
EXPECT_FP_EQ(T(1.0), func(T(1.75)));
EXPECT_FP_EQ(T(-2.0), func(T(-1.75)));
EXPECT_FP_EQ(T(10.0), func(T(10.32)));
EXPECT_FP_EQ(T(-11.0), func(T(-10.32)));
EXPECT_FP_EQ(T(10.0), func(T(10.65)));
EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.38)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
}

void testRange(FloorFunc func) {
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;

ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, func(x), 0.0);
}
}
};

#define LIST_FLOOR_TESTS(T, func) \
using LlvmLibcFloorTest = FloorTest<T>; \
TEST_F(LlvmLibcFloorTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcFloorTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcFloorTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcFloorTest, Range) { testRange(&func); }
84 changes: 84 additions & 0 deletions libc/test/src/math/RoundTest.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,84 @@
//===-- Utility class to test round[f|l] ------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"

#include <math.h>

namespace mpfr = __llvm_libc::testing::mpfr;

template <typename T> class RoundTest : public __llvm_libc::testing::Test {

DECLARE_SPECIAL_CONSTANTS(T)

public:
typedef T (*RoundFunc)(T);

void testSpecialNumbers(RoundFunc func) {
EXPECT_FP_EQ(zero, func(zero));
EXPECT_FP_EQ(negZero, func(negZero));

EXPECT_FP_EQ(inf, func(inf));
EXPECT_FP_EQ(negInf, func(negInf));

EXPECT_FP_EQ(aNaN, func(aNaN));
}

void testRoundedNumbers(RoundFunc func) {
EXPECT_FP_EQ(T(1.0), func(T(1.0)));
EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
EXPECT_FP_EQ(T(10.0), func(T(10.0)));
EXPECT_FP_EQ(T(-10.0), func(T(-10.0)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.0)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.0)));
}

void testFractions(RoundFunc func) {
EXPECT_FP_EQ(T(1.0), func(T(0.5)));
EXPECT_FP_EQ(T(-1.0), func(T(-0.5)));
EXPECT_FP_EQ(T(0.0), func(T(0.115)));
EXPECT_FP_EQ(T(-0.0), func(T(-0.115)));
EXPECT_FP_EQ(T(1.0), func(T(0.715)));
EXPECT_FP_EQ(T(-1.0), func(T(-0.715)));
EXPECT_FP_EQ(T(1.0), func(T(1.3)));
EXPECT_FP_EQ(T(-1.0), func(T(-1.3)));
EXPECT_FP_EQ(T(2.0), func(T(1.5)));
EXPECT_FP_EQ(T(-2.0), func(T(-1.5)));
EXPECT_FP_EQ(T(2.0), func(T(1.75)));
EXPECT_FP_EQ(T(-2.0), func(T(-1.75)));
EXPECT_FP_EQ(T(10.0), func(T(10.32)));
EXPECT_FP_EQ(T(-10.0), func(T(-10.32)));
EXPECT_FP_EQ(T(11.0), func(T(10.65)));
EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
}

void testRange(RoundFunc func) {
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;

ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, func(x), 0.0);
}
}
};

#define LIST_ROUND_TESTS(T, func) \
using LlvmLibcRoundTest = RoundTest<T>; \
TEST_F(LlvmLibcRoundTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcRoundTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcRoundTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcRoundTest, Range) { testRange(&func); }
84 changes: 84 additions & 0 deletions libc/test/src/math/TruncTest.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,84 @@
//===-- Utility class to test trunc[f|l] ------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"

#include <math.h>

namespace mpfr = __llvm_libc::testing::mpfr;

template <typename T> class TruncTest : public __llvm_libc::testing::Test {

DECLARE_SPECIAL_CONSTANTS(T)

public:
typedef T (*TruncFunc)(T);

void testSpecialNumbers(TruncFunc func) {
EXPECT_FP_EQ(zero, func(zero));
EXPECT_FP_EQ(negZero, func(negZero));

EXPECT_FP_EQ(inf, func(inf));
EXPECT_FP_EQ(negInf, func(negInf));

EXPECT_FP_EQ(aNaN, func(aNaN));
}

void testRoundedNumbers(TruncFunc func) {
EXPECT_FP_EQ(T(1.0), func(T(1.0)));
EXPECT_FP_EQ(T(-1.0), func(T(-1.0)));
EXPECT_FP_EQ(T(10.0), func(T(10.0)));
EXPECT_FP_EQ(T(-10.0), func(T(-10.0)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.0)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.0)));
}

void testFractions(TruncFunc func) {
EXPECT_FP_EQ(T(0.0), func(T(0.5)));
EXPECT_FP_EQ(T(-0.0), func(T(-0.5)));
EXPECT_FP_EQ(T(0.0), func(T(0.115)));
EXPECT_FP_EQ(T(-0.0), func(T(-0.115)));
EXPECT_FP_EQ(T(0.0), func(T(0.715)));
EXPECT_FP_EQ(T(-0.0), func(T(-0.715)));
EXPECT_FP_EQ(T(1.0), func(T(1.3)));
EXPECT_FP_EQ(T(-1.0), func(T(-1.3)));
EXPECT_FP_EQ(T(1.0), func(T(1.5)));
EXPECT_FP_EQ(T(-1.0), func(T(-1.5)));
EXPECT_FP_EQ(T(1.0), func(T(1.75)));
EXPECT_FP_EQ(T(-1.0), func(T(-1.75)));
EXPECT_FP_EQ(T(10.0), func(T(10.32)));
EXPECT_FP_EQ(T(-10.0), func(T(-10.32)));
EXPECT_FP_EQ(T(10.0), func(T(10.65)));
EXPECT_FP_EQ(T(-10.0), func(T(-10.65)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
}

void testRange(TruncFunc func) {
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0; i <= count; ++i, v += step) {
T x = T(FPBits(v));
if (isnan(x) || isinf(x))
continue;

ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, func(x), 0.0);
}
}
};

#define LIST_TRUNC_TESTS(T, func) \
using LlvmLibcTruncTest = TruncTest<T>; \
TEST_F(LlvmLibcTruncTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(LlvmLibcTruncTest, RoundedNubmers) { testRoundedNumbers(&func); } \
TEST_F(LlvmLibcTruncTest, Fractions) { testFractions(&func); } \
TEST_F(LlvmLibcTruncTest, Range) { testRange(&func); }
68 changes: 3 additions & 65 deletions libc/test/src/math/ceil_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/ceil.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(double)

TEST(LlvmLibcCeilTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::ceil(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::ceil(negZero));
#include "CeilTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::ceil(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::ceil(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::ceil(aNaN));
}

TEST(LlvmLibcCeilTest, 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(LlvmLibcCeilTest, 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(LlvmLibcCeilTest, 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;
#include "src/math/ceil.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceil(x), 0.0);
}
}
LIST_CEIL_TESTS(double, __llvm_libc::ceil)
68 changes: 3 additions & 65 deletions libc/test/src/math/ceilf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/ceilf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(float)

TEST(LlvmLibcCeilfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::ceilf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::ceilf(negZero));
#include "CeilTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::ceilf(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::ceilf(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::ceilf(aNaN));
}

TEST(LlvmLibcCeilfTest, RoundedNumbers) {
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(LlvmLibcCeilfTest, 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(LlvmLibcCeilfTest, InFloatRange) {
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;
#include "src/math/ceilf.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceilf(x), 0.0);
}
}
LIST_CEIL_TESTS(float, __llvm_libc::ceilf)
68 changes: 3 additions & 65 deletions libc/test/src/math/ceill_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#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"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(long double)

TEST(LlvmLibcCeillTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::ceill(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::ceill(negZero));
#include "CeilTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::ceill(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::ceill(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::ceill(aNaN));
}

TEST(LlvmLibcCeillTest, RoundedNumbers) {
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(LlvmLibcCeillTest, Fractions) {
EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.5l));
EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.5l));
EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.115l));
EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.115l));
EXPECT_FP_EQ(1.0l, __llvm_libc::ceill(0.715l));
EXPECT_FP_EQ(-0.0l, __llvm_libc::ceill(-0.715l));
EXPECT_FP_EQ(2.0l, __llvm_libc::ceill(1.3l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.3l));
EXPECT_FP_EQ(2.0l, __llvm_libc::ceill(1.5l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.5l));
EXPECT_FP_EQ(2.0l, __llvm_libc::ceill(1.75l));
EXPECT_FP_EQ(-1.0l, __llvm_libc::ceill(-1.75l));
EXPECT_FP_EQ(11.0l, __llvm_libc::ceill(10.32l));
EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.32l));
EXPECT_FP_EQ(11.0l, __llvm_libc::ceill(10.65l));
EXPECT_FP_EQ(-10.0l, __llvm_libc::ceill(-10.65l));
EXPECT_FP_EQ(1235.0l, __llvm_libc::ceill(1234.38l));
EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.38l));
EXPECT_FP_EQ(1235.0l, __llvm_libc::ceill(1234.96l));
EXPECT_FP_EQ(-1234.0l, __llvm_libc::ceill(-1234.96l));
}

TEST(LlvmLibcCeillTest, InLongDoubleRange) {
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) {
long double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
#include "src/math/ceill.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceill(x), 0.0);
}
}
LIST_CEIL_TESTS(long double, __llvm_libc::ceill)
38 changes: 3 additions & 35 deletions libc/test/src/math/copysign_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,40 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/copysign.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

DECLARE_SPECIAL_CONSTANTS(double)

TEST(LlvmLibcCopySignTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, -1.0));
EXPECT_FP_EQ(aNaN, __llvm_libc::copysign(aNaN, 1.0));
#include "CopySignTest.h"

EXPECT_FP_EQ(negInf, __llvm_libc::copysign(inf, -1.0));
EXPECT_FP_EQ(inf, __llvm_libc::copysign(negInf, 1.0));

EXPECT_FP_EQ(negZero, __llvm_libc::copysign(zero, -1.0));
EXPECT_FP_EQ(zero, __llvm_libc::copysign(negZero, 1.0));
}

TEST(LlvmLibcCopySignTest, 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) || x == 0)
continue;

double res1 = __llvm_libc::copysign(x, -x);
ASSERT_FP_EQ(res1, -x);
#include "src/math/copysign.h"

double res2 = __llvm_libc::copysign(x, x);
ASSERT_FP_EQ(res2, x);
}
}
LIST_COPYSIGN_TESTS(double, __llvm_libc::copysign)
38 changes: 3 additions & 35 deletions libc/test/src/math/copysignf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,40 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/copysignf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

DECLARE_SPECIAL_CONSTANTS(float)

TEST(LlvmLibcCopySinfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, -1.0));
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignf(aNaN, 1.0));
#include "CopySignTest.h"

EXPECT_FP_EQ(negInf, __llvm_libc::copysignf(inf, -1.0));
EXPECT_FP_EQ(inf, __llvm_libc::copysignf(negInf, 1.0));

EXPECT_FP_EQ(negZero, __llvm_libc::copysignf(zero, -1.0));
EXPECT_FP_EQ(zero, __llvm_libc::copysignf(negZero, 1.0));
}

TEST(LlvmLibcCopySinfTest, InFloatRange) {
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) || x == 0)
continue;

float res1 = __llvm_libc::copysignf(x, -x);
ASSERT_FP_EQ(res1, -x);
#include "src/math/copysignf.h"

float res2 = __llvm_libc::copysignf(x, x);
ASSERT_FP_EQ(res2, x);
}
}
LIST_COPYSIGN_TESTS(float, __llvm_libc::copysignf)
38 changes: 3 additions & 35 deletions libc/test/src/math/copysignl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,40 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/copysignl.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

DECLARE_SPECIAL_CONSTANTS(long double)

TEST(LlvmLibcCopySinlTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, -1.0));
EXPECT_FP_EQ(aNaN, __llvm_libc::copysignl(aNaN, 1.0));
#include "CopySignTest.h"

EXPECT_FP_EQ(negInf, __llvm_libc::copysignl(inf, -1.0));
EXPECT_FP_EQ(inf, __llvm_libc::copysignl(negInf, 1.0));

EXPECT_FP_EQ(negZero, __llvm_libc::copysignl(zero, -1.0));
EXPECT_FP_EQ(zero, __llvm_libc::copysignl(negZero, 1.0));
}

TEST(LlvmLibcCopySinlTest, InLongDoubleRange) {
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) {
long double x = FPBits(v);
if (isnan(x) || isinf(x) || x == 0)
continue;

long double res1 = __llvm_libc::copysignl(x, -x);
ASSERT_FP_EQ(res1, -x);
#include "src/math/copysignl.h"

long double res2 = __llvm_libc::copysignl(x, x);
ASSERT_FP_EQ(res2, x);
}
}
LIST_COPYSIGN_TESTS(long double, __llvm_libc::copysignl)
35 changes: 3 additions & 32 deletions libc/test/src/math/fabs_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,37 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/fabs.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

DECLARE_SPECIAL_CONSTANTS(double)

namespace mpfr = __llvm_libc::testing::mpfr;
#include "FAbsTest.h"

TEST(LlvmLibcFabsTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fabs(aNaN));

EXPECT_FP_EQ(inf, __llvm_libc::fabs(inf));
EXPECT_FP_EQ(inf, __llvm_libc::fabs(negInf));

EXPECT_FP_EQ(zero, __llvm_libc::fabs(zero));
EXPECT_FP_EQ(zero, __llvm_libc::fabs(negZero));
}
#include "src/math/fabs.h"

TEST(LlvmLibcFabsTest, 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::Abs, x, __llvm_libc::fabs(x), 0.0);
}
}
LIST_FABS_TESTS(double, __llvm_libc::fabs)
35 changes: 3 additions & 32 deletions libc/test/src/math/fabsf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,37 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/fabsf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

DECLARE_SPECIAL_CONSTANTS(float)

namespace mpfr = __llvm_libc::testing::mpfr;
#include "FAbsTest.h"

TEST(LlvmLibcFabsfTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fabsf(aNaN));

EXPECT_FP_EQ(inf, __llvm_libc::fabsf(inf));
EXPECT_FP_EQ(inf, __llvm_libc::fabsf(negInf));

EXPECT_FP_EQ(zero, __llvm_libc::fabsf(zero));
EXPECT_FP_EQ(zero, __llvm_libc::fabsf(negZero));
}
#include "src/math/fabsf.h"

TEST(LlvmLibcFabsfTest, InFloatRange) {
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::Abs, x, __llvm_libc::fabsf(x), 0.0);
}
}
LIST_FABS_TESTS(float, __llvm_libc::fabsf)
35 changes: 3 additions & 32 deletions libc/test/src/math/fabsl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,37 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/fabsl.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

DECLARE_SPECIAL_CONSTANTS(long double)

namespace mpfr = __llvm_libc::testing::mpfr;
#include "FAbsTest.h"

TEST(LlvmLibcFabslTest, SpecialNumbers) {
EXPECT_FP_EQ(aNaN, __llvm_libc::fabsl(aNaN));

EXPECT_FP_EQ(inf, __llvm_libc::fabsl(inf));
EXPECT_FP_EQ(inf, __llvm_libc::fabsl(negInf));

EXPECT_FP_EQ(zero, __llvm_libc::fabsl(zero));
EXPECT_FP_EQ(zero, __llvm_libc::fabsl(negZero));
}
#include "src/math/fabsl.h"

TEST(LlvmLibcFabslTest, InLongDoubleRange) {
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) {
long double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, __llvm_libc::fabsl(x), 0.0);
}
}
LIST_FABS_TESTS(long double, __llvm_libc::fabsl)
68 changes: 3 additions & 65 deletions libc/test/src/math/floor_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/floor.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

DECLARE_SPECIAL_CONSTANTS(double)

namespace mpfr = __llvm_libc::testing::mpfr;

TEST(LlvmLibcFloorTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::floor(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::floor(negZero));
#include "FloorTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::floor(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::floor(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::floor(aNaN));
}

TEST(LlvmLibcFloorTest, 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(LlvmLibcFloorTest, 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(LlvmLibcFloorTest, 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;
#include "src/math/floor.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floor(x), 0.0);
}
}
LIST_FLOOR_TESTS(double, __llvm_libc::floor)
68 changes: 3 additions & 65 deletions libc/test/src/math/floorf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/floorf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

DECLARE_SPECIAL_CONSTANTS(float)

namespace mpfr = __llvm_libc::testing::mpfr;

TEST(LlvmLibcFloorfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::floorf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::floorf(negZero));
#include "FloorTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::floorf(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::floorf(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::floorf(aNaN));
}

TEST(LlvmLibcFloorfTest, RoundedNumbers) {
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(LlvmLibcFloorfTest, 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(LlvmLibcFloorfTest, InFloatRange) {
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;
#include "src/math/floorf.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorf(x), 0.0);
}
}
LIST_FLOOR_TESTS(float, __llvm_libc::floorf)
68 changes: 3 additions & 65 deletions libc/test/src/math/floorl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#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"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

DECLARE_SPECIAL_CONSTANTS(long double)

namespace mpfr = __llvm_libc::testing::mpfr;

TEST(LlvmLibcFloorlTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::floorl(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::floorl(negZero));
#include "FloorTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::floorl(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::floorl(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::floorl(aNaN));
}

TEST(LlvmLibcFloorlTest, RoundedNumbers) {
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(LlvmLibcFloorlTest, Fractions) {
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(LlvmLibcFloorlTest, InLongDoubleRange) {
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) {
long double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
#include "src/math/floorl.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorl(x), 0.0);
}
}
LIST_FLOOR_TESTS(long double, __llvm_libc::floorl)
65 changes: 3 additions & 62 deletions libc/test/src/math/fmax_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,67 +6,8 @@
//
//===---------------------------------------------------------------------===//

#include "src/math/fmax.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

DECLARE_SPECIAL_CONSTANTS(double)

TEST(LlvmLibcFmaxTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmax(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmax(negInf, aNaN));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(aNaN, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, aNaN));
EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(aNaN, -1.2345));
EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, aNaN));
EXPECT_FP_EQ(aNaN, __llvm_libc::fmax(aNaN, aNaN));
}
#include "FMaxTest.h"

TEST(LlvmLibcFmaxTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmax(negInf, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 0.0));
EXPECT_FP_EQ(inf, __llvm_libc::fmax(-0.0, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, 1.2345));
EXPECT_FP_EQ(inf, __llvm_libc::fmax(-1.2345, inf));
}

TEST(LlvmLibcFmaxTest, NegInfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmax(inf, negInf));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(negInf, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, negInf));
EXPECT_FP_EQ(-1.2345, __llvm_libc::fmax(negInf, -1.2345));
EXPECT_FP_EQ(1.2345, __llvm_libc::fmax(1.2345, negInf));
}

TEST(LlvmLibcFmaxTest, BothZero) {
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, 0.0));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(-0.0, 0.0));
EXPECT_FP_EQ(0.0, __llvm_libc::fmax(0.0, -0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmax(-0.0, -0.0));
}

TEST(LlvmLibcFmaxTest, InDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;
#include "src/math/fmax.h"

if (x > y) {
EXPECT_FP_EQ(x, __llvm_libc::fmax(x, y));
} else {
EXPECT_FP_EQ(y, __llvm_libc::fmax(x, y));
}
}
}
LIST_FMAX_TESTS(double, __llvm_libc::fmax)
67 changes: 4 additions & 63 deletions libc/test/src/math/fmaxf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,69 +4,10 @@
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===---------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

#include "src/math/fmaxf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

DECLARE_SPECIAL_CONSTANTS(float)

TEST(LlvmLibcFmaxfTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmaxf(negInf, aNaN));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(aNaN, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, aNaN));
EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(aNaN, -1.2345f));
EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, aNaN));
EXPECT_FP_EQ(aNaN, __llvm_libc::fmaxf(aNaN, aNaN));
}
#include "FMaxTest.h"

TEST(LlvmLibcFmaxfTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(negInf, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 0.0f));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-0.0f, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, 1.2345f));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(-1.2345f, inf));
}

TEST(LlvmLibcFmaxfTest, NegInfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxf(inf, negInf));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(negInf, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, negInf));
EXPECT_FP_EQ(-1.2345f, __llvm_libc::fmaxf(negInf, -1.2345f));
EXPECT_FP_EQ(1.2345f, __llvm_libc::fmaxf(1.2345f, negInf));
}

TEST(LlvmLibcFmaxfTest, BothZero) {
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, 0.0f));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(-0.0f, 0.0f));
EXPECT_FP_EQ(0.0f, __llvm_libc::fmaxf(0.0f, -0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fmaxf(-0.0f, -0.0f));
}

TEST(LlvmLibcFmaxfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
float x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;
#include "src/math/fmaxf.h"

if (x > y) {
ASSERT_FP_EQ(x, __llvm_libc::fmaxf(x, y));
} else {
ASSERT_FP_EQ(y, __llvm_libc::fmaxf(x, y));
}
}
}
LIST_FMAX_TESTS(float, __llvm_libc::fmaxf)
67 changes: 4 additions & 63 deletions libc/test/src/math/fmaxl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,69 +4,10 @@
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===---------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

#include "src/math/fmaxl.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

DECLARE_SPECIAL_CONSTANTS(long double)

TEST(LlvmLibcFmaxlTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmaxl(negInf, aNaN));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(aNaN, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, aNaN));
EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(aNaN, -1.2345L));
EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, aNaN));
EXPECT_FP_EQ(aNaN, __llvm_libc::fmaxl(aNaN, aNaN));
}
#include "FMaxTest.h"

TEST(LlvmLibcFmaxlTest, InfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(negInf, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 0.0L));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-0.0L, inf));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, 1.2345L));
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(-1.2345L, inf));
}

TEST(LlvmLibcFmaxlTest, NegInfArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmaxl(inf, negInf));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(negInf, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, negInf));
EXPECT_FP_EQ(-1.2345L, __llvm_libc::fmaxl(negInf, -1.2345L));
EXPECT_FP_EQ(1.2345L, __llvm_libc::fmaxl(1.2345L, negInf));
}

TEST(LlvmLibcFmaxlTest, BothZero) {
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, 0.0L));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(-0.0L, 0.0L));
EXPECT_FP_EQ(0.0L, __llvm_libc::fmaxl(0.0L, -0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fmaxl(-0.0L, -0.0L));
}

TEST(LlvmLibcFmaxlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000001;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
long double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;
#include "src/math/fmaxl.h"

if (x > y) {
ASSERT_FP_EQ(x, __llvm_libc::fmaxl(x, y));
} else {
ASSERT_FP_EQ(y, __llvm_libc::fmaxl(x, y));
}
}
}
LIST_FMAX_TESTS(long double, __llvm_libc::fmaxl)
65 changes: 3 additions & 62 deletions libc/test/src/math/fmin_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,67 +6,8 @@
//
//===---------------------------------------------------------------------===//

#include "src/math/fmin.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

DECLARE_SPECIAL_CONSTANTS(double)

TEST(LlvmLibcFminTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fmin(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, aNaN));
EXPECT_FP_EQ(0.0, __llvm_libc::fmin(aNaN, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, aNaN));
EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(aNaN, -1.2345));
EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(1.2345, aNaN));
EXPECT_FP_EQ(aNaN, __llvm_libc::fmin(aNaN, aNaN));
}
#include "FMinTest.h"

TEST(LlvmLibcFminTest, InfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, inf));
EXPECT_FP_EQ(0.0, __llvm_libc::fmin(inf, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, inf));
EXPECT_FP_EQ(1.2345, __llvm_libc::fmin(inf, 1.2345));
EXPECT_FP_EQ(-1.2345, __llvm_libc::fmin(-1.2345, inf));
}

TEST(LlvmLibcFminTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(inf, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, 0.0));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(-0.0, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(negInf, -1.2345));
EXPECT_FP_EQ(negInf, __llvm_libc::fmin(1.2345, negInf));
}

TEST(LlvmLibcFminTest, BothZero) {
EXPECT_FP_EQ(0.0, __llvm_libc::fmin(0.0, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, 0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(0.0, -0.0));
EXPECT_FP_EQ(-0.0, __llvm_libc::fmin(-0.0, -0.0));
}

TEST(LlvmLibcFminTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;
#include "src/math/fmin.h"

if (x < y) {
ASSERT_FP_EQ(x, __llvm_libc::fmin(x, y));
} else {
ASSERT_FP_EQ(y, __llvm_libc::fmin(x, y));
}
}
}
LIST_FMIN_TESTS(double, __llvm_libc::fmin)
69 changes: 5 additions & 64 deletions libc/test/src/math/fminf_test.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,72 +1,13 @@
//===-- Unittests for fminf ----------------------------------------------===//
//===-- Unittests for fminf -----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===---------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

#include "src/math/fminf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

DECLARE_SPECIAL_CONSTANTS(float)

TEST(LlvmLibcFminfTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fminf(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, aNaN));
EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(aNaN, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, aNaN));
EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(aNaN, -1.2345f));
EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(1.2345f, aNaN));
EXPECT_FP_EQ(aNaN, __llvm_libc::fminf(aNaN, aNaN));
}
#include "FMinTest.h"

TEST(LlvmLibcFminfTest, InfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, inf));
EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(inf, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, inf));
EXPECT_FP_EQ(1.2345f, __llvm_libc::fminf(inf, 1.2345f));
EXPECT_FP_EQ(-1.2345f, __llvm_libc::fminf(-1.2345f, inf));
}

TEST(LlvmLibcFminfTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(inf, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, 0.0f));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(-0.0f, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(negInf, -1.2345f));
EXPECT_FP_EQ(negInf, __llvm_libc::fminf(1.2345f, negInf));
}

TEST(LlvmLibcFminfTest, BothZero) {
EXPECT_FP_EQ(0.0f, __llvm_libc::fminf(0.0f, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, 0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(0.0f, -0.0f));
EXPECT_FP_EQ(-0.0f, __llvm_libc::fminf(-0.0f, -0.0f));
}

TEST(LlvmLibcFminfTest, InFloatRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
float x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;
#include "src/math/fminf.h"

if (x < y) {
ASSERT_FP_EQ(x, __llvm_libc::fminf(x, y));
} else {
ASSERT_FP_EQ(y, __llvm_libc::fminf(x, y));
}
}
}
LIST_FMIN_TESTS(float, __llvm_libc::fminf)
69 changes: 5 additions & 64 deletions libc/test/src/math/fminl_test.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,72 +1,13 @@
//===-- Unittests for fmin -----------------------------------------------===//
//===-- Unittests for fminl -----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===---------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

#include "src/math/fminl.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

DECLARE_SPECIAL_CONSTANTS(long double)

TEST(LlvmLibcFminlTest, NaNArg) {
EXPECT_FP_EQ(inf, __llvm_libc::fminl(aNaN, inf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, aNaN));
EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(aNaN, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, aNaN));
EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(aNaN, -1.2345L));
EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(1.2345L, aNaN));
EXPECT_FP_EQ(aNaN, __llvm_libc::fminl(aNaN, aNaN));
}
#include "FMinTest.h"

TEST(LlvmLibcFminlTest, InfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, inf));
EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(inf, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, inf));
EXPECT_FP_EQ(1.2345L, __llvm_libc::fminl(inf, 1.2345L));
EXPECT_FP_EQ(-1.2345L, __llvm_libc::fminl(-1.2345L, inf));
}

TEST(LlvmLibcFminlTest, NegInfArg) {
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(inf, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, 0.0L));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(-0.0L, negInf));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(negInf, -1.2345L));
EXPECT_FP_EQ(negInf, __llvm_libc::fminl(1.2345L, negInf));
}

TEST(LlvmLibcFminlTest, BothZero) {
EXPECT_FP_EQ(0.0L, __llvm_libc::fminl(0.0L, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, 0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(0.0L, -0.0L));
EXPECT_FP_EQ(-0.0L, __llvm_libc::fminl(-0.0L, -0.0L));
}

TEST(LlvmLibcFminlTest, InLongDoubleRange) {
using UIntType = FPBits::UIntType;
constexpr UIntType count = 10000000;
constexpr UIntType step = UIntType(-1) / count;
for (UIntType i = 0, v = 0, w = UIntType(-1); i <= count;
++i, v += step, w -= step) {
long double x = FPBits(v), y = FPBits(w);
if (isnan(x) || isinf(x))
continue;
if (isnan(y) || isinf(y))
continue;
if ((x == 0) && (y == 0))
continue;
#include "src/math/fminl.h"

if (x < y) {
ASSERT_FP_EQ(x, __llvm_libc::fminl(x, y));
} else {
ASSERT_FP_EQ(y, __llvm_libc::fminl(x, y));
}
}
}
LIST_FMIN_TESTS(long double, __llvm_libc::fminl)
68 changes: 3 additions & 65 deletions libc/test/src/math/round_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/round.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(double)

TEST(LlvmLibcRoundTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::round(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::round(negZero));
#include "RoundTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::round(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::round(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::round(aNaN));
}

TEST(LlvmLibcRoundTest, RoundedNumbers) {
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(LlvmLibcRoundTest, 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(LlvmLibcRoundTest, 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;
#include "src/math/round.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::round(x), 0.0);
}
}
LIST_ROUND_TESTS(double, __llvm_libc::round)
68 changes: 3 additions & 65 deletions libc/test/src/math/roundf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/roundf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(float)

TEST(LlvmLibcRoundfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::roundf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::roundf(negZero));
#include "RoundTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::roundf(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::roundf(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::roundf(aNaN));
}

TEST(LlvmLibcRoundfTest, RoundedNumbers) {
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(LlvmLibcRoundfTest, 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(LlvmLibcRoundfTest, InFloatRange) {
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;
#include "src/math/roundf.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundf(x), 0.0);
}
}
LIST_ROUND_TESTS(float, __llvm_libc::roundf)
68 changes: 3 additions & 65 deletions libc/test/src/math/roundl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#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"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(long double)

TEST(LlvmLibcRoundlTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::roundl(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::roundl(negZero));
#include "RoundTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::roundl(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::roundl(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::roundl(aNaN));
}

TEST(LlvmLibcRoundlTest, RoundedNumbers) {
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(LlvmLibcRoundlTest, Fractions) {
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(LlvmLibcRoundlTest, InLongDoubleRange) {
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) {
long double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
#include "src/math/roundl.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundl(x), 0.0);
}
}
LIST_ROUND_TESTS(long double, __llvm_libc::roundl)
68 changes: 3 additions & 65 deletions libc/test/src/math/trunc_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/trunc.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<double>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(double)

TEST(LlvmLibcTruncTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::trunc(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::trunc(negZero));
#include "TruncTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::trunc(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::trunc(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::trunc(aNaN));
}

TEST(LlvmLibcTruncTest, RoundedNumbers) {
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(LlvmLibcTruncTest, 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(LlvmLibcTruncTest, 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;
#include "src/math/trunc.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::trunc(x), 0.0);
}
}
LIST_TRUNC_TESTS(double, __llvm_libc::trunc)
68 changes: 3 additions & 65 deletions libc/test/src/math/truncf_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#include "src/math/truncf.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<float>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(float)

TEST(LlvmLibcTruncfTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::truncf(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::truncf(negZero));
#include "TruncTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::truncf(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::truncf(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::truncf(aNaN));
}

TEST(LlvmLibcTruncfTest, RoundedNumbers) {
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(LlvmLibcTruncfTest, 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(LlvmLibcTruncfTest, InFloatRange) {
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;
#include "src/math/truncf.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncf(x), 0.0);
}
}
LIST_TRUNC_TESTS(float, __llvm_libc::truncf)
68 changes: 3 additions & 65 deletions libc/test/src/math/truncl_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,70 +6,8 @@
//
//===----------------------------------------------------------------------===//

#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"
#include <math.h>

using FPBits = __llvm_libc::fputil::FPBits<long double>;

namespace mpfr = __llvm_libc::testing::mpfr;

DECLARE_SPECIAL_CONSTANTS(long double)

TEST(LlvmLibcTrunclTest, SpecialNumbers) {
EXPECT_FP_EQ(zero, __llvm_libc::truncl(zero));
EXPECT_FP_EQ(negZero, __llvm_libc::truncl(negZero));
#include "TruncTest.h"

EXPECT_FP_EQ(inf, __llvm_libc::truncl(inf));
EXPECT_FP_EQ(negInf, __llvm_libc::truncl(negInf));

EXPECT_FP_EQ(aNaN, __llvm_libc::truncl(aNaN));
}

TEST(LlvmLibcTrunclTest, RoundedNumbers) {
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(LlvmLibcTrunclTest, Fractions) {
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(LlvmLibcTrunclTest, InLongDoubleRange) {
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) {
long double x = FPBits(v);
if (isnan(x) || isinf(x))
continue;
#include "src/math/truncl.h"

ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncl(x), 0.0);
}
}
LIST_TRUNC_TESTS(long double, __llvm_libc::truncl)
12 changes: 7 additions & 5 deletions libc/utils/FPUtil/TestHelpers.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -66,11 +66,13 @@ FPMatcher<T, C> getMatcher(T expectedValue) {
} // namespace __llvm_libc

#define DECLARE_SPECIAL_CONSTANTS(T) \
static const T zero = __llvm_libc::fputil::FPBits<T>::zero(); \
static const T negZero = __llvm_libc::fputil::FPBits<T>::negZero(); \
static const T aNaN = __llvm_libc::fputil::FPBits<T>::buildNaN(1); \
static const T inf = __llvm_libc::fputil::FPBits<T>::inf(); \
static const T negInf = __llvm_libc::fputil::FPBits<T>::negInf();
using FPBits = __llvm_libc::fputil::FPBits<T>; \
using UIntType = typename FPBits::UIntType; \
const T zero = FPBits::zero(); \
const T negZero = FPBits::negZero(); \
const T aNaN = FPBits::buildNaN(1); \
const T inf = FPBits::inf(); \
const T negInf = FPBits::negInf();

#define EXPECT_FP_EQ(expected, actual) \
EXPECT_THAT( \
Expand Down