libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp

   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 <>
  29 constexpr float fp_error_pct<float>() { return 1.0e-4f; }
  30
  31 template <>
  32 constexpr double fp_error_pct<double>() { return 1.0e-12; }
  33
  34 template <>
  35 constexpr long double fp_error_pct<long double>() { return 1.0e-13l; }
  36
  37
  38 template <typename T>
  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
 128 int main (int, char**)
 129 {
 130     fp_test<float>();
 131     fp_test<double>();
 132     fp_test<long double>();
 133
 134     return 0;
 135 }