[libc][NFC] Add template tests for a bunch of math functions.
Namely, template tests have been added for the following functions: ceil, copysign, fabs, fmax, fmin, floor, trunc, round.
This commit is contained in:
parent
82240e07eb
commit
80e166f81a
|
@ -82,6 +82,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fabs_test.cpp
|
||||
HDRS
|
||||
FAbsTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fabs
|
||||
|
@ -95,6 +97,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fabsf_test.cpp
|
||||
HDRS
|
||||
FAbsTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fabsf
|
||||
|
@ -108,6 +112,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fabsl_test.cpp
|
||||
HDRS
|
||||
FAbsTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fabsl
|
||||
|
@ -121,6 +127,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
trunc_test.cpp
|
||||
HDRS
|
||||
TruncTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.trunc
|
||||
|
@ -134,6 +142,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
truncf_test.cpp
|
||||
HDRS
|
||||
TruncTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.truncf
|
||||
|
@ -147,6 +157,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
truncl_test.cpp
|
||||
HDRS
|
||||
TruncTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.truncl
|
||||
|
@ -160,6 +172,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
ceil_test.cpp
|
||||
HDRS
|
||||
CeilTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.ceil
|
||||
|
@ -173,6 +187,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
ceilf_test.cpp
|
||||
HDRS
|
||||
CeilTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.ceilf
|
||||
|
@ -186,6 +202,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
ceill_test.cpp
|
||||
HDRS
|
||||
CeilTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.ceill
|
||||
|
@ -199,6 +217,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
floor_test.cpp
|
||||
HDRS
|
||||
FloorTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.floor
|
||||
|
@ -212,6 +232,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
floorf_test.cpp
|
||||
HDRS
|
||||
FloorTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.floorf
|
||||
|
@ -225,6 +247,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
floorl_test.cpp
|
||||
HDRS
|
||||
FloorTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.floorl
|
||||
|
@ -238,6 +262,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
round_test.cpp
|
||||
HDRS
|
||||
RoundTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.round
|
||||
|
@ -251,6 +277,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
roundf_test.cpp
|
||||
HDRS
|
||||
RoundTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.roundf
|
||||
|
@ -264,6 +292,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
roundl_test.cpp
|
||||
HDRS
|
||||
RoundTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.roundl
|
||||
|
@ -559,6 +589,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
copysign_test.cpp
|
||||
HDRS
|
||||
CopySignTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.copysign
|
||||
|
@ -571,6 +603,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
copysignf_test.cpp
|
||||
HDRS
|
||||
CopySignTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.copysignf
|
||||
|
@ -583,6 +617,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
copysignl_test.cpp
|
||||
HDRS
|
||||
CopySignTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.copysignl
|
||||
|
@ -832,6 +868,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fminf_test.cpp
|
||||
HDRS
|
||||
FMinTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fminf
|
||||
|
@ -844,6 +882,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fmin_test.cpp
|
||||
HDRS
|
||||
FMinTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fmin
|
||||
|
@ -856,6 +896,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fminl_test.cpp
|
||||
HDRS
|
||||
FMinTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fminl
|
||||
|
@ -868,6 +910,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fmaxf_test.cpp
|
||||
HDRS
|
||||
FMaxTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fmaxf
|
||||
|
@ -880,6 +924,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fmax_test.cpp
|
||||
HDRS
|
||||
FMaxTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fmax
|
||||
|
@ -892,6 +938,8 @@ add_fp_unittest(
|
|||
libc_math_unittests
|
||||
SRCS
|
||||
fmaxl_test.cpp
|
||||
HDRS
|
||||
FMaxTest.h
|
||||
DEPENDS
|
||||
libc.include.math
|
||||
libc.src.math.fmaxl
|
||||
|
|
|
@ -0,0 +1,84 @@
|
|||
//===-- Utility class to test ceil[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 CeilTest : public __llvm_libc::testing::Test {
|
||||
|
||||
DECLARE_SPECIAL_CONSTANTS(T)
|
||||
|
||||
public:
|
||||
typedef T (*CeilFunc)(T);
|
||||
|
||||
void testSpecialNumbers(CeilFunc 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(CeilFunc 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(CeilFunc func) {
|
||||
EXPECT_FP_EQ(T(1.0), func(T(0.5)));
|
||||
EXPECT_FP_EQ(T(-0.0), func(T(-0.5)));
|
||||
EXPECT_FP_EQ(T(1.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(-0.0), func(T(-0.715)));
|
||||
EXPECT_FP_EQ(T(2.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(-1.0), func(T(-1.5)));
|
||||
EXPECT_FP_EQ(T(2.0), func(T(1.75)));
|
||||
EXPECT_FP_EQ(T(-1.0), func(T(-1.75)));
|
||||
EXPECT_FP_EQ(T(11.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(-10.0), func(T(-10.65)));
|
||||
EXPECT_FP_EQ(T(1235.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(-1234.0), func(T(-1234.96)));
|
||||
}
|
||||
|
||||
void testRange(CeilFunc 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::Ceil, x, func(x), 0.0);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#define LIST_CEIL_TESTS(T, func) \
|
||||
using LlvmLibcCeilTest = CeilTest<T>; \
|
||||
TEST_F(LlvmLibcCeilTest, SpecialNumbers) { testSpecialNumbers(&func); } \
|
||||
TEST_F(LlvmLibcCeilTest, RoundedNubmers) { testRoundedNumbers(&func); } \
|
||||
TEST_F(LlvmLibcCeilTest, Fractions) { testFractions(&func); } \
|
||||
TEST_F(LlvmLibcCeilTest, Range) { testRange(&func); }
|
|
@ -0,0 +1,55 @@
|
|||
//===-- Utility class to test copysign[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 CopySignTest : public __llvm_libc::testing::Test {
|
||||
|
||||
DECLARE_SPECIAL_CONSTANTS(T)
|
||||
|
||||
public:
|
||||
typedef T (*CopySignFunc)(T, T);
|
||||
|
||||
void testSpecialNumbers(CopySignFunc func) {
|
||||
EXPECT_FP_EQ(aNaN, func(aNaN, -1.0));
|
||||
EXPECT_FP_EQ(aNaN, func(aNaN, 1.0));
|
||||
|
||||
EXPECT_FP_EQ(negInf, func(inf, -1.0));
|
||||
EXPECT_FP_EQ(inf, func(negInf, 1.0));
|
||||
|
||||
EXPECT_FP_EQ(negZero, func(zero, -1.0));
|
||||
EXPECT_FP_EQ(zero, func(negZero, 1.0));
|
||||
}
|
||||
|
||||
void testRange(CopySignFunc 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;
|
||||
|
||||
double res1 = func(x, -x);
|
||||
ASSERT_FP_EQ(res1, -x);
|
||||
|
||||
double res2 = func(x, x);
|
||||
ASSERT_FP_EQ(res2, x);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#define LIST_COPYSIGN_TESTS(T, func) \
|
||||
using LlvmLibcCopySignTest = CopySignTest<T>; \
|
||||
TEST_F(LlvmLibcCopySignTest, SpecialNumbers) { testSpecialNumbers(&func); } \
|
||||
TEST_F(LlvmLibcCopySignTest, Range) { testRange(&func); }
|
|
@ -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); }
|
|
@ -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); }
|
|
@ -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); }
|
|
@ -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); }
|
|
@ -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); }
|
|
@ -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); }
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "CeilTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceil(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_CEIL_TESTS(double, __llvm_libc::ceil)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "CeilTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceilf(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_CEIL_TESTS(float, __llvm_libc::ceilf)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "CeilTest.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"
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, __llvm_libc::ceill(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_CEIL_TESTS(long double, __llvm_libc::ceill)
|
||||
|
|
|
@ -6,40 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "CopySignTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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);
|
||||
|
||||
double res2 = __llvm_libc::copysign(x, x);
|
||||
ASSERT_FP_EQ(res2, x);
|
||||
}
|
||||
}
|
||||
LIST_COPYSIGN_TESTS(double, __llvm_libc::copysign)
|
||||
|
|
|
@ -6,40 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "CopySignTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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);
|
||||
|
||||
float res2 = __llvm_libc::copysignf(x, x);
|
||||
ASSERT_FP_EQ(res2, x);
|
||||
}
|
||||
}
|
||||
LIST_COPYSIGN_TESTS(float, __llvm_libc::copysignf)
|
||||
|
|
|
@ -6,40 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "CopySignTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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);
|
||||
|
||||
long double res2 = __llvm_libc::copysignl(x, x);
|
||||
ASSERT_FP_EQ(res2, x);
|
||||
}
|
||||
}
|
||||
LIST_COPYSIGN_TESTS(long double, __llvm_libc::copysignl)
|
||||
|
|
|
@ -6,37 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FAbsTest.h"
|
||||
|
||||
#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;
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
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)
|
||||
|
|
|
@ -6,37 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FAbsTest.h"
|
||||
|
||||
#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;
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
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)
|
||||
|
|
|
@ -6,37 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FAbsTest.h"
|
||||
|
||||
#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;
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
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)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FloorTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floor(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_FLOOR_TESTS(double, __llvm_libc::floor)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FloorTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorf(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_FLOOR_TESTS(float, __llvm_libc::floorf)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FloorTest.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"
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, __llvm_libc::floorl(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_FLOOR_TESTS(long double, __llvm_libc::floorl)
|
||||
|
|
|
@ -6,67 +6,8 @@
|
|||
//
|
||||
//===---------------------------------------------------------------------===//
|
||||
|
||||
#include "FMaxTest.h"
|
||||
|
||||
#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));
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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)
|
||||
|
|
|
@ -4,69 +4,10 @@
|
|||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===---------------------------------------------------------------------===//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FMaxTest.h"
|
||||
|
||||
#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));
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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)
|
||||
|
|
|
@ -4,69 +4,10 @@
|
|||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===---------------------------------------------------------------------===//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "FMaxTest.h"
|
||||
|
||||
#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));
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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)
|
||||
|
|
|
@ -6,67 +6,8 @@
|
|||
//
|
||||
//===---------------------------------------------------------------------===//
|
||||
|
||||
#include "FMinTest.h"
|
||||
|
||||
#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));
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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)
|
||||
|
|
|
@ -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 "FMinTest.h"
|
||||
|
||||
#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));
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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)
|
||||
|
|
|
@ -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 "FMinTest.h"
|
||||
|
||||
#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));
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "RoundTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::round(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_ROUND_TESTS(double, __llvm_libc::round)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "RoundTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundf(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_ROUND_TESTS(float, __llvm_libc::roundf)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "RoundTest.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"
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundl(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_ROUND_TESTS(long double, __llvm_libc::roundl)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "TruncTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::trunc(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_TRUNC_TESTS(double, __llvm_libc::trunc)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "TruncTest.h"
|
||||
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncf(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_TRUNC_TESTS(float, __llvm_libc::truncf)
|
||||
|
|
|
@ -6,70 +6,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "TruncTest.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"
|
||||
#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));
|
||||
|
||||
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;
|
||||
|
||||
ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, __llvm_libc::truncl(x), 0.0);
|
||||
}
|
||||
}
|
||||
LIST_TRUNC_TESTS(long double, __llvm_libc::truncl)
|
||||
|
|
|
@ -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( \
|
||||
|
|
Loading…
Reference in New Issue