pow

kyosu::pow = eve::functor<pow_t>

inlineconstexpr

Computes the computing the pow operation $x^y$.

Header file

#include <kyosu/functions.hpp>

Callable Signatures

namespace kyosu
{
  constexpr auto pow(auto z0, auto z1) noexcept;                \\123
  constexpr auto pow(auto z0, eve::integral_value n)  noexcept; \\4
}

Parameters

• z0, z1: Values to process.

Return value

1. if both parameters are floating the call will act as if they were converted to complex before call
2. if both parameters are floating or complex. The ieee specification are taken:
   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
3. if any parameter as a dimensionality greater than 2, the call is semantically equivalent to exp(z1*log(z0))
4. pow can accept an integral typed second parameter, in this case it is the russian peasant algorithm that is used (feasible as every monogen ideals are commutative). If the first parameter is integral typed the result is real typed.

External references

• C++ standard reference: complex pow
• Wolfram MathWorld: Power

Example

#include <kyosu/kyosu.hpp>
#include <eve/wide.hpp>
#include <iostream>
 
int main()
{
  using kyosu::pow;
  using kyosu::complex_t;
  using kyosu::quaternion_t;
  using e_t = float;
  using c_t = kyosu::complex_t<float>;
  using q_t = kyosu::quaternion_t<float>;
  using we_t = eve::wide<float, eve::fixed<2>>;
  using wc_t = eve::wide<kyosu::complex_t<float>, eve::fixed<2>>;
  using wq_t = eve::wide<kyosu::quaternion_t<float>, eve::fixed<2>>;
  using wi_t =  eve::wide<int, eve::fixed<2>>;
 
  std::cout << "Real:        "<< "\n";
  e_t e0(1);
  e_t e1(2);
  std::cout << e0 << ", " << e1 << " -> "  << pow(e0, e1) << "\n";
  std::cout << e0 << ", " << e0 << " -> "  << pow(e0, e0) << "\n";
  we_t we0(e0);
  we_t we1(e1);
  wi_t wi0(4, 5);
  std::cout << we0 << ", " << we1 << " -> " << pow(we0, we1) << "\n";
  std::cout << we1 << ", " << wi0 << " -> " << pow(we1, wi0) << "\n";
 
  std::cout << "Complex:     "<< "\n";
  c_t c0(1, 5);
  c_t c1(5, 9);
  std::cout << c0 << ", " << c1 << " -> "  << pow(c0, c1) << "\n";
  std::cout << c0 << ", " << c0 << " -> "  << pow(c0, c0) << "\n";
  wc_t wc0(c0, c1);
  wc_t wc1(c1, c1);
  std::cout << wc0 << ", " << wc1 << " -> " << pow(wc0, wc1) << "\n";
  std::cout << wc0 << ", " << wi0 << " -> " << pow(wc0, wi0) << "\n";
 
 
  std::cout << "Quaternion:  "<< "\n";
  q_t q0(1, 5, 2, 3);
  q_t q1(5, 9, 6, 7);
  std::cout << q0 << ", " << q1 << " -> "  << pow(q0, q1) << "\n";
  std::cout << q0 << ", " << q0 << " -> "  << pow(q0, q0) << "\n";
  wq_t wq0(q0, q1);
  wq_t wq1(q1, q1);
  std::cout << wq0 << ", " << wq1 << " -> " << pow(wq0, wq1) << "\n";
 
  std::cout << "Mixed:  "<< "\n";
  std::cout << kyosu::pow(c0, q1) << std::endl;
  std::cout << kyosu::pow(e0, q1) << std::endl;
  std::cout << kyosu::pow(c0, wq1) << std::endl;
  std::cout << kyosu::pow(we0, q1) << std::endl;
 
  return 0;
}