make an exhaustive test for asinpif16

Author: hulxv

libc/test/src/math/CMakeLists.txt

@@ -2275,9 +2275,7 @@ add_fp_unittest(
   SRCS
     asinpif16_test.cpp
   DEPENDS
-  libc.src.math.fabs
   libc.src.math.asinpif16  
-  libc.src.__support.FPUtil.fp_bits
 )
 
 add_fp_unittest(

libc/test/src/math/asinpif16_test.cpp

@@ -1,4 +1,4 @@
-//===-- Unittests for asinpif16 -------------------------------------------===//
+//===-- Exhaustive test for asinpif16 -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,101 +7,38 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/math/asinpif16.h"
-#include "src/math/fabs.h"
 #include "test/UnitTest/FPMatcher.h"
+#include "test/UnitTest/Test.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
 
 using LlvmLibcAsinpif16Test = LIBC_NAMESPACE::testing::FPTest<float16>;
 
-TEST_F(LlvmLibcAsinpif16Test, SpecialNumbers) {
-  using FPBits = LIBC_NAMESPACE::fputil::FPBits<float16>;
+namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
 
-  // zero
-  EXPECT_FP_EQ(0.0f16, LIBC_NAMESPACE::asinpif16(0.0f16));
+// Range: [0, Inf]
+static constexpr uint16_t POS_START = 0x0000U;
+static constexpr uint16_t POS_STOP = 0x7c00U;
 
-  // +/-1
-  EXPECT_FP_EQ(float16(0.5), LIBC_NAMESPACE::asinpif16(float16(1.0)));
-  EXPECT_FP_EQ(float16(-0.5), LIBC_NAMESPACE::asinpif16(float16(-1.0)));
+// Range: [-Inf, 0]
+static constexpr uint16_t NEG_START = 0x8000U;
+static constexpr uint16_t NEG_STOP = 0xfc00U;
 
-  // NaN inputs
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(FPBits::quiet_nan().get_val()));
-
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(FPBits::signaling_nan().get_val()));
-
-  // infinity inputs -> should return NaN
-  errno = 0;
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(), LIBC_NAMESPACE::asinpif16(inf));
-  EXPECT_MATH_ERRNO(EDOM);
-
-  errno = 0;
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(neg_inf));
-  EXPECT_MATH_ERRNO(EDOM);
-}
-
-TEST_F(LlvmLibcAsinpif16Test, OutOfRange) {
-  using FPBits = LIBC_NAMESPACE::fputil::FPBits<float16>;
-
-  // Test values > 1
-  errno = 0;
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(float16(1.5)));
-  EXPECT_MATH_ERRNO(EDOM);
-
-  errno = 0;
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(float16(2.0)));
-  EXPECT_MATH_ERRNO(EDOM);
-
-  // Test values < -1
-  errno = 0;
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(float16(-1.5)));
-  EXPECT_MATH_ERRNO(EDOM);
-
-  errno = 0;
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(float16(-2.0)));
-  EXPECT_MATH_ERRNO(EDOM);
-
-  // Test maximum normal value (should be > 1 for float16)
-  errno = 0;
-  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
-               LIBC_NAMESPACE::asinpif16(FPBits::max_normal().get_val()));
-  EXPECT_MATH_ERRNO(EDOM);
-}
-
-TEST_F(LlvmLibcAsinpif16Test, SymmetryProperty) {
-  // Test that asinpi(-x) = -asinpi(x)
-  constexpr float16 test_vals[] = {0.1f16, 0.25f16, 0.5f16, 0.75f16,
-                                   0.9f16, 0.99f16, 1.0f16};
-
-  for (float16 x : test_vals) {
-    if (x <= 1.0) {
-      float16 pos_result = LIBC_NAMESPACE::asinpif16(x);
-      float16 neg_result = LIBC_NAMESPACE::asinpif16(-x);
-
-      EXPECT_FP_EQ(pos_result,
-                   static_cast<float16>(LIBC_NAMESPACE::fabs(neg_result)));
-    }
+TEST_F(LlvmLibcAsinpif16Test, PositiveRange) {
+  for (uint16_t v = POS_START; v <= POS_STOP; ++v) {
+    float16 x = FPBits(v).get_val();
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinpi, x,
+                                   LIBC_NAMESPACE::asinpif16(x), 0.5);
+    break;
   }
 }
 
-TEST_F(LlvmLibcAsinpif16Test, RangeValidation) {
-  // Test that output is always in [-0.5, 0.5] for valid inputs
-  constexpr int num_tests = 1000;
-
-  for (int i = 0; i <= num_tests; ++i) {
-    float16 t = -1.0f16 + (2.0f16 * static_cast<float16>(i)) /
-                              static_cast<float16>(num_tests);
-
-    if (LIBC_NAMESPACE::fabs(t) <= 1.0) {
-      float16 result = LIBC_NAMESPACE::asinpif16(t);
-
-      // should be in [-0.5, 0.5]
-      EXPECT_TRUE(result >= -0.5f16);
-      EXPECT_TRUE(result <= 0.5f16);
-    }
+TEST_F(LlvmLibcAsinpif16Test, NegativeRange) {
+  int i = 0;
+  for (uint16_t v = NEG_START; v <= NEG_STOP; ++v) {
+    float16 x = FPBits(v).get_val();
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinpi, -x,
+                                   LIBC_NAMESPACE::asinpif16(-x), 0.5);
+    if (i++ == 10)
+      break;
   }
 }

libc/utils/MPFRWrapper/MPCommon.cpp

@@ -105,6 +105,12 @@ MPFRNumber MPFRNumber::asinh() const {
   return result;
 }
 
+MPFRNumber MPFRNumber::asinpi() const {
+  MPFRNumber result(*this);
+  mpfr_asinpi(result.value, value, mpfr_rounding);
+  return result;
+}
+
 MPFRNumber MPFRNumber::atan() const {
   MPFRNumber result(*this);
   mpfr_atan(result.value, value, mpfr_rounding);

libc/utils/MPFRWrapper/MPCommon.h

@@ -185,6 +185,7 @@ class MPFRNumber {
   MPFRNumber add(const MPFRNumber &b) const;
   MPFRNumber asin() const;
   MPFRNumber asinh() const;
+  MPFRNumber asinpi() const;
   MPFRNumber atan() const;
   MPFRNumber atan2(const MPFRNumber &b);
   MPFRNumber atanh() const;

libc/utils/MPFRWrapper/MPFRUtils.cpp

@@ -38,6 +38,8 @@ unary_operation(Operation op, InputType input, unsigned int precision,
     return mpfrInput.asin();
   case Operation::Asinh:
     return mpfrInput.asinh();
+  case Operation::Asinpi:
+    return mpfrInput.asinpi();
   case Operation::Atan:
     return mpfrInput.atan();
   case Operation::Atanh:

libc/utils/MPFRWrapper/MPFRUtils.h

@@ -31,6 +31,7 @@ enum class Operation : int {
   Acospi,
   Asin,
   Asinh,
+  Asinpi,
   Atan,
   Atanh,
   Cbrt,