powm1

eve::powm1 = functor<powm1_t>

inlineconstexpr

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto powm1(floating_value auto x, floating_value auto y)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto powm1[conditional_expr auto c](floating_value auto x, floating_value auto y) noexcept; // 2
   constexpr auto powm1[logical_value auto m](floating_value auto x, floating_value auto y)    noexcept; // 2
 
   // Semantic options
   constexpr auto powm1[raw](floating_value auto x, floating_value auto y)                     noexcept; // 3
}

Parameters

* `x`, `y`: [floating value](@ref floating_value) arguments.
* `c`: [Conditional expression](@ref conditional_expr) masking the operation.
* `m`: [Logical value](@ref logical) masking the operation.

Return value

1. Returns the elementwise power minus one, with good accuracy, even when y is very small, or when x is close to 1.
2. The operation is performed conditionnaly
3. faster but less accurate call.

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide pf = {2.0f, 3.0f, -4.0f, 2.0f, 2.0f,
                  2.0f, eve::minf(eve::as<float>()), eve::nan(eve::as<float>())};
  eve::wide qf = {4.0f, 1.0f, -1.0f,  0.5f,  0.0f,
                  eve::eps(eve::as<float>()), -3.0f,  2.5f};
 
   std::cout << "<- pf                           = " << pf << "\n";
   std::cout << "<- qf                           = " << qf << "\n";
 
   std::cout << "-> powm1(pf, qf)                = " << eve::powm1(pf, qf) << "\n";
   std::cout << "-> powm1[ignore_last(2)](pf, qf)= " << eve::powm1[eve::ignore_last(2)](pf, qf) << "\n";
   std::cout << "-> powm1[qf > 0.0f](pf, qf)     = " << eve::powm1[qf > 0.0f](pf, qf) << "\n";
   std::cout << "-> powm1[raw](pf, qf)           = " << eve::powm1[eve::raw](pf, qf) << "\n";
}