[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