newton

auto eve::newton = functor<newton_t>

inlineconstexpr

If \((c_i)_{0\le i\le n-1}\) denotes the coefficients of the polynomial by decreasing power order, and \((m_i)_{0\le i\le n-2}\) the nodes, the Newton scheme evaluates the polynom \(p\) at \(x\) using the following formula :

\(\qquad\displaystyle p(x) = (((c_0(x-m_0)+c_1)(x-m_1)+ ... )(x-m_{n-2}) + c_{n-1})\)

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overloads
   constexpr auto newton(floating_value auto x, floating_value auto ... cmi)         noexcept; // 1
   constexpr auto newton(floating_value auto x, eve::coefficients ci
                                                eve::nodes auto ni)                  noexcept; // 2
 
   // Lanes masking
   constexpr auto newton[conditional_expr auto c](/*any of the above overloads*/)     noexcept; // 3
   constexpr auto newton[logical_value auto m](/*any of the above overloads*/)        noexcept; // 3
 
   // Semantic options
   constexpr auto newton[pedantic](/*any of the above overloads*/)                   noexcept; // 4
}

Parameters

• x: real floating argument.
• ci: eve::coefficients tuple containing the coefficients by decreasing power order.
• cn: eve::nodes tuple containing the nodes by decreasing power order.
• cni...: all the coefficients followed by all the nodes, both in decreasing power order. The total number of values is to be odd. If s is this number, the (s+1)/2 first are taken as the coefs and the others are the nodes. Note that the values of the cmi are not necessarily floating but the non floating ones are to be scalar
• c: Conditional expression masking the operation.
• m: Logical value masking the operation.

Return value

1. The value of the polynom at x is returned.
2. same as the call with the elements of the tuples.
3. The operation is performed conditionally.
4. fma[pedantic] instead of fma is used in internal computations.

Note

If the coefficients or nodes 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

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  eve::wide<float> wf([](auto i, auto c){ return (1+eve::eps(eve::as<float>()))*(i-c/2);});
  kumi::tuple wtc{wf,2*wf,3*wf};
  kumi::tuple wtn{4*wf, 5*wf};
 
  std::cout << std::setprecision(10);
  std::cout << "<- wf  = " << wf << "\n";
  std::cout << "<- wtc = " << wtc << "\n";
  std::cout << "<- wtn = " << wtn << "\n";
 
  std::cout << "-> newton(wf,wf,2*wf,3*wf,4*wf,5*wf)               = " << eve::newton(wf,wf,2*wf,3*wf,4*wf,5*wf) << "\n";
  std::cout << "-> newton(wf,coefficients(wtc),coefficients(wtn))  = " << eve::newton(wf, eve::coefficients(wtc),eve::nodes(wtn)) << "\n";
  std::cout << "-> newton[pedantic](wf,wf,2*wf,3*wf,4*wf, 5*wf)= " << eve::newton[eve::pedantic](wf,wf,2*wf,3*wf,4*wf, 5*wf) << "\n";
}