[libc-commits] [libc] [libc][math][c23] implement C23 math function asinpif16 (PR #146226)

[via libc-commits]

================
@@ -0,0 +1,174 @@
+//===-- Half-precision asinf16(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.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception.
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/math/asinpif16.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"
+#include "src/__support/FPUtil/except_value_utils.h"
+#include "src/__support/FPUtil/multiply_add.h"
+#include "src/__support/FPUtil/sqrt.h"
+#include "src/__support/macros/optimization.h"
+
+namespace LIBC_NAMESPACE_DECL {
+
+static constexpr float16 ONE_OVER_TWO = 0.5f16;
+
+#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+static constexpr size_t N_ASINFPI_EXCEPTS = 5;
+static constexpr float16 ONE_OVER_SIX = 0.166748046875f16;
+
+static constexpr fputil::ExceptValues<float16, N_ASINFPI_EXCEPTS>
+    ASINFPI_EXCEPTS{{
+        // (input_hex, RZ_output_hex, RU_offset, RD_offset, RN_offset)
+        // x = 0.0, asinfpi(0.0) = 0.0
+        {0x0000, 0x0000, 0, 0, 0},
+
+        // x = 1.0, asinfpi(1) = 1/2
+        {(fputil::FPBits<float16>(-1.0f16)).uintval(),
+         (fputil::FPBits<float16>(-ONE_OVER_TWO)).uintval(), 0, 0, 0},
+
+        // x = -1.0, asinfpi(-1.0) = -1/2
+        {(fputil::FPBits<float16>(-1.0f16)).uintval(),
+         (fputil::FPBits<float16>(-ONE_OVER_TWO)).uintval(), 0, 0, 0},
+
+        // x = 0.5, asinfpi(0.5) = 1/6
+        {(fputil::FPBits<float16>(0.5f16)).uintval(),
+         (fputil::FPBits<float16>(ONE_OVER_SIX)).uintval(), 0, 0, 0},
+
+        // x = -0.5, asinfpi(0.5) = -1/6
+        {(fputil::FPBits<float16>(-0.5f16)).uintval(),
+         (fputil::FPBits<float16>(-ONE_OVER_SIX)).uintval(), 0, 0, 0},
+
+    }};
+#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+
+LLVM_LIBC_FUNCTION(float16, asinpif16, (float16 x)) {
+  using FPBits = fputil::FPBits<float16>;
+
+  FPBits xbits(x);
+  uint16_t x_uint = xbits.uintval();
+  bool is_neg = static_cast<bool>(x_uint >> 15);
+  float16 x_abs = is_neg ? -x : x;
+
+  auto __signed_result = [is_neg](float16 r) -> float16 {
+    return is_neg ? -r : r;
+  };
+
+  if (LIBC_UNLIKELY(x_abs > 1.0f16)) {
+    // aspinf16(NaN) = NaN
+    if (xbits.is_nan()) {
+      if (xbits.is_signaling_nan()) {
+        fputil::raise_except_if_required(FE_INVALID);
+        return FPBits::quiet_nan().get_val();
+      }
+      return x;
+    }
+
+    // 1 < |x| <= +/-inf
+    fputil::raise_except_if_required(FE_INVALID);
+    fputil::set_errno_if_required(EDOM);
+
+    return FPBits::quiet_nan().get_val();
+  }
+
+#ifndef LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+  // exceptional values
+  if (auto r = ASINFPI_EXCEPTS.lookup(x_uint); LIBC_UNLIKELY(r.has_value())) {
+    return r.value();
+  }
+#endif // !LIBC_MATH_HAS_SKIP_ACCURATE_PASS
+
+  // the coefficients for the polynomial approximation of asin(x)/pi in the
+  // range [0, 0.5] extracted using python-sympy
+  //
+  // Python code to generate the coefficients:
+  //  > from sympy import *
+  //  > import math
+  //  > x = symbols('x')
+  //  > print(series(asin(x)/math.pi, x, 0, 21))
+  //
+  // OUTPUT:
+  //
+  // 0.318309886183791*x + 0.0530516476972984*x**3 + 0.0238732414637843*x**5 +
+  // 0.0142102627760621*x**7 + 0.00967087327815336*x**9 +
+  // 0.00712127941391293*x**11 + 0.00552355646848375*x**13 +
+  // 0.00444514782463692*x**15 + 0.00367705242846804*x**17 +
+  // 0.00310721681820837*x**19 + O(x**21)
+  //
+  // it's very accurate in the range [0, 0.5] and has a maximum error of
+  // 0.0000000000000001 in the range [0, 0.5].
+  static constexpr float16 POLY_COEFFS[10] = {
+      0.318309886183791f16,   // x^1
+      0.0530516476972984f16,  // x^3
+      0.0238732414637843f16,  // x^5
+      0.0142102627760621f16,  // x^7
+      0.00967087327815336f16, // x^9
+      0.00712127941391293f16, // x^11
+      0.00552355646848375f16, // x^13
+      0.00444514782463692f16, // x^15
+      0.00367705242846804f16, // x^17
+      0.00310721681820837f16  // x^19
+  };
+
+  // polynomial evaluation using horner's method
+  // work only for |x| in [0, 0.5]
+  auto __asinpi_polyeval = [](float16 xsq) -> float16 {
----------------
overmighty wrote:

Nit:

```suggestion
  auto asinpi_polyeval = [](float16 xsq) -> float16 {
```

https://github.com/llvm/llvm-project/pull/146226