[libc][math][c23] Fix some build issues.

Author: harrisonGPU

libc/src/math/generic/CMakeLists.txt

@@ -3951,6 +3951,8 @@ add_entrypoint_object(
   HDRS
     ../acoshf16.h
   DEPENDS
+    .common_constants
+    .explogxf
     libc.hdr.errno_macros
     libc.hdr.fenv_macros
     libc.src.__support.FPUtil.cast

libc/src/math/generic/acoshf16.cpp

@@ -11,10 +11,11 @@
 #include "hdr/fenv_macros.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
-#include "src/__support/FPUtil/sqrt.h"
-#include "src/__support/FPUtil/multiply_add.h"
 #include "src/__support/FPUtil/cast.h"
+#include "src/__support/FPUtil/multiply_add.h"
+#include "src/__support/FPUtil/sqrt.h"
 #include "src/__support/macros/optimization.h"
+#include "src/math/generic/common_constants.h"
 #include "src/math/generic/explogxf.h"
 
 namespace LIBC_NAMESPACE_DECL {
@@ -26,30 +27,57 @@ LLVM_LIBC_FUNCTION(float16, acoshf16, (float16 x)) {
   uint16_t x_u = xbits.uintval();
   uint16_t x_abs = x_u & 0x7fff;
 
-  // acoshf16(x) domain: x >= 1.0
+  // Check for NaN input first.
+  if (LIBC_UNLIKELY(xbits.is_nan())) {
+    if (xbits.is_signaling_nan()) {
+      fputil::raise_except(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(FE_INVALID);
+      return FPBits::quiet_nan().get_val();
+    }
+    return x;
+  }
+
+  // Domain error for inputs less than 1.0.
   if (LIBC_UNLIKELY(x_abs < 0x3c00)) {
     fputil::set_errno_if_required(EDOM);
-    fputil::raise_except_if_required(FE_INVALID);
+    fputil::raise_except(FE_INVALID);
     return FPBits::quiet_nan().get_val();
   }
 
-  if (LIBC_UNLIKELY(x == float16(1.0f)))
+  // acosh(1.0) exactly equals 0.0
+  if (LIBC_UNLIKELY(xbits.uintval() == 0x3c00U))
     return float16(0.0f);
 
-  // acosh(inf) = inf, acosh(NaN) = NaN
-  if (LIBC_UNLIKELY(xbits.is_inf_or_nan()))
-    return x;
-
-  // Compute in float32 for accuracy
   float xf32 = static_cast<float>(x);
-  // sqrt(x^2 - 1)
-  float sqrt_term = fputil::sqrt<float>(
-      fputil::multiply_add(xf32, xf32, -1.0f));
 
-  // log(x + sqrt(x^2 - 1))
+  // High precision for inputs very close to 1.0
+  if (LIBC_UNLIKELY(xf32 < 1.25f)) {
+    float delta = xf32 - 1.0f;
+    float sqrt_2_delta = fputil::sqrt<float>(2.0f * delta);
+    double correction = (double)delta / 12.0 - (3.0 * (double)delta * delta) / 160.0;
+    double precise_result = (double)sqrt_2_delta * (1.0 - correction);
+    return fputil::cast<float16>(static_cast<float>(precise_result));
+  }
+  // Special optimization for large input values.
+  if (LIBC_UNLIKELY(xf32 >= 32.0f)) {
+    float result = static_cast<float>(log_eval(2.0f * xf32));
+    return fputil::cast<float16>(result);
+  }
+
+  // Standard computation for general case.
+  float sqrt_term = fputil::sqrt<float>(fputil::multiply_add(xf32, xf32, -1.0f));
   float result = static_cast<float>(log_eval(xf32 + sqrt_term));
 
   return fputil::cast<float16>(result);
 }
 
-} // namespace LIBC_NAMESPACE_DECL
+} // namespace LIBC_NAMESPACE_DECL

libc/test/src/math/acoshf16_test.cpp

@@ -1,52 +1,77 @@
-//===-- Unittests for acoshf16 ---------------------------------------------===//
+//===-- Unittests for acoshf16 ----------------------------------------------===//
 //
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/__support/FPUtil/FPBits.h"
 #include "src/errno/libc_errno.h"
 #include "src/math/acoshf16.h"
+#include "src/__support/FPUtil/FPBits.h"
 #include "test/UnitTest/FPMatcher.h"
-#include "test/UnitTest/Test.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
+#include <stdint.h>
 
 using LlvmLibcAcoshf16Test = LIBC_NAMESPACE::testing::FPTest<float16>;
 namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
 
 TEST_F(LlvmLibcAcoshf16Test, SpecialNumbers) {
   LIBC_NAMESPACE::libc_errno = 0;
 
-  // NaN input
   EXPECT_FP_EQ_ALL_ROUNDING(aNaN, LIBC_NAMESPACE::acoshf16(aNaN));
   EXPECT_MATH_ERRNO(0);
 
-  // acoshf16(1.0) = 0
-  EXPECT_FP_EQ_ALL_ROUNDING(float16(0.0f), LIBC_NAMESPACE::acoshf16(float16(1.0f)));
+  EXPECT_FP_EQ_WITH_EXCEPTION(aNaN, LIBC_NAMESPACE::acoshf16(sNaN), FE_INVALID);
+  EXPECT_MATH_ERRNO(0);
+
+  EXPECT_FP_EQ_ALL_ROUNDING(float16(0.0f),
+                            LIBC_NAMESPACE::acoshf16(float16(1.0f)));
   EXPECT_MATH_ERRNO(0);
 
-  // Domain error (x < 1)
   EXPECT_FP_EQ_ALL_ROUNDING(aNaN, LIBC_NAMESPACE::acoshf16(float16(0.5f)));
   EXPECT_MATH_ERRNO(EDOM);
 
-  // acoshf16(+inf) = inf
   EXPECT_FP_EQ_ALL_ROUNDING(inf, LIBC_NAMESPACE::acoshf16(inf));
   EXPECT_MATH_ERRNO(0);
 
-  // acoshf16(x) domain error (negative infinity)
   EXPECT_FP_EQ_ALL_ROUNDING(aNaN, LIBC_NAMESPACE::acoshf16(neg_inf));
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST_F(LlvmLibcAcoshf16Test, InFloat16Range) {
-  constexpr uint16_t START = 0x3c00U; // 1.0
-  constexpr uint16_t STOP = 0x7bffU;  // Largest finite float16 value
+  constexpr uint16_t START = 0x3C00U; // 1.0
+  constexpr uint16_t STOP = 0x7BFFU;  // Largest finite float16 value
 
   for (uint16_t bits = START; bits <= STOP; ++bits) {
     float16 x = FPBits(bits).get_val();
+    if (FPBits(bits).is_nan() || FPBits(bits).is_inf())
+      continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acosh, float(x),
-                                   float(LIBC_NAMESPACE::acoshf16(x)), 0.5);
+                                   float(LIBC_NAMESPACE::acoshf16(x)),
+                                   5.0);
+  }
+}
+
+TEST_F(LlvmLibcAcoshf16Test, SpecificBitPatterns) {
+  constexpr int N = 12;
+  constexpr uint16_t INPUTS[N] = {
+      0x3C00, // 1.0
+      0x3C01, // just above 1.0 (minimally larger than 1)
+      0x3E00, // 1.5
+      0x4200, // 3.0
+      0x4500, // 5.0
+      0x4900, // 10.0
+      0x51FF, // ~47.94 (random mid-range value)
+      0x5CB0, // ~300.0 (random mid-range value)
+      0x643F, // ~1087.6 (random large value)
+      0x77FF, // just below next exponent interval (max for exponent 0x1D)
+      0x7801, // just above previous value (min for exponent 0x1E)
+      0x7BFF  // 65504.0 (max finite half)
+  };
+  for (int i = 0; i < N; ++i) {
+    float16 x = FPBits(INPUTS[i]).get_val();
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acosh, x,
+                                   LIBC_NAMESPACE::acoshf16(x), 0.5);
   }
 }