[libc][math][c23] Add acoshf16 C23 math function.

libc/config/linux/aarch64/entrypoints.txt

@@ -644,6 +644,7 @@ endif()
 if(LIBC_TYPES_HAS_FLOAT16)
   list(APPEND TARGET_LIBM_ENTRYPOINTS
     # math.h C23 _Float16 entrypoints
+    libc.src.math.acoshf16
     libc.src.math.canonicalizef16
     libc.src.math.ceilf16
     libc.src.math.copysignf16

libc/config/linux/riscv/entrypoints.txt

@@ -397,6 +397,7 @@ set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.acosf
     libc.src.math.acoshf
+    libc.src.math.acoshf16
     libc.src.math.asinf
     libc.src.math.asinhf
     libc.src.math.atan2

libc/src/math/generic/acoshf16.cpp

@@ -33,19 +33,22 @@ LLVM_LIBC_FUNCTION(float16, acoshf16, (float16 x)) {
   using FPBits = fputil::FPBits<float16>;
   FPBits xbits(x);
   uint16_t x_u = xbits.uintval();
-  uint16_t x_abs = x_u & 0x7fff;
+
+  // Domain error for inputs less than 1.0.
+  if (LIBC_UNLIKELY(x <= 1.0f)) {
+    if (x == 1.0f)
+      return FPBits::zero().get_val();
+    fputil::set_errno_if_required(EDOM);
+    fputil::raise_except_if_required(FE_INVALID);
+    return FPBits::quiet_nan().get_val();
+  }
 
   // Check for NaN input first.
-  if (LIBC_UNLIKELY(xbits.is_nan())) {
+  if (LIBC_UNLIKELY(xbits.is_inf_or_nan())) {
     if (xbits.is_signaling_nan()) {
       fputil::raise_except_if_required(FE_INVALID);
       return FPBits::quiet_nan().get_val();
     }
-    return x;
-  }
-
-  // Check for infinite inputs.
-  if (LIBC_UNLIKELY(xbits.is_inf())) {
     if (xbits.is_neg()) {
       fputil::set_errno_if_required(EDOM);
       fputil::raise_except_if_required(FE_INVALID);
@@ -54,17 +57,6 @@ LLVM_LIBC_FUNCTION(float16, acoshf16, (float16 x)) {
     return x;
   }
 
-  // Domain error for inputs less than 1.0.
-  if (LIBC_UNLIKELY(x_abs < 0x3c00U)) {
-    fputil::set_errno_if_required(EDOM);
-    fputil::raise_except_if_required(FE_INVALID);
-    return FPBits::quiet_nan().get_val();
-  }
-
-  // acosh(1.0) exactly equals 0.0
-  if (LIBC_UNLIKELY(x_u == 0x3c00U))
-    return FPBits::zero().get_val();
-
   if (auto r = ACOSHF16_EXCEPTS.lookup(xbits.uintval());
       LIBC_UNLIKELY(r.has_value()))
     return r.value();
@@ -74,16 +66,29 @@ LLVM_LIBC_FUNCTION(float16, acoshf16, (float16 x)) {
   // ([1, 1.25)).
   //
   // Brief derivation:
-  // 1. Start from the definition: acosh(x) = y means x = cosh(y).
-  // 2. Set x = 1 + delta. For small delta, y ≈ sqrt(2 * delta).
-  // 3. Expand acosh(1 + delta) using Taylor series around delta=0:
+  // 1. Expand acosh(1 + delta) using Taylor series around delta=0:
   //    acosh(1 + delta) ≈ sqrt(2 * delta) * [1 - delta/12 + 3*delta^2/160
   //                     - 5*delta^3/896 + 35*delta^4/18432 + ...]
-  // 4. Truncate the series to fit accurately for delta in [0, 0.25].
-  // 5. Polynomial coefficients (from sollya) used here are:
+  // 2. Truncate the series to fit accurately for delta in [0, 0.25].
+  // 3. Polynomial coefficients (from sollya) used here are:
   //    P(delta) ≈ 1 - 0x1.555556p-4 * delta + 0x1.333334p-6 * delta^2
   //               - 0x1.6db6dcp-8 * delta^3 + 0x1.f1c71cp-10 * delta^4
-  if (LIBC_UNLIKELY(xf < 1.25f)) {
+  // 4. The Sollya commands used to generate these coefficients were:
+  //      > display = hexadecimal;
+  //      > round(1/12, SG, RN);
+  //      > round(3/160, SG, RN);
+  //      > round(5/896, SG, RN);
+  //      > round(35/18432, SG, RN);
+  //      With hexadecimal display mode enabled, the outputs were:
+  //      0x1.555556p-4
+  //      0x1.333334p-6
+  //      0x1.6db6dcp-8
+  //      0x1.f1c71cp-10
+  // 5. The maximum absolute error, estimated using:
+  //      dirtyinfnorm(acosh(1 + x) - sqrt(2*x) * P(x), [0, 0.25])
+  //    is:
+  //      0x1.d84281p-22
+  if (LIBC_UNLIKELY(x_u < 1.25f)) {
     float delta = xf - 1.0f;
     float sqrt_2_delta = fputil::sqrt<float>(2.0 * delta);
     float pe = fputil::polyeval(delta, 0x1p+0f, -0x1.555556p-4f, 0x1.333334p-6f,

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

@@ -49,4 +49,22 @@ TEST_F(LlvmLibcAcoshf16Test, SpecialNumbers) {
   EXPECT_FP_EQ(aNaN, LIBC_NAMESPACE::acoshf16(
                          LIBC_NAMESPACE::fputil::cast<float16>(0.5)));
   EXPECT_MATH_ERRNO(EDOM);
+
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      aNaN,
+      LIBC_NAMESPACE::acoshf16(LIBC_NAMESPACE::fputil::cast<float16>(-1.0)),
+      FE_INVALID);
+  EXPECT_MATH_ERRNO(EDOM);
+
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      aNaN,
+      LIBC_NAMESPACE::acoshf16(LIBC_NAMESPACE::fputil::cast<float16>(-2.0)),
+      FE_INVALID);
+  EXPECT_MATH_ERRNO(EDOM);
+
+  EXPECT_FP_EQ_WITH_EXCEPTION(
+      aNaN,
+      LIBC_NAMESPACE::acoshf16(LIBC_NAMESPACE::fputil::cast<float16>(-3.0)),
+      FE_INVALID);
+  EXPECT_MATH_ERRNO(EDOM);
 }