horner

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, kumi::non_empty_product_type 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
}

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: non empty tuple of floating values.
• 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 conditionnaly.
4. fma[pedantic] instead of fma is used in internal computations.

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 << "-> 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(x, 1, -2, 3, -4)          = " << eve::horner(xd, 1, -2, 3, -4)  << '\n';
  std::cout << "-> horner(xd, v)                    = " << eve::horner(xd, v)  << '\n';
  std::cout << "-> horner(xd, t)                    = " << eve::horner(xd, t)   << '\n';
  std::cout << "-> horner(x, t)                     = " << eve::horner(x, t)   << '\n';
  std::cout << "-> horner(x, wv)                    = " << eve::horner(x, wv) << '\n';
  std::cout << "-> horner(0.5f, wv)                 = " << eve::horner(0.5, wv) << '\n';
  std::cout << "-> horner(xd, wv)                   = " << eve::horner(xd, wv) << '\n';
  std::cout << "-> horner(1.0, t)                   = " << eve::horner(1.0, t) << '\n';
}

Output:

<- xd = (-0.3, 0.5, 0, 2)
<- x = 0.2
<- v = ( 1 -2 3 -4 )
<- wv = ( (1.5, 1, 2, 3) (4, 5, 6, 7) (8, 9, 10, 11) )
-> horner(xd, 1.0, -2.0, 3.0, -4.0) = (-5.107, -2.875, -4, 2)
-> horner(0.5, 1, b, 3, -4) = (-2.875, 0.25, -3.375, -2.35)
-> horner(x, 1, -2, 3, -4) = (-5.107, -2.875, -4, 2)
-> horner(xd, v) = (-5.107, -2.875, -4, 2)
-> horner(xd, t) = (6.935, 10.375, 8, 22)
-> horner(x, t) = 8.86
-> horner(x, wv) = (8.86, 10.04, 11.28, 12.52)
-> horner(0.5f, wv) = (10.375, 11.75, 13.5, 15.25)
-> horner(xd, wv) = (6.935, 11.75, 10, 37)
-> horner(1.0, t) = 13.5