1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // UNSUPPORTED: c++03, c++11, c++14, c++17
10
11 // <numeric>
12
13 // template <class _Float>
14 // _Tp midpoint(_Float __a, _Float __b) noexcept
15 //
16
17 #include <limits>
18 #include <numeric>
19 #include <cassert>
20
21 #include "test_macros.h"
22 #include "fp_compare.h"
23
24 // Totally arbitrary picks for precision
25 template <typename T>
26 constexpr T fp_error_pct();
27
28 template <>
fp_error_pct()29 constexpr float fp_error_pct<float>() { return 1.0e-4f; }
30
31 template <>
fp_error_pct()32 constexpr double fp_error_pct<double>() { return 1.0e-12; }
33
34 template <>
fp_error_pct()35 constexpr long double fp_error_pct<long double>() { return 1.0e-13l; }
36
37
38 template <typename T>
fp_test()39 void fp_test()
40 {
41 ASSERT_SAME_TYPE(T, decltype(std::midpoint(T(), T())));
42 ASSERT_NOEXCEPT( std::midpoint(T(), T()));
43
44 constexpr T maxV = std::numeric_limits<T>::max();
45 constexpr T minV = std::numeric_limits<T>::min();
46
47 // Things that can be compared exactly
48 static_assert((std::midpoint(T(0), T(0)) == T(0)), "");
49 static_assert((std::midpoint(T(2), T(4)) == T(3)), "");
50 static_assert((std::midpoint(T(4), T(2)) == T(3)), "");
51 static_assert((std::midpoint(T(3), T(4)) == T(3.5)), "");
52 static_assert((std::midpoint(T(0), T(0.4)) == T(0.2)), "");
53
54 // Things that can't be compared exactly
55 constexpr T pct = fp_error_pct<T>();
56 assert((fptest_close_pct(std::midpoint(T( 1.3), T(11.4)), T( 6.35), pct)));
57 assert((fptest_close_pct(std::midpoint(T(11.33), T(31.45)), T(21.39), pct)));
58 assert((fptest_close_pct(std::midpoint(T(-1.3), T(11.4)), T( 5.05), pct)));
59 assert((fptest_close_pct(std::midpoint(T(11.4), T(-1.3)), T( 5.05), pct)));
60 assert((fptest_close_pct(std::midpoint(T(0.1), T(0.4)), T(0.25), pct)));
61
62 assert((fptest_close_pct(std::midpoint(T(11.2345), T(14.5432)), T(12.88885), pct)));
63
64 // From e to pi
65 assert((fptest_close_pct(std::midpoint(T(2.71828182845904523536028747135266249775724709369995),
66 T(3.14159265358979323846264338327950288419716939937510)),
67 T(2.92993724102441923691146542731608269097720824653752), pct)));
68
69 assert((fptest_close_pct(std::midpoint(maxV, T(0)), maxV/2, pct)));
70 assert((fptest_close_pct(std::midpoint(T(0), maxV), maxV/2, pct)));
71 assert((fptest_close_pct(std::midpoint(minV, T(0)), minV/2, pct)));
72 assert((fptest_close_pct(std::midpoint(T(0), minV), minV/2, pct)));
73 assert((fptest_close_pct(std::midpoint(maxV, maxV), maxV, pct)));
74 assert((fptest_close_pct(std::midpoint(minV, minV), minV, pct)));
75 assert((fptest_close_pct(std::midpoint(maxV, minV), maxV/2, pct)));
76 assert((fptest_close_pct(std::midpoint(minV, maxV), maxV/2, pct)));
77
78 // Near the min and the max
79 assert((fptest_close_pct(std::midpoint(maxV*T(0.75), maxV*T(0.50)), maxV*T(0.625), pct)));
80 assert((fptest_close_pct(std::midpoint(maxV*T(0.50), maxV*T(0.75)), maxV*T(0.625), pct)));
81 assert((fptest_close_pct(std::midpoint(minV*T(2), minV*T(8)), minV*T(5), pct)));
82
83 // Big numbers of different signs
84 assert((fptest_close_pct(std::midpoint(maxV*T( 0.75), maxV*T(-0.5)), maxV*T( 0.125), pct)));
85 assert((fptest_close_pct(std::midpoint(maxV*T(-0.75), maxV*T( 0.5)), maxV*T(-0.125), pct)));
86
87 // Denormalized values
88 // TODO
89
90 // Check two values "close to each other"
91 T d1 = T(3.14);
92 T d0 = std::nextafter(d1, T(2));
93 T d2 = std::nextafter(d1, T(5));
94 assert(d0 < d1); // sanity checking
95 assert(d1 < d2); // sanity checking
96
97 #if defined(__PPC__) && (defined(__LONG_DOUBLE_128__) && __LONG_DOUBLE_128__) && \
98 !(defined(__LONG_DOUBLE_IEEE128__) && __LONG_DOUBLE_IEEE128__)
99 // For 128 bit long double implemented as 2 doubles on PowerPC,
100 // nextafterl() of libm gives imprecise results which fails the
101 // midpoint() tests below. So skip the test for this case.
102 if constexpr (sizeof(T) != 16)
103 #endif
104 {
105 // Since there's nothing in between, the midpoint has to be one or the other
106 T res;
107 res = std::midpoint(d0, d1);
108 assert(res == d0 || res == d1);
109 assert(d0 <= res);
110 assert(res <= d1);
111 res = std::midpoint(d1, d0);
112 assert(res == d0 || res == d1);
113 assert(d0 <= res);
114 assert(res <= d1);
115
116 res = std::midpoint(d1, d2);
117 assert(res == d1 || res == d2);
118 assert(d1 <= res);
119 assert(res <= d2);
120 res = std::midpoint(d2, d1);
121 assert(res == d1 || res == d2);
122 assert(d1 <= res);
123 assert(res <= d2);
124 }
125 }
126
127
main(int,char **)128 int main (int, char**)
129 {
130 fp_test<float>();
131 fp_test<double>();
132 fp_test<long double>();
133
134 return 0;
135 }
136