pow1p

eve::pow1p = functor<pow1p_t>

inlineconstexpr

Header file

#include <eve/module/math.hpp>

Callable Signatures

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

Parameters

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

Return value

1. Returns the [elementwise](@ref glossary_elementwise) \f$(1+x)^y\f$, with good accuracy,
   even when `x` is  small.
2. [The operation is performed conditionnaly](@ref conditional)
3. faster but less accurate call.

Example

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