tchebsum

auto eve::tchebsum = functor<tchebsum_t>

inlineconstexpr

If \((c_i)_{0\le i\le n-1}\) denotes the coefficients of the polynomial by increasing power order, the Tchebsum scheme evaluates : \(\qquad\displaystyle p(x) = c_0/2+\sum_1^n c_n T_n(x))\)

Header file

#include <eve/module/math.hpp>

Callable Signatures

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

Parameters

• x: evaluation point floating value arguments.
• ci...: floating values tchebytchev coefficients in increasing 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 Tchebytchev coefficients of the polynomial The Tchebsum scheme evaluates : \(\qquad\displaystyle p(x) = c_0/2+\sum_1^n c_n T_n(x))\)

1. The value at x f the polynom based on first kind Tchebytchev function 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.
7. the order of the given coefficients is reversed

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/Tchebsum's_method)

Example

// revision 1
#include <eve/module/math.hpp>
#include <eve/module/polynomial.hpp>
#include <iostream>
#include <array>
 
double tch1(auto t, auto c)
{
  double u0 = 0;
  double u1 = 0;
  double u2 = 0;
  auto tt = t+t;
 
  for(int i=c.size()-1; i >= 0 ; --i)
  {
    u2=u1;
    u1=u0;
    u0=tt*u1+c[i]-u2;
  }
  return (u0-u2)/2;
}
 
double tch2(auto t, auto ... c)
{
  double u0 = 0;
  double u1 = 0;
  double u2 = 0;
  auto tt = t+t;
 
  auto clemshaw_step = [&](auto ci){
    u2=u1;
    u1=u0;
    u0 = fma(tt, u1, ci-u2);
    return u0;
  };
 
  ((u0 = clemshaw_step(c)), ...);
  return (u0-u2)/2;
}
 
int main()
{
  std::array<double, 4> c{1, 2, 3, 4};
 std::array<double, 4> d{4.0, 3.0, 2.0, 1.0};
  std::cout <<  tch1(-2.0, c) << std::endl;
  std::cout <<  eve::tchebsum[eve::increasing](2.0, c)<< std::endl;
  std::cout <<  eve::tchebsum[eve::decreasing](2.0, d)<< std::endl;
  std::cout <<  tch2(2.0, 4.0, 3.0, 2.0, 1.0)<< std::endl;
  std::cout <<  eve::tchebsum[eve::decreasing](2.0, 4.0, 3.0, 2.0, 1.0)<< std::endl;
  std::cout <<  eve::tchebsum(2.0, 1.0, 2.0, 3.0, 4.0)<< std::endl;
 
  eve::wide<double, eve::fixed<4>> xx{-2.0, -0.44, 0.44, 2.0};
  std::cout <<  eve::tchebsum[eve::increasing](xx, c)<< std::endl;
  std::cout <<  eve::tchebsum[eve::decreasing](xx, d)<< std::endl;
  std::cout <<  eve::tchebsum(xx, 1.0, 2.0, 3.0, 4.0)<< std::endl;
 
}