pow_abs

auto eve::pow_abs = functor<pow_abs_t>

inlineconstexpr

Header file

#include <eve/module/math.hpp>

Callable Signatures

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

Parameters

• x, y: floating_value arguments.
• c: Conditional expression masking the operation.
• m: Logical value masking the operation.

Return value

Returns elementwise \(|x|^y\).

1. The result type is the common type of the two parameters. In particular we have (IEC 60559) for floating entries:
   • pow_abs( \(\pm0\), y), where y is a negative odd integer, returns \(+\infty\).
   • pow_abs( \(\pm0\), y), where y is negative, finite, and is an even integer or a non-integer, returns \(+\infty\).
   • pow_abs( \(\pm0\), \(-\infty\)) returns \(+\infty\).
   • pow_abs( \(\pm0\), y), where y is a positive odd integer, returns \(+0\).
   • pow_abs( \(\pm0\), y), where y is positive non-integer or a positive even integer, returns \(+0\).
   • pow_abs(-1, \(\pm\infty\)) returns 1.
   • pow_abs( \(\pm1\), y) returns 1 for any y, even when y is NaN.
   • pow_abs(x, \(\pm0\)) returns 1 for any x, even when x is NaN.
   • pow_abs(x, \(-\infty\)) returns \(+\infty\) for any |x| < 1.
   • pow_abs(x, \(-\infty\)) returns \(+0\) for any |x| > 1.
   • pow_abs(x, \(+\infty\)) returns \(+0\) for any |x| < 1.
   • pow_abs(x, \(+\infty\)) returns \(+\infty\) for any |x| > 1.
   • pow_abs( \(+\infty\), y) returns \(+0\) for any negative y.
   • pow_abs( \(+\infty\), y) returns \(+\infty\) for any positive y.
   • except where specified above, if any argument is NaN, NaN is returned.
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,
                  eve::inf(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 << "<- pf                             = " << pf << "\n";
   std::cout << "<- qf                             = " << qf << "\n";
 
   std::cout << "-> pow_abs(pf, qf)                = " << eve::pow_abs(pf, qf) << "\n";
   std::cout << "-> pow_abs[ignore_last(2)](pf, qf)= " << eve::pow_abs[eve::ignore_last(2)](pf, qf) << "\n";
   std::cout << "-> pow_abs[qf > 0.0f](pf, qf)     = " << eve::pow_abs[qf > 0.0f](pf, qf) << "\n";
   std::cout << "-> pow_abs[raw](pf, qf)           = " << eve::pow_abs[eve::raw](pf, qf) << "\n";
}