[libc-commits] [libc] [libc][math][c23] Implement C23 math function atanpif16 (PR #150400)
Mohamed Emad via libc-commits
libc-commits at lists.llvm.org
Fri Jul 25 02:47:15 PDT 2025
https://github.com/hulxv updated https://github.com/llvm/llvm-project/pull/150400
>From 1c1135b3fccf59537243fc365e83a568f77273ae Mon Sep 17 00:00:00 2001
From: hulxv <hulxxv at gmail.com>
Date: Thu, 24 Jul 2025 11:49:03 +0300
Subject: [PATCH 1/5] feat: add the implementatio of `atanpif16`
---
libc/src/math/CMakeLists.txt | 2 +
libc/src/math/atanpif16.h | 22 ++++
libc/src/math/generic/CMakeLists.txt | 17 +++
libc/src/math/generic/atanpif16.cpp | 155 +++++++++++++++++++++++++++
4 files changed, 196 insertions(+)
create mode 100644 libc/src/math/atanpif16.h
create mode 100644 libc/src/math/generic/atanpif16.cpp
diff --git a/libc/src/math/CMakeLists.txt b/libc/src/math/CMakeLists.txt
index d177ff79141c0..033aa2396b86b 100644
--- a/libc/src/math/CMakeLists.txt
+++ b/libc/src/math/CMakeLists.txt
@@ -67,6 +67,8 @@ add_math_entrypoint_object(atan2f128)
add_math_entrypoint_object(atanh)
add_math_entrypoint_object(atanhf)
+add_math_entrypoint_object(atanpif16)
+
add_math_entrypoint_object(canonicalize)
add_math_entrypoint_object(canonicalizef)
add_math_entrypoint_object(canonicalizel)
diff --git a/libc/src/math/atanpif16.h b/libc/src/math/atanpif16.h
new file mode 100644
index 0000000000000..14dc150014578
--- /dev/null
+++ b/libc/src/math/atanpif16.h
@@ -0,0 +1,22 @@
+//===-- Implementation header for atanpif16 ---------------------*- C++ -*-===//
+//
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_MATH_ATANPIF16_H
+#define LLVM_LIBC_SRC_MATH_ATANPIF16_H
+
+#include "src/__support/macros/config.h"
+#include "src/__support/macros/properties/types.h"
+
+namespace LIBC_NAMESPACE_DECL {
+
+float16 atanpif16(float16 x);
+
+} // namespace LIBC_NAMESPACE_DECL
+
+#endif // LLVM_LIBC_SRC_MATH_ASINF16_H
+
diff --git a/libc/src/math/generic/CMakeLists.txt b/libc/src/math/generic/CMakeLists.txt
index adbed5b2de48c..421d8163ea792 100644
--- a/libc/src/math/generic/CMakeLists.txt
+++ b/libc/src/math/generic/CMakeLists.txt
@@ -4029,6 +4029,23 @@ add_entrypoint_object(
libc.src.__support.macros.optimization
)
+add_entrypoint_object(
+ atanpif16
+ SRCS
+ atanpif16.cpp
+ HDRS
+ ../atanpif16.h
+ DEPENDS
+ libc.hdr.errno_macros
+ libc.hdr.fenv_macros
+ libc.src.__support.FPUtil.fenv_impl
+ libc.src.__support.FPUtil.fp_bits
+ libc.src.__support.FPUtil.polyeval
+ libc.src.__support.FPUtil.cast
+ libc.src.__support.FPUtil.multiply_add
+ libc.src.__support.FPUtil.sqrt
+)
+
add_object_library(
inv_trigf_utils
HDRS
diff --git a/libc/src/math/generic/atanpif16.cpp b/libc/src/math/generic/atanpif16.cpp
new file mode 100644
index 0000000000000..e7ab0a48ca2ab
--- /dev/null
+++ b/libc/src/math/generic/atanpif16.cpp
@@ -0,0 +1,155 @@
+//===-- Half-precision atanpi 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/atanpif16.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/multiply_add.h"
+#include "src/__support/FPUtil/sqrt.h"
+
+namespace LIBC_NAMESPACE_DECL {
+
+// Using Python's SymPy library, we can obtain the polynomial approximation of
+// arctan(x)/pi. The steps are as follows:
+// >>> from sympy import *
+// >>> import math
+// >>> x = symbols('x')
+// >>> print(series(atan(x)/math.pi, x, 0, 21))
+//
+// Output:
+// 0.318309886183791*x - 0.106103295394597*x**3 + 0.0636619772367581*x**5 -
+// 0.0454728408833987*x**7 + 0.0353677651315323*x**9 - 0.0289372623803446*x**11
+// + 0.0244853758602916*x**13 - 0.0212206590789194*x**15 +
+// 0.0187241109519877*x**17 - 0.01675315190441*x**19 + O(x**21)
+//
+// We will assign this 19-degree Taylor polynomial as g(x). This polynomial
+// approximation is accurate for arctan(x)/pi when |x| is in the range [0, 0.5].
+//
+//
+// To compute arctan(x) for all real x, we divide the domain into the following
+// cases:
+//
+// * Case 1: |x| <= 0.5
+// In this range, the direct polynomial approximation is used:
+// arctan(x)/pi = sign(x) * g(|x|)
+// or equivalently, arctan(x) = sign(x) * pi * g(|x|).
+//
+// * Case 2: 0.5 < |x| <= 1
+// We use the double-angle identity for the tangent function, specifically:
+// arctan(x) = 2 * arctan(x / (1 + sqrt(1 + x^2))).
+// Applying this, we have:
+// arctan(x)/pi = sign(x) * 2 * arctan(x')/pi,
+// where x' = |x| / (1 + sqrt(1 + x^2)).
+// Thus, arctan(x)/pi = sign(x) * 2 * g(x')
+//
+// When |x| is in (0.5, 1], the value of x' will always fall within the
+// interval [0.207, 0.414], which is within the accurate range of g(x).
+//
+// * Case 3: |x| > 1
+// For values of |x| greater than 1, we use the reciprocal transformation
+// identity:
+// arctan(x) = pi/2 - arctan(1/x) for x > 0.
+// For any x (real number), this generalizes to:
+// arctan(x)/pi = sign(x) * (1/2 - arctan(1/|x|)/pi).
+// Then, using g(x) for arctan(1/|x|)/pi:
+// arctan(x)/pi = sign(x) * (1/2 - g(1/|x|)).
+//
+// Note that if 1/|x| still falls outside the
+// g(x)'s primary range of accuracy (i.e., if 0.5 < 1/|x| <= 1), the rule
+// from Case 2 must be applied recursively to 1/|x|.
+
+LLVM_LIBC_FUNCTION(float16, atanpif16, (float16 x)) {
+ using FPBits = fputil::FPBits<float16>;
+
+ FPBits xbits(x);
+ bool is_neg = xbits.is_neg();
+
+ auto signed_result = [is_neg](double r) -> float16 {
+ return fputil::cast<float16>(is_neg ? -r : r);
+ };
+
+ if (LIBC_UNLIKELY(xbits.is_inf_or_nan())) {
+ if (xbits.is_nan()) {
+ return x;
+ }
+ // atanpi(±∞) = ±0.5
+ return signed_result(0.5);
+ }
+
+ if (LIBC_UNLIKELY(xbits.is_zero())) {
+ return 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)
+ constexpr double POLY_COEFFS[] = {
+ 0x1.45f306dc9c889p-2, // x^1: 1/pi
+ -0x1.b2995e7b7b60bp-4, // x^3: -1/(3*pi)
+ 0x1.04c26be3b06ccp-4, // x^5: 1/(5*pi)
+ -0x1.7483758e69c08p-5, // x^7: -1/(7*pi)
+ 0x1.21bb945252403p-5, // x^9: 1/(9*pi)
+ -0x1.da1bace3cc68ep-6, // x^11: -1/(11*pi)
+ 0x1.912b1c2336cf2p-6, // x^13: 1/(13*pi)
+ -0x1.5bade52f95e7p-6, // x^15: -1/(15*pi)
+ 0x1.32c69d0bde9e8p-6, // x^17: 1/(17*pi)
+ -0x1.127bcfe232f8cp-6, // x^19: -1/(19*pi)
+ };
+
+ // evaluate atan(x)/pi using polynomial approximation, valid for |x| <= 0.5
+ constexpr auto atanpi_eval = [](double x) -> double {
+ double xx = x * x;
+ return x * fputil::polyeval(xx, POLY_COEFFS[0], POLY_COEFFS[1],
+ POLY_COEFFS[2], POLY_COEFFS[3], POLY_COEFFS[4],
+ POLY_COEFFS[5], POLY_COEFFS[6], POLY_COEFFS[7],
+ POLY_COEFFS[8], POLY_COEFFS[9]);
+ };
+
+ // Case 1: |x| <= 0.5 - Direct polynomial evaluation
+ if (LIBC_LIKELY(x_abs <= 0.5)) {
+ double result = atanpi_eval(x_abs);
+ return signed_result(result);
+ }
+
+ // 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))
+ if (x_abs <= 1.0) {
+ double x2 = x_abs * x_abs;
+ double sqrt_term = fputil::sqrt<double>(1.0 + x2);
+ double x_prime = x_abs / (1.0 + sqrt_term);
+ double result = 2.0 * atanpi_eval(x_prime);
+ return signed_result(result);
+ }
+
+ // 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)
+ 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 x_prime = x_recip / (1.0 + sqrt_term);
+ result = fputil::multiply_add(-2.0, atanpi_eval(x_prime), 0.5);
+ } else {
+ // direct evaluation since 1/|x| <= 0.5
+ result = 0.5 - atanpi_eval(x_recip);
+ }
+
+ return signed_result(result);
+}
+
+} // namespace LIBC_NAMESPACE_DECL
>From 1a5d472cde4fb58887ddcf3d1e9bd73fc0b763b0 Mon Sep 17 00:00:00 2001
From: hulxv <hulxxv at gmail.com>
Date: Thu, 24 Jul 2025 11:49:16 +0300
Subject: [PATCH 2/5] add entries
---
libc/config/linux/x86_64/entrypoints.txt | 1 +
libc/include/math.yaml | 6 ++++++
2 files changed, 7 insertions(+)
diff --git a/libc/config/linux/x86_64/entrypoints.txt b/libc/config/linux/x86_64/entrypoints.txt
index 73dfeae1a2c94..1585f803229b6 100644
--- a/libc/config/linux/x86_64/entrypoints.txt
+++ b/libc/config/linux/x86_64/entrypoints.txt
@@ -664,6 +664,7 @@ if(LIBC_TYPES_HAS_FLOAT16)
libc.src.math.acoshf16
libc.src.math.asinf16
libc.src.math.asinhf16
+ libc.src.math.atanpif16
libc.src.math.canonicalizef16
libc.src.math.ceilf16
libc.src.math.copysignf16
diff --git a/libc/include/math.yaml b/libc/include/math.yaml
index fef829422244d..06a67fdb44a9c 100644
--- a/libc/include/math.yaml
+++ b/libc/include/math.yaml
@@ -113,6 +113,12 @@ functions:
return_type: float
arguments:
- type: float
+ - name: atanpif16
+ standards:
+ - stdc
+ return_type: _Float16
+ arguments:
+ - type: _Float16
- name: canonicalize
standards:
- stdc
>From 926937077156306fe3ddbb3137e8416ab01160e8 Mon Sep 17 00:00:00 2001
From: hulxv <hulxxv at gmail.com>
Date: Thu, 24 Jul 2025 12:45:34 +0300
Subject: [PATCH 3/5] add unit tests for `atanpif16`
---
libc/src/math/generic/atanpif16.cpp | 16 ++---
libc/test/src/math/smoke/CMakeLists.txt | 12 ++++
libc/test/src/math/smoke/atanpif16_test.cpp | 66 +++++++++++++++++++++
3 files changed, 86 insertions(+), 8 deletions(-)
create mode 100644 libc/test/src/math/smoke/atanpif16_test.cpp
diff --git a/libc/src/math/generic/atanpif16.cpp b/libc/src/math/generic/atanpif16.cpp
index e7ab0a48ca2ab..0ca0c534d1658 100644
--- a/libc/src/math/generic/atanpif16.cpp
+++ b/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 {
diff --git a/libc/test/src/math/smoke/CMakeLists.txt b/libc/test/src/math/smoke/CMakeLists.txt
index 223d1933bca38..2461478e2ffb5 100644
--- a/libc/test/src/math/smoke/CMakeLists.txt
+++ b/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
diff --git a/libc/test/src/math/smoke/atanpif16_test.cpp b/libc/test/src/math/smoke/atanpif16_test.cpp
new file mode 100644
index 0000000000000..e0f3ce5f52392
--- /dev/null
+++ b/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);
+ }
+}
>From bdae5140992b134249ef8331ab91c4f0dda6f2ca Mon Sep 17 00:00:00 2001
From: hulxv <hulxxv at gmail.com>
Date: Thu, 24 Jul 2025 12:53:13 +0300
Subject: [PATCH 4/5] add exhaustive test for `atanpif16`
---
libc/test/src/math/CMakeLists.txt | 11 ++++++++
libc/test/src/math/atanpif16_test.cpp | 40 +++++++++++++++++++++++++++
libc/utils/MPFRWrapper/MPCommon.cpp | 6 ++++
libc/utils/MPFRWrapper/MPCommon.h | 1 +
libc/utils/MPFRWrapper/MPFRUtils.cpp | 2 ++
libc/utils/MPFRWrapper/MPFRUtils.h | 1 +
6 files changed, 61 insertions(+)
create mode 100644 libc/test/src/math/atanpif16_test.cpp
diff --git a/libc/test/src/math/CMakeLists.txt b/libc/test/src/math/CMakeLists.txt
index 7ee8b86135557..b17c7bc50fa42 100644
--- a/libc/test/src/math/CMakeLists.txt
+++ b/libc/test/src/math/CMakeLists.txt
@@ -2143,6 +2143,17 @@ 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
+)
+
add_fp_unittest(
fmul_test
NEED_MPFR
diff --git a/libc/test/src/math/atanpif16_test.cpp b/libc/test/src/math/atanpif16_test.cpp
new file mode 100644
index 0000000000000..2c24b5048a2fb
--- /dev/null
+++ b/libc/test/src/math/atanpif16_test.cpp
@@ -0,0 +1,40 @@
+//===-- Exhaustive test 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/math/atanpif16.h"
+#include "test/UnitTest/FPMatcher.h"
+#include "test/UnitTest/Test.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+
+using LlvmLibcAtanpif16Test = LIBC_NAMESPACE::testing::FPTest<float16>;
+
+namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
+
+// Range: [0, Inf]
+static constexpr uint16_t POS_START = 0x0000U;
+static constexpr uint16_t POS_STOP = 0x7c00U;
+
+// Range: [-Inf, 0]
+static constexpr uint16_t NEG_START = 0x8000U;
+static constexpr uint16_t NEG_STOP = 0xfc00U;
+
+TEST_F(LlvmLibcAtanpif16Test, PositiveRange) {
+ for (uint16_t v = POS_START; v <= POS_STOP; ++v) {
+ float16 x = FPBits(v).get_val();
+ EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atanpi, x,
+ LIBC_NAMESPACE::atanpif16(x), 0.5);
+ }
+}
+
+TEST_F(LlvmLibcAtanpif16Test, NegativeRange) {
+ for (uint16_t v = NEG_START; v <= NEG_STOP; ++v) {
+ float16 x = FPBits(v).get_val();
+ EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atanpi, x,
+ LIBC_NAMESPACE::atanpif16(x), 0.5);
+ }
+}
\ No newline at end of file
diff --git a/libc/utils/MPFRWrapper/MPCommon.cpp b/libc/utils/MPFRWrapper/MPCommon.cpp
index ac8cde2f97221..5bb95df02fcf0 100644
--- a/libc/utils/MPFRWrapper/MPCommon.cpp
+++ b/libc/utils/MPFRWrapper/MPCommon.cpp
@@ -106,6 +106,12 @@ MPFRNumber MPFRNumber::atanh() const {
return result;
}
+MPFRNumber MPFRNumber::atanpi() const {
+ MPFRNumber result(*this);
+ mpfr_atanpi(result.value, value, mpfr_rounding);
+ return result;
+}
+
MPFRNumber MPFRNumber::cbrt() const {
MPFRNumber result(*this);
mpfr_cbrt(result.value, value, mpfr_rounding);
diff --git a/libc/utils/MPFRWrapper/MPCommon.h b/libc/utils/MPFRWrapper/MPCommon.h
index eaa512e30bc86..6888fcfad1329 100644
--- a/libc/utils/MPFRWrapper/MPCommon.h
+++ b/libc/utils/MPFRWrapper/MPCommon.h
@@ -187,6 +187,7 @@ class MPFRNumber {
MPFRNumber atan() const;
MPFRNumber atan2(const MPFRNumber &b);
MPFRNumber atanh() const;
+ MPFRNumber atanpi() const;
MPFRNumber cbrt() const;
MPFRNumber ceil() const;
MPFRNumber cos() const;
diff --git a/libc/utils/MPFRWrapper/MPFRUtils.cpp b/libc/utils/MPFRWrapper/MPFRUtils.cpp
index 4a033dbc2049b..cb65f080192b8 100644
--- a/libc/utils/MPFRWrapper/MPFRUtils.cpp
+++ b/libc/utils/MPFRWrapper/MPFRUtils.cpp
@@ -40,6 +40,8 @@ unary_operation(Operation op, InputType input, unsigned int precision,
return mpfrInput.atan();
case Operation::Atanh:
return mpfrInput.atanh();
+ case Operation::Atanpi:
+ return mpfrInput.atanpi();
case Operation::Cbrt:
return mpfrInput.cbrt();
case Operation::Ceil:
diff --git a/libc/utils/MPFRWrapper/MPFRUtils.h b/libc/utils/MPFRWrapper/MPFRUtils.h
index bc65f87c6b5ab..a650a09428f18 100644
--- a/libc/utils/MPFRWrapper/MPFRUtils.h
+++ b/libc/utils/MPFRWrapper/MPFRUtils.h
@@ -32,6 +32,7 @@ enum class Operation : int {
Asinh,
Atan,
Atanh,
+ Atanpi,
Cbrt,
Ceil,
Cos,
>From 3d0becae259c11c1f6b9f5b1eb82cfa96c09bc7d Mon Sep 17 00:00:00 2001
From: hulxv <hulxxv at gmail.com>
Date: Thu, 24 Jul 2025 12:55:58 +0300
Subject: [PATCH 5/5] improve `atanpif16` implementation
---
libc/src/math/generic/atanpif16.cpp | 18 +++++++++---------
1 file changed, 9 insertions(+), 9 deletions(-)
diff --git a/libc/src/math/generic/atanpif16.cpp b/libc/src/math/generic/atanpif16.cpp
index 0ca0c534d1658..985cf3738614e 100644
--- a/libc/src/math/generic/atanpif16.cpp
+++ b/libc/src/math/generic/atanpif16.cpp
@@ -23,13 +23,12 @@ namespace LIBC_NAMESPACE_DECL {
// >>> from sympy import *
// >>> import math
// >>> x = symbols('x')
-// >>> print(series(atan(x)/math.pi, x, 0, 21))
+// >>> print(series(atan(x)/math.pi, x, 0, 17))
//
// Output:
// 0.318309886183791*x - 0.106103295394597*x**3 + 0.0636619772367581*x**5 -
// 0.0454728408833987*x**7 + 0.0353677651315323*x**9 - 0.0289372623803446*x**11
-// + 0.0244853758602916*x**13 - 0.0212206590789194*x**15 +
-// 0.0187241109519877*x**17 - 0.01675315190441*x**19 + O(x**21)
+// + 0.0244853758602916*x**13 - 0.0212206590789194*x**15 + O(x**17)
//
// We will assign this 19-degree Taylor polynomial as g(x). This polynomial
// approximation is accurate for arctan(x)/pi when |x| is in the range [0, 0.5].
@@ -86,13 +85,17 @@ LLVM_LIBC_FUNCTION(float16, atanpif16, (float16 x)) {
}
if (LIBC_UNLIKELY(xbits.is_zero())) {
- return x; //
+ return x;
}
double x_abs = fputil::cast<double>(xbits.abs().get_val());
+ if (LIBC_UNLIKELY(x_abs == 1.0)) {
+ return signed_result(0.25);
+ }
+
// polynomial coefficients for atan(x)/pi taylor series
- // generated using sympy: series(atan(x)/pi, x, 0, 21)
+ // generated using sympy: series(atan(x)/pi, x, 0, 17)
constexpr double POLY_COEFFS[] = {
0x1.45f306dc9c889p-2, // x^1: 1/pi
-0x1.b2995e7b7b60bp-4, // x^3: -1/(3*pi)
@@ -102,8 +105,6 @@ LLVM_LIBC_FUNCTION(float16, atanpif16, (float16 x)) {
-0x1.da1bace3cc68ep-6, // x^11: -1/(11*pi)
0x1.912b1c2336cf2p-6, // x^13: 1/(13*pi)
-0x1.5bade52f95e7p-6, // x^15: -1/(15*pi)
- 0x1.32c69d0bde9e8p-6, // x^17: 1/(17*pi)
- -0x1.127bcfe232f8cp-6, // x^19: -1/(19*pi)
};
// evaluate atan(x)/pi using polynomial approximation, valid for |x| <= 0.5
@@ -111,8 +112,7 @@ LLVM_LIBC_FUNCTION(float16, atanpif16, (float16 x)) {
double xx = x * x;
return x * fputil::polyeval(xx, POLY_COEFFS[0], POLY_COEFFS[1],
POLY_COEFFS[2], POLY_COEFFS[3], POLY_COEFFS[4],
- POLY_COEFFS[5], POLY_COEFFS[6], POLY_COEFFS[7],
- POLY_COEFFS[8], POLY_COEFFS[9]);
+ POLY_COEFFS[5], POLY_COEFFS[6], POLY_COEFFS[7]);
};
// Case 1: |x| <= 0.5 - Direct polynomial evaluation
More information about the libc-commits
mailing list