[libc][math][c23] Update for comments.

Author: harrisonGPU

libc/src/math/generic/CMakeLists.txt

@@ -4003,6 +4003,7 @@ add_entrypoint_object(
     libc.hdr.errno_macros
     libc.hdr.fenv_macros
     libc.src.__support.FPUtil.cast
+    libc.src.__support.FPUtil.fenv_impl
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.multiply_add
     libc.src.__support.FPUtil.polyeval

libc/src/math/generic/atanhf16.cpp

@@ -1,4 +1,4 @@
-//===-- Implementation of atanh(x) function -------------------------------===//
+//===-- Half-precision atanh(x) function ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -10,6 +10,7 @@
 #include "explogxf.h"
 #include "hdr/errno_macros.h"
 #include "hdr/fenv_macros.h"
+#include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PolyEval.h"
 #include "src/__support/FPUtil/cast.h"
@@ -21,26 +22,27 @@
 namespace LIBC_NAMESPACE_DECL {
 
 LLVM_LIBC_FUNCTION(float16, atanhf16, (float16 x)) {
-  using FPBits = typename fputil::FPBits<float16>;
+  using FPBits = fputil::FPBits<float16>;
 
   FPBits xbits(x);
   Sign sign = xbits.sign();
   uint16_t x_abs = xbits.abs().uintval();
 
+  // |x| >= 1
   if (LIBC_UNLIKELY(x_abs >= 0x3c00U)) {
-    if (xbits.is_nan()) {
+    if (xbits.is_nan())
       return x;
-    }
+
     // |x| == 1.0
     if (x_abs == 0x3c00U) {
       fputil::set_errno_if_required(ERANGE);
       fputil::raise_except_if_required(FE_DIVBYZERO);
       return FPBits::inf(sign).get_val();
-    } else {
-      fputil::set_errno_if_required(EDOM);
-      fputil::raise_except_if_required(FE_INVALID);
-      return FPBits::quiet_nan().get_val();
     }
+    // |x| > 1.0
+    fputil::set_errno_if_required(EDOM);
+    fputil::raise_except_if_required(FE_INVALID);
+    return FPBits::quiet_nan().get_val();
   }
 
   // For |x| less than approximately 0.10
@@ -52,35 +54,25 @@ LLVM_LIBC_FUNCTION(float16, atanhf16, (float16 x)) {
     //    atanh(x) ≈ x + (1/3)*x^3
     if (LIBC_UNLIKELY(x_abs < 0x0100U)) {
       return static_cast<float16>(
-          LIBC_UNLIKELY(x_abs == 0) ? x : (x + 0x1.555556p-2 * x * x * x));
+          LIBC_UNLIKELY(x_abs == 0) ? x : (x + 0x1.555556p-2f * x * x * x));
     }
 
     // For 0x0100U <= |x| <= 0x2e66U:
     //   Let t = x^2.
     //   Define P(t) ≈ (1/3)*t + (1/5)*t^2 + (1/7)*t^3 + (1/9)*t^4 + (1/11)*t^5.
-    // The coefficients below were derived using Sollya:
-    //   > display = hexadecimal;
-    //   > round(1/3, SG, RN);
-    //   > round(1/5, SG, RN);
-    //   > round(1/7, SG, RN);
-    //   > round(1/9, SG, RN);
-    //   > round(1/11, SG, RN);
-    // This yields:
-    //   0x1.555556p-2
-    //   0x1.99999ap-3
-    //   0x1.24924ap-3
-    //   0x1.c71c72p-4
-    //   0x1.745d18p-4f
+    // Coefficients (from Sollya, RN, hexadecimal):
+    //  1/3 = 0x1.555556p-2, 1/5 = 0x1.99999ap-3, 1/7 = 0x1.24924ap-3,
+    //  1/9 = 0x1.c71c72p-4, 1/11 = 0x1.745d18p-4f
     // Thus, atanh(x) ≈ x * (1 + P(x^2)).
     float xf = x;
     float x2 = xf * xf;
     float pe = fputil::polyeval(x2, 0.0f, 0x1.555556p-2f, 0x1.99999ap-3f,
                                 0x1.24924ap-3f, 0x1.c71c72p-4f, 0x1.745d18p-4f);
-    return static_cast<float16>(fputil::multiply_add(xf, pe, xf));
+    return fputil::cast<float16>(fputil::multiply_add(xf, pe, xf));
   }
 
   float xf = x;
-  return static_cast<float16>(0.5 * log_eval((xf + 1.0) / (xf - 1.0)));
+  return fputil::cast<float16>(0.5 * log_eval((xf + 1.0) / (xf - 1.0)));
 }
 
 } // namespace LIBC_NAMESPACE_DECL

libc/test/src/math/atanhf16_test.cpp

@@ -7,7 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/FPUtil/FPBits.h"
-#include "src/errno/libc_errno.h"
 #include "src/math/atanhf16.h"
 #include "test/UnitTest/FPMatcher.h"
 #include "test/UnitTest/Test.h"
@@ -17,13 +16,13 @@
 using LlvmLibcAtanhf16Test = LIBC_NAMESPACE::testing::FPTest<float16>;
 namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
 
-// Range for positive numbers: [0, 1)
+// Range for positive numbers: [0, +Inf]
 static constexpr uint16_t POS_START = 0x0000U;
-static constexpr uint16_t POS_STOP = 0x3C00;
+static constexpr uint16_t POS_STOP = 0x7C00U;
 
-// Range for negative numbers: (-1, 0]
-static constexpr uint16_t NEG_START = 0xBBFFU;
-static constexpr uint16_t NEG_STOP = 0x8000U;
+// Range for negative numbers: [-Inf, 0]
+static constexpr uint16_t NEG_START = 0x8000U;
+static constexpr uint16_t NEG_STOP = 0xFC00U;
 
 TEST_F(LlvmLibcAtanhf16Test, PositiveRange) {
   for (uint16_t v = POS_START; v < POS_STOP; ++v) {
@@ -34,7 +33,7 @@ TEST_F(LlvmLibcAtanhf16Test, PositiveRange) {
 }
 
 TEST_F(LlvmLibcAtanhf16Test, NegativeRange) {
-  for (uint16_t v = NEG_START; v >= NEG_STOP; --v) {
+  for (uint16_t v = NEG_START; v <= NEG_STOP; ++v) {
     float16 x = FPBits(v).get_val();
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atanh, x,
                                    LIBC_NAMESPACE::atanhf16(x), 0.5);

libc/test/src/math/smoke/atanhf16_test.cpp

@@ -22,9 +22,7 @@ TEST_F(LlvmLibcAtanhf16Test, SpecialNumbers) {
   EXPECT_FP_EQ_ALL_ROUNDING(zero, LIBC_NAMESPACE::atanhf16(zero));
   EXPECT_MATH_ERRNO(0);
 
-  EXPECT_FP_EQ_ALL_ROUNDING(
-      -0.0f,
-      LIBC_NAMESPACE::atanhf16(LIBC_NAMESPACE::fputil::cast<float16>(-0.0f)));
+  EXPECT_FP_EQ_ALL_ROUNDING(neg_zero, LIBC_NAMESPACE::atanhf16(neg_zero));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ_WITH_EXCEPTION(