libstdc++-v3/testsuite/26_numerics/headers/cmath/nextafter_c++23.cc

   1 // Copyright (C) 2022-2023 Free Software Foundation, Inc.
   2 //
   3 // This file is part of the GNU ISO C++ Library.  This library is free
   4 // software; you can redistribute it and/or modify it under the
   5 // terms of the GNU General Public License as published by the
   6 // Free Software Foundation; either version 3, or (at your option)
   7 // any later version.
   8
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 // You should have received a copy of the GNU General Public License along
  15 // with this library; see the file COPYING3.  If not see
  16 // <http://www.gnu.org/licenses/>.
  17
  18 // { dg-do run { target c++23 } }
  19
  20 #include <stdfloat>
  21 #include <cmath>
  22 #include <limits>
  23 #include <testsuite_hooks.h>
  24
  25 template <typename T>
  26 void
  27 test ()
  28 {
  29   using lim = std::numeric_limits<T>;
  30   T t0 = std::nextafter(T(-0.0), T(2.0));
  31   VERIFY( t0 == lim::denorm_min() );
  32   T t1 = std::nextafter(T(), T(1.0));
  33   VERIFY( t1 == lim::denorm_min() );
  34   T t2 = std::nextafter(T(), T());
  35   VERIFY( t2 == T() && !std::signbit(t2) );
  36   T t3 = std::nextafter(lim::denorm_min(), T(-2.0));
  37   VERIFY( t3 == T() && !std::signbit(t3) );
  38   T t4 = std::nextafter(lim::min(), T(-0.0));
  39   VERIFY( std::fpclassify(t4) == FP_SUBNORMAL && t4 > T() );
  40   T t5 = std::nextafter(t4, T(1.0));
  41   VERIFY( t5 == lim::min() );
  42   T t6 = std::nextafter(lim::min(), lim::infinity());
  43   VERIFY( std::fpclassify(t6) == FP_NORMAL && t6 > lim::min() );
  44   T t7 = std::nextafter(t6, -lim::infinity());
  45   VERIFY( t7 == lim::min() );
  46   T t8 = std::nextafter(T(16.0), T(16.5));
  47   VERIFY( t8 > t7 );
  48   T t9 = std::nextafter(t8, T(15.5));
  49   VERIFY( t9 == T(16.0) );
  50   T t10 = std::nextafter(lim::max(), T(-0.5));
  51   VERIFY( std::fpclassify(t10) == FP_NORMAL && t10 < lim::max() );
  52   T t11 = std::nextafter(t10, lim::infinity());
  53   VERIFY( t11 == lim::max() );
  54   T t12 = std::nextafter(t11, lim::infinity());
  55   VERIFY( std::fpclassify(t12) == FP_INFINITE && !std::signbit(t12) );
  56   T t13 = std::nextafter(lim::infinity(), t12);
  57   VERIFY( t13 == t12 );
  58   T t14 = std::nextafter(t13, T(1.0));
  59   VERIFY( t14 == lim::max() );
  60   T t15 = std::nextafter(lim::quiet_NaN(), T());
  61   VERIFY( std::fpclassify(t15) == FP_NAN );
  62   T t16 = std::nextafter(T(17.0), lim::quiet_NaN());
  63   VERIFY( std::fpclassify(t16) == FP_NAN );
  64   T t17 = std::nextafter(T(), T(-0.0));
  65   VERIFY( t17 == T() && std::signbit(t17) );
  66   T t20 = std::nextafter(T(-0.0), T(-2.0));
  67   VERIFY( t20 == -lim::denorm_min() );
  68   T t21 = std::nextafter(T(), T(-1.0));
  69   VERIFY( t21 == -lim::denorm_min() );
  70   T t22 = std::nextafter(T(-0.0), T(-0.0));
  71   VERIFY( t22 == T() && std::signbit(t22) );
  72   T t23 = std::nextafter(-lim::denorm_min(), T(2.0));
  73   VERIFY( t23 == T() && std::signbit(t23) );
  74   T t24 = std::nextafter(-lim::min(), T());
  75   VERIFY( std::fpclassify(t24) == FP_SUBNORMAL && t24 < T() );
  76   T t25 = std::nextafter(t24, T(-1.0));
  77   VERIFY( t25 == -lim::min() );
  78   T t26 = std::nextafter(-lim::min(), -lim::infinity());
  79   VERIFY( std::fpclassify(t26) == FP_NORMAL && t26 < -lim::min() );
  80   T t27 = std::nextafter(t26, lim::infinity());
  81   VERIFY( t27 == -lim::min() );
  82   T t28 = std::nextafter(T(-16.0), T(-16.5));
  83   VERIFY( t28 < t27 );
  84   T t29 = std::nextafter(t28, T(-15.5));
  85   VERIFY( t29 == T(-16.0) );
  86   T t30 = std::nextafter(-lim::max(), T(0.5));
  87   VERIFY( std::fpclassify(t30) == FP_NORMAL && t30 > -lim::max() );
  88   T t31 = std::nextafter(t30, -lim::infinity());
  89   VERIFY( t31 == -lim::max() );
  90   T t32 = std::nextafter(t31, -lim::infinity());
  91   VERIFY( std::fpclassify(t32) == FP_INFINITE && std::signbit(t32) );
  92   T t33 = std::nextafter(-lim::infinity(), t32);
  93   VERIFY( t33 == t32 );
  94   T t34 = std::nextafter(t33, T(-1.0));
  95   VERIFY( t34 == -lim::max() );
  96   T t35 = std::nextafter(-lim::quiet_NaN(), T());
  97   VERIFY( std::fpclassify(t35) == FP_NAN );
  98   T t36 = std::nextafter(T(-17.0), lim::quiet_NaN());
  99   VERIFY( std::fpclassify(t36) == FP_NAN );
 100   T t37 = std::nextafter(T(-0.0), T());
 101   VERIFY( t37 == T() && !std::signbit(t37) );
 102   static_assert(std::nextafter(T(1.0), T(2.0)) > T(1.0));
 103   static_assert(std::nextafter(std::nextafter(T(1.0), T(5.0)), T(0.0)) == T(1.0));
 104 }
 105
 106 int
 107 main ()
 108 {
 109 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 110   test <std::float16_t>();
 111 #endif
 112 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 113   test <std::float32_t>();
 114 #endif
 115 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
 116   test <std::float64_t>();
 117 #endif
 118 #if defined(__STDCPP_FLOAT128_T__) \
 119     && (defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY128) \
 120         || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
 121   test <std::float128_t>();
 122 #endif
 123 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 124   test <std::bfloat16_t>();
 125 #endif
 126 }