horner

auto eve::horner = functor<horner_t>

inlineconstexpr

If \((c_i)_{0\le i\le n-1}\) denotes the coefficients of the polynomial by decreasing power order, the Horner scheme evaluates the polynom \(p\) at \(x\) by :

\(\qquad\displaystyle p(x) = (((c_0x+c_1)x+ ... )x + c_{n-1})\)

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overloads
   constexpr auto horner(floating_value auto x, value auto ...ci)                      noexcept; // 1
   constexpr auto horner(floating_value auto x, eve::coefficients auto tci)            noexcept; // 2
 
   // Lanes masking
   constexpr auto horner[conditional_expr auto c](/*any of the above overloads*/)       noexcept; // 3
   constexpr auto horner[logical_value auto m](/*any of the above overloads*/)          noexcept; // 3
 
   // Semantic options
   constexpr auto horner[pedantic](/*any of the above overloads*/)                     noexcept; // 4
   constexpr auto horner[kahan](/*any of the above overloads*/)                        noexcept; // 5
   constexpr auto horner[widen](/*any of the above overloads*/)                        noexcept; // 6
}

Parameters

• x: evaluation point floating value arguments.
• ci...: floating values polynom coefficients in decreasing power order, Note that the values of the ci are not necessarily floating but the non floating ones are to be scalar
• tci: eve::coefficients is a specialization of tuple of floating values, used to avoid possible ambiguities
• c: Conditional expression masking the operation.
• m: Logical value masking the operation.

Return value

If \((c_i)_{0\le i\le n-1}\) denotes the coefficients of the polynomial by decreasing power order, the Horner scheme evaluates the polynom \(p\) at \(x\) by : \(\qquad\qquad\displaystyle p(x) = (((c_0x+c_1)x+ ... )x + c_{n-1})\)

1. The value of the polynom at x is returned.
2. Same as the call with the elements of the tuple.
3. The operation is performed conditionally.
4. fma[pedantic] instead of fma is used in internal computations.
5. a Kahan like compensated algorithm is used to enhance accuracy.
6. the computation is applied to upgraded types values when available.

Note

If the coefficients are simd values of cardinal N, this means you simultaneously compute the values of N polynomials.

• If x is scalar, the polynomials are all computed at the same point
• If x is simd, the nth polynomial is computed on the nth value of x

External references

• [Wikipedia](https://en.wikipedia.org/wiki/Horner's_method)

Example

// revision 1 TODO
#include <eve/module/math.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  eve::wide xd = {-0.3, 0.5, 0.0, 2.0};
  eve::wide b  = {-2.0, 10.5, -4.0, 0.1};
  double x(0.2);
  kumi::tuple v {1.0, -2.0, 3.0, -4.0};
  using w_t = decltype(xd);
  kumi::tuple wv{ w_t{1.5, 1, 2, 3}, w_t{4, 5, 6, 7}, w_t{8, 9, 10, 11} };
  auto t =kumi::tuple{1.5,4.0,8.0};
 
  std::cout << "<- xd                                   = " << xd << '\n';
  std::cout << "<- x                                    = " << x  << '\n';
  std::cout << "<- v                                    = " << v  << '\n';
  std::cout << "<- wv                                   = " << wv << '\n';
  std::cout << "<- b                                    = " << b  << '\n';
  std::cout << "-> horner(xd, 1.0, -2.0, 3.0, -4.0)     = " << eve::horner(xd, 1.0, -2.0, 3.0, -4.0) << '\n';
  std::cout << "-> horner(0.5, 1, b, 3, -4)             = " << eve::horner(0.5, 1, b, 3, -4) << '\n';
  std::cout << "-> horner(xd, 1, -2, 3, -4)             = " << eve::horner(xd, 1, -2, 3, -4)  << '\n';
  std::cout << "-> horner(xd, eve::coefficients(v))     = " << eve::horner(xd, eve::coefficients(v))  << '\n';
  std::cout << "-> horner(xd, eve::coefficients(t))     = " << eve::horner(xd, eve::coefficients(t))   << '\n';
  std::cout << "-> horner(x, eve::coefficients(t))      = " << eve::horner(x, eve::coefficients(t))   << '\n';
  std::cout << "-> horner(w_t(x), eve::coefficients(t)) = " << eve::horner(w_t(x), eve::coefficients(t))   << '\n';
  std::cout << "-> horner(x, eve::coefficients(wv))     = " << eve::horner(x, eve::coefficients(wv)) << '\n';
  std::cout << "-> horner(0.5f, eve::coefficients(wv))  = " << eve::horner(0.5, eve::coefficients(wv)) << '\n';
  std::cout << "-> horner(xd, eve::coefficients(wv))    = " << eve::horner(xd, eve::coefficients(wv)) << '\n';
  std::cout << "-> horner(2.0, eve::coefficients(t))    = " << eve::horner(2.0, eve::coefficients(t)) << '\n';
  std::cout << "-> horner(2.0,1.5,4.0,8.0)              = " << eve::horner(2.0, 1.5,4.0,8.0) << '\n';
  std::cout << "-> horner(w_t(2.0),1.5,4.0,8.0)         = " << eve::horner(w_t(2.0), 1.5,4.0,8.0) << '\n';
}