1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
//===-- Utility class to test different flavors of nearbyint ----*- 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_SRC_MATH_NEARBYINTTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_NEARBYINTTEST_H
#include "src/__support/CPP/algorithm.h"
#include "src/__support/CPP/array.h"
#include "test/UnitTest/FEnvSafeTest.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
using namespace LIBC_NAMESPACE::fputil::testing;
namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
template <typename T>
class NearbyIntTestTemplate : public LIBC_NAMESPACE::testing::FEnvSafeTest {
DECLARE_SPECIAL_CONSTANTS(T)
static constexpr LIBC_NAMESPACE::cpp::array<RoundingMode, 4> ROUNDING_MODES =
{
RoundingMode::Upward,
RoundingMode::Downward,
RoundingMode::TowardZero,
RoundingMode::Nearest,
};
static constexpr StorageType MIN_SUBNORMAL =
FPBits::min_subnormal().uintval();
static constexpr StorageType MAX_SUBNORMAL =
FPBits::max_subnormal().uintval();
static constexpr StorageType MIN_NORMAL = FPBits::min_normal().uintval();
static constexpr StorageType MAX_NORMAL = FPBits::max_normal().uintval();
public:
using NearbyIntFunc = T (*)(T);
void test_round_numbers(NearbyIntFunc func) {
for (RoundingMode mode : ROUNDING_MODES) {
if (ForceRoundingMode r(mode); r.success) {
EXPECT_FP_EQ(func(T(1.0)), mpfr::round(T(1.0), mode));
EXPECT_FP_EQ(func(T(-1.0)), mpfr::round(T(-1.0), mode));
EXPECT_FP_EQ(func(T(10.0)), mpfr::round(T(10.0), mode));
EXPECT_FP_EQ(func(T(-10.0)), mpfr::round(T(-10.0), mode));
EXPECT_FP_EQ(func(T(1234.0)), mpfr::round(T(1234.0), mode));
EXPECT_FP_EQ(func(T(-1234.0)), mpfr::round(T(-1234.0), mode));
}
}
}
void test_fractions(NearbyIntFunc func) {
for (RoundingMode mode : ROUNDING_MODES) {
if (ForceRoundingMode r(mode); r.success) {
EXPECT_FP_EQ(func(T(0.5)), mpfr::round(T(0.5), mode));
EXPECT_FP_EQ(func(T(-0.5)), mpfr::round(T(-0.5), mode));
EXPECT_FP_EQ(func(T(0.115)), mpfr::round(T(0.115), mode));
EXPECT_FP_EQ(func(T(-0.115)), mpfr::round(T(-0.115), mode));
EXPECT_FP_EQ(func(T(0.715)), mpfr::round(T(0.715), mode));
EXPECT_FP_EQ(func(T(-0.715)), mpfr::round(T(-0.715), mode));
}
}
}
void test_subnormal_range(NearbyIntFunc func) {
constexpr int COUNT = 100'001;
const StorageType STEP = LIBC_NAMESPACE::cpp::max(
static_cast<StorageType>((MAX_SUBNORMAL - MIN_SUBNORMAL) / COUNT),
StorageType(1));
for (StorageType i = MIN_SUBNORMAL; i <= MAX_SUBNORMAL; i += STEP) {
T x = FPBits(i).get_val();
for (RoundingMode mode : ROUNDING_MODES) {
if (ForceRoundingMode r(mode); r.success) {
EXPECT_FP_EQ(func(x), mpfr::round(x, mode));
}
}
}
}
void test_normal_range(NearbyIntFunc func) {
constexpr int COUNT = 100'001;
const StorageType STEP = LIBC_NAMESPACE::cpp::max(
static_cast<StorageType>((MAX_NORMAL - MIN_NORMAL) / COUNT),
StorageType(1));
for (StorageType i = MIN_NORMAL; i <= MAX_NORMAL; i += STEP) {
FPBits xbits(i);
T x = xbits.get_val();
// In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. We will skip them.
if (xbits.is_nan())
continue;
for (RoundingMode mode : ROUNDING_MODES) {
if (ForceRoundingMode r(mode); r.success) {
EXPECT_FP_EQ(func(x), mpfr::round(x, mode));
}
}
}
}
};
#define LIST_NEARBYINT_TESTS(F, func) \
using LlvmLibcNearbyIntTest = NearbyIntTestTemplate<F>; \
TEST_F(LlvmLibcNearbyIntTest, RoundNumbers) { test_round_numbers(&func); } \
TEST_F(LlvmLibcNearbyIntTest, Fractions) { test_fractions(&func); } \
TEST_F(LlvmLibcNearbyIntTest, SubnormalRange) { \
test_subnormal_range(&func); \
} \
TEST_F(LlvmLibcNearbyIntTest, NormalRange) { test_normal_range(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_NEARBYINTTEST_H
|
