[llvm-branch-commits] [libc] [llvm] [libc][math] Expand polyeval.h with array, loop, and Estrin evaluation. (PR #243523)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Nov 17 16:07:29 PST 2026
================
@@ -18,69 +18,399 @@
#include "src/__support/CPP/type_traits.h"
#include "src/__support/common.h"
#include "src/__support/macros/config.h"
+#include "src/__support/macros/optimization.h"
-// Evaluate polynomial using Horner's Scheme:
-// With polyeval(x, a_0, a_1, ..., a_n) = a_n * x^n + ... + a_1 * x + a_0, we
-// evaluated it as: a_0 + x * (a_1 + x * ( ... (a_(n-1) + x * a_n) ... ) ) ).
-// We will use FMA instructions if available.
-// Example: to evaluate x^3 + 2*x^2 + 3*x + 4, call
-// polyeval( x, 4.0, 3.0, 2.0, 1.0 )
+#include <stddef.h>
namespace LIBC_NAMESPACE_DECL {
namespace fputil {
-template <typename T>
-LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(void *)), T>
-polyeval(const T &, const T &a0) {
- return a0;
+// Evaluate polynomial using Horner's scheme:
+// polyeval(x, a_0, a_1, ..., a_n) = a_0 + x * (a_1 + ... + x * a_n).
+template <typename T, typename... Ts>
+LIBC_ALWAYS_INLINE constexpr cpp::enable_if_t<(sizeof(T) <= sizeof(double)), T>
+polyeval(T x, T a0, Ts... a) {
+ static_assert((cpp::is_same_v<T, Ts> && ...),
+ "All coefficients must have the same type T.");
+ if constexpr (sizeof...(Ts) == 0) {
+ (void)x;
+ return a0;
+ } else {
+ T r = polyeval(x, a...);
+ return multiply_add(x, r, a0);
+ }
}
-template <typename T>
-LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) <= sizeof(void *)), T>
-polyeval(T, T a0) {
- return a0;
+template <typename T, typename... Ts>
+LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(double)), T>
+polyeval(const T &x, const T &a0, const Ts &...a) {
+ static_assert((cpp::is_same_v<T, Ts> && ...),
+ "All coefficients must have the same type T.");
+ if constexpr (sizeof...(Ts) == 0) {
+ (void)x;
+ return a0;
+ } else {
+ T r = polyeval(x, a...);
+ return multiply_add(x, r, a0);
+ }
}
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_ALWAYS_INLINE constexpr cpp::enable_if_t<(sizeof(T) <= sizeof(double)), T>
+polyeval(T x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ if constexpr (OFFSET + 1 == N) {
+ (void)x;
+ return a[OFFSET];
+ } else {
+ T r = polyeval<OFFSET + 1>(x, a);
+ return multiply_add(x, r, a[OFFSET]);
+ }
+}
+
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(double)), T>
+polyeval(const T &x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ if constexpr (OFFSET + 1 == N) {
+ (void)x;
+ return a[OFFSET];
+ } else {
+ T r = polyeval<OFFSET + 1>(x, a);
+ return multiply_add(x, r, a[OFFSET]);
+ }
+}
+
+// Evaluate alternating polynomial:
+// altpolyeval(x, a_0, a_1, ..., a_n) = a_0 - x * a_1 + x^2 * a_2 - ...
+// + (-1)^n * x^n * a_n.
template <typename T, typename... Ts>
-LIBC_INLINE static constexpr cpp::enable_if_t<(sizeof(T) > sizeof(void *)), T>
-polyeval(const T &x, const T &a0, const Ts &...a) {
- return multiply_add(x, polyeval(x, a...), a0);
+LIBC_ALWAYS_INLINE constexpr cpp::enable_if_t<(sizeof(T) <= sizeof(double)), T>
+altpolyeval(T x, T a0, Ts... a) {
+ static_assert((cpp::is_same_v<T, Ts> && ...),
+ "All coefficients must have the same type T.");
+ if constexpr (sizeof...(Ts) == 0) {
+ (void)x;
+ return a0;
+ } else {
+ T r = altpolyeval(x, a...);
+ return sub_multiply(a0, x, r);
+ }
}
template <typename T, typename... Ts>
-LIBC_INLINE LIBC_CONSTEXPR cpp::enable_if_t<(sizeof(T) <= sizeof(void *)), T>
-polyeval(T x, T a0, Ts... a) {
- return multiply_add(x, polyeval(x, a...), a0);
+LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(double)), T>
+altpolyeval(const T &x, const T &a0, const Ts &...a) {
+ static_assert((cpp::is_same_v<T, Ts> && ...),
+ "All coefficients must have the same type T.");
+ if constexpr (sizeof...(Ts) == 0) {
+ (void)x;
+ return a0;
+ } else {
+ T r = altpolyeval(x, a...);
+ return sub_multiply(a0, x, r);
+ }
}
-// Evaluating alternating polynomials using subtraction directly.
-// altpolyeval(x, a_0, a_1, ..., a_n) = a_0 - x * a_1 + x^2 * a_2 - ... +
-// + (-1)^n x_n * a_n.
-template <typename T>
-LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(void *)), T>
-altpolyeval(const T &, const T &a0) {
- return a0;
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_ALWAYS_INLINE constexpr cpp::enable_if_t<(sizeof(T) <= sizeof(double)), T>
+altpolyeval(T x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ if constexpr (OFFSET + 1 == N) {
+ (void)x;
+ return a[OFFSET];
+ } else {
+ T r = altpolyeval<OFFSET + 1>(x, a);
+ return sub_multiply(a[OFFSET], x, r);
+ }
+}
+
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(double)), T>
+altpolyeval(const T &x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ if constexpr (OFFSET + 1 == N) {
+ (void)x;
+ return a[OFFSET];
+ } else {
+ T r = altpolyeval<OFFSET + 1>(x, a);
+ return sub_multiply(a[OFFSET], x, r);
+ }
+}
+
+// Evaluate polynomial using a non-unrolled Horner loop:
+// loop_polyeval<OFFSET>(x, a) = a[OFFSET] + x * (a[OFFSET + 1] + ...
+// + x * a[N - 1]).
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_ALWAYS_INLINE constexpr cpp::enable_if_t<(sizeof(T) <= sizeof(double)), T>
+loop_polyeval(T x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ T r = a[N - 1];
+ if constexpr (OFFSET + 1 < N) {
+ LIBC_LOOP_NOUNROLL
+ for (size_t i = N - 1; i > OFFSET; --i)
+ r = multiply_add(x, r, a[i - 1]);
+ } else {
+ (void)x;
+ }
+ return r;
+}
+
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(double)), T>
+loop_polyeval(const T &x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ T r = a[N - 1];
+ if constexpr (OFFSET + 1 < N) {
+ LIBC_LOOP_NOUNROLL
+ for (size_t i = N - 1; i > OFFSET; --i)
+ r = multiply_add(x, r, a[i - 1]);
+ } else {
+ (void)x;
+ }
+ return r;
}
+// Evaluate alternating polynomial using a non-unrolled Horner loop:
+// loop_altpolyeval<OFFSET>(x, a) = a[OFFSET] - x * a[OFFSET + 1] + ...
+// + (-1)^(N - 1 - OFFSET) * x^(N - 1 - OFFSET) * a[N - 1].
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_ALWAYS_INLINE constexpr cpp::enable_if_t<(sizeof(T) <= sizeof(double)), T>
+loop_altpolyeval(T x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ T r = a[N - 1];
+ if constexpr (OFFSET + 1 < N) {
+ LIBC_LOOP_NOUNROLL
+ for (size_t i = N - 1; i > OFFSET; --i)
+ r = sub_multiply(a[i - 1], x, r);
+ } else {
+ (void)x;
+ }
+ return r;
+}
+
+template <size_t OFFSET = 0, typename T, size_t N>
+LIBC_INLINE constexpr cpp::enable_if_t<(sizeof(T) > sizeof(double)), T>
+loop_altpolyeval(const T &x, const T (&a)[N]) {
+ static_assert(OFFSET < N, "OFFSET must be less than array size N.");
+ T r = a[N - 1];
+ if constexpr (OFFSET + 1 < N) {
+ LIBC_LOOP_NOUNROLL
+ for (size_t i = N - 1; i > OFFSET; --i)
+ r = sub_multiply(a[i - 1], x, r);
+ } else {
+ (void)x;
----------------
lntue wrote:
Done.
https://github.com/llvm/llvm-project/pull/243523
More information about the llvm-branch-commits
mailing list