pow

auto eve::pow = functor<pow_t>

inlineconstexpr

Header file

#include <eve/module/math.hpp>

Callable Signatures

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

Parameters

Return value

1. Returns elementwise \(x^y\). In particular we have (IEC 60559):
   • pow(+0, y), where y is a negative odd integer, returns \(+\infty\)
   • pow(-0, y), where y is a negative odd integer, returns \(-\infty\)
   • pow( \(\pm0\), y), where y is negative, finite, and is an even integer or a non-integer, returns \(+\infty\)
   • pow( \(\pm0\), \(-\infty\)) returns \(+\infty\)
   • pow(+0, y), where y is a positive odd integer, returns +0
   • pow(-0, y), where y is a positive odd integer, returns -0
   • pow( \(\pm0\), y), where y is positive non-integer or a positive even integer, returns +0
   • pow(-1, \(\pm\infty\)) returns 1
   • pow(+1, y) returns 1 for any y, even when y is NaN
   • pow(x, \(\pm0\)) returns 1 for any x, even when x is NaN
   • pow(x, y) returns NaN if x is finite and less than 0 and y is finite and non-integer.
   • pow(x, \(-\infty\)) returns \(+\infty\) for any |x|<1
   • pow(x, \(-\infty\)) returns +0 for any |x|>1
   • pow(x, \(+\infty\)) returns +0 for any |x|<1
   • pow(x, \(+\infty\)) returns \(+\infty\) for any |x|>1
   • pow( \(-\infty\), y) returns -0 if y is a negative odd integer
   • pow( \(-\infty\), y) returns +0 if y is a negative non-integer or even integer
   • pow( \(-\infty\), y) returns \(-\infty\) if y is a positive odd integer
   • pow( \(-\infty\), y) returns \(+\infty\) if y is a positive non-integer or even integer
   • pow( \(+\infty\), y) returns +0 for any y less than 0
   • pow( \(+\infty\), y) returns \(+\infty\) for any y greater than 0
   • 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>
#include <cmath>
 
int main()
{
  eve::wide qf = {0.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 pf = {4.0f, 1.0f, -1.0f,  0.5f,  0.0f, 0.0f, -0.0f,  2.5f};
 
  std::cout << "<- pf                         = " << pf << "\n";
  std::cout << "<- qf                         = " << qf << "\n";
 
  std::cout << "-> pow(pf, qf)                = " << eve::pow(pf, qf) << "\n";
  std::cout << "-> pow[ignore_last(2)](pf, qf)= " << eve::pow[eve::ignore_last(2)](pf, qf) << "\n";
  std::cout << "-> pow[qf > 0.0f](pf, qf)     = " << eve::pow[qf > 0.0f](pf, qf) << "\n";
  std::cout << "-> pow[raw](pf, qf)           = " << eve::pow[eve::raw](pf, qf) << "\n";
}