add unit tests for atanpif16

Author: hulxv

libc/src/math/generic/atanpif16.cpp

@@ -91,8 +91,8 @@ LLVM_LIBC_FUNCTION(float16, atanpif16, (float16 x)) {
 
   double x_abs = fputil::cast<double>(xbits.abs().get_val());
 
-  // Polynomial coefficients for atan(x)/pi Taylor series
-  // Generated using SymPy: series(atan(x)/pi, x, 0, 21)
+  // polynomial coefficients for atan(x)/pi taylor series
+  // generated using sympy: series(atan(x)/pi, x, 0, 21)
   constexpr double POLY_COEFFS[] = {
       0x1.45f306dc9c889p-2,  // x^1:   1/pi
       -0x1.b2995e7b7b60bp-4, // x^3:  -1/(3*pi)
@@ -121,9 +121,9 @@ LLVM_LIBC_FUNCTION(float16, atanpif16, (float16 x)) {
     return signed_result(result);
   }
 
-  // Case 2: 0.5 < |x| <= 1 - Use double-angle reduction
+  // case 2: 0.5 < |x| <= 1 - use double-angle reduction
   // atan(x) = 2 * atan(x / (1 + sqrt(1 + x^2)))
-  // So atanpi(x) = 2 * atanpi(x') where x' = x / (1 + sqrt(1 + x^2))
+  // so atanpi(x) = 2 * atanpi(x') where x' = x / (1 + sqrt(1 + x^2))
   if (x_abs <= 1.0) {
     double x2 = x_abs * x_abs;
     double sqrt_term = fputil::sqrt<double>(1.0 + x2);
@@ -132,16 +132,16 @@ LLVM_LIBC_FUNCTION(float16, atanpif16, (float16 x)) {
     return signed_result(result);
   }
 
-  // Case 3: |x| > 1 - Use reciprocal transformation
+  // case 3: |x| > 1 - use reciprocal transformation
   // atan(x) = pi/2 - atan(1/x) for x > 0
-  // So atanpi(x) = 1/2 - atanpi(1/x)
+  // so atanpi(x) = 1/2 - atanpi(1/x)
   double x_recip = 1.0 / x_abs;
   double result;
 
   // if 1/|x| > 0.5, we need to apply Case 2 transformation to 1/|x|
   if (x_recip > 0.5) {
-    double x_recip2 = x_recip * x_recip;
-    double sqrt_term = fputil::sqrt<double>(1.0 + x_recip2);
+    double xx_recip = x_recip * x_recip;
+    double sqrt_term = fputil::sqrt<double>(1.0 + xx_recip);
     double x_prime = x_recip / (1.0 + sqrt_term);
     result = fputil::multiply_add(-2.0, atanpi_eval(x_prime), 0.5);
   } else {

libc/test/src/math/smoke/CMakeLists.txt

@@ -3947,6 +3947,18 @@ add_fp_unittest(
     libc.src.__support.FPUtil.fp_bits
 )
 
+add_fp_unittest(
+  atanpif16_test
+  NEED_MPFR
+  SUITE
+    libc-math-unittests
+  SRCS
+    atanpif16_test.cpp
+  DEPENDS
+    libc.src.math.atanpif16
+    libc.src.errno.errno
+)
+
 add_fp_unittest(
   asinhf_test
   SUITE

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

@@ -0,0 +1,66 @@
+//===-- Unittests for atanpif16 -------------------------------------------===//
+//
+// 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/errno/libc_errno.h"
+#include "src/math/atanpif16.h"
+#include "test/UnitTest/FPMatcher.h"
+
+using LlvmLibcAtanpif16Test = LIBC_NAMESPACE::testing::FPTest<float16>;
+
+TEST_F(LlvmLibcAtanpif16Test, SpecialNumbers) {
+  // zero
+  EXPECT_FP_EQ(zero, LIBC_NAMESPACE::atanpif16(zero));
+  EXPECT_FP_EQ(neg_zero, LIBC_NAMESPACE::atanpif16(neg_zero));
+
+  // NaN inputs
+  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
+               LIBC_NAMESPACE::atanpif16(FPBits::quiet_nan().get_val()));
+
+  EXPECT_FP_EQ(FPBits::quiet_nan().get_val(),
+               LIBC_NAMESPACE::atanpif16(FPBits::signaling_nan().get_val()));
+
+  // infinity inputs -> should return +/-0.5
+  EXPECT_FP_EQ(0.5f16, LIBC_NAMESPACE::atanpif16(inf));
+  EXPECT_FP_EQ(-0.5f16, LIBC_NAMESPACE::atanpif16(neg_inf));
+}
+
+
+TEST_F(LlvmLibcAtanpif16Test, SymmetryProperty) {
+  // Test that atanpi(-x) = -atanpi(x)
+  constexpr float16 TEST_VALS[] = {0.1f16,  0.25f16, 0.5f16,   0.75f16,
+                                   1.0f16,  1.5f16,  2.0f16,   5.0f16,
+                                   10.0f16, 50.0f16, 100.0f16, 1000.0f16};
+
+  for (float16 x : TEST_VALS) {
+    FPBits neg_x_bits(x);
+    neg_x_bits.set_sign(Sign::NEG);
+    float16 neg_x = neg_x_bits.get_val();
+
+    float16 pos_result = LIBC_NAMESPACE::atanpif16(x);
+    float16 neg_result = LIBC_NAMESPACE::atanpif16(neg_x);
+
+    EXPECT_FP_EQ(pos_result, FPBits(neg_result).abs().get_val());
+  }
+}
+
+TEST_F(LlvmLibcAtanpif16Test, MonotonicityProperty) {
+  // Test that atanpi is monotonically increasing
+  constexpr float16 TEST_VALS[] = {-1000.0f16, -100.0f16, -10.0f16, -2.0f16,
+                                   -1.0f16,    -0.5f16,   -0.1f16,  0.0f16,
+                                   0.1f16,     0.5f16,    1.0f16,   2.0f16,
+                                   10.0f16,    100.0f16,  1000.0f16};
+
+  for (size_t i = 0; i < sizeof(TEST_VALS) / sizeof(TEST_VALS[0]) - 1; ++i) {
+    float16 x1 = TEST_VALS[i];
+    float16 x2 = TEST_VALS[i + 1];
+    float16 result1 = LIBC_NAMESPACE::atanpif16(x1);
+    float16 result2 = LIBC_NAMESPACE::atanpif16(x2);
+
+    EXPECT_TRUE(result1 < result2);
+  }
+}