rsqrt

auto kyosu::rsqrt = eve::functor<rsqrt_t>

inlineconstexpr

Computes a inverse square root value.

External references

• Wolfram MathWorld: Square Root
• Wikipedia: Square root

Example

#include <kyosu/kyosu.hpp>
#include <eve/wide.hpp>
#include <iostream>
 
int main()
{
  using kyosu::rsqrt;
  using kyosu::complex_t;
  using kyosu::quaternion_t;
  using kyosu::real_only;
 
  std::cout << "Real:        ";
  std::cout << 72.9f << " -> " << rsqrt(72.9f) << "\n";
 
  std::cout << "Complex:     ";
  std::cout << kyosu::complex_t<float>(3.5f,-2.9f) << " -> " << rsqrt(kyosu::complex_t<float>(3.5f,-2.9f)) << "\n";
 
  std::cout << "Quaternion:  ";
  std::cout << kyosu::quaternion_t<double>(1.,2.,3.,4.) << " -> " << rsqrt(kyosu::quaternion_t<double>(1.,2.,3.,4.)) << "\n";
 
  std::cout << "SIMD:        ";
  using wc_t = eve::wide<kyosu::complex_t<double>, eve::fixed<2>>;
  std::cout << wc_t(kyosu::complex_t<double>(1.3,-3.7)) << " -> " << rsqrt(wc_t(kyosu::complex_t<double>(1.3,-3.7))) << "\n";
 
  using e_t = float;
  using z_t = kyosu::complex_t<e_t>;
  using k_t = eve::wide<e_t, eve::fixed<2>>;
  z_t z{e_t(1.0), e_t(2.0)};
  k_t k{0, 1};
  e_t e(1.0);
 
  std::cout << "z                       " << z << std::endl;
  std::cout << "k                       " << k << std::endl;
  std::cout << "rsqrt(z)                " << rsqrt(z) << std::endl;
  std::cout << "rsqrt(z, k)             " << rsqrt(z, k) << std::endl;
  std::cout << "rsqrt(e)                " << rsqrt(e) << std::endl;
  std::cout << "rsqrt[real_only](e)     " << rsqrt[real_only](e) << std::endl;
  std::cout << "rsqrt(-e)               " << rsqrt(-e) << std::endl;
  std::cout << "rsqrt[real_only](-e)    " << rsqrt[real_only](-e) << std::endl;
  std::cout << "rsqrt(e, k)             " << rsqrt(e, k) << std::endl;
  std::cout << "rsqrt[real_only](e, k)  " << rsqrt[real_only](e, k) << std::endl;
  std::cout << "rsqrt[real_only](-e, k) " << rsqrt[real_only](-e, k) << std::endl;
  std::cout << "rsqrt[real_only](z, k)  " << rsqrt[real_only](z, k) << std::endl;
 
  return 0;
}

Header file

#include <kyosu/functions.hpp>

Callable Signatures

namespace kyosu
{
   //  regular call
   template<kyosu::concepts::cayley_dickson_like T> constexpr complexify_t<T> rsqrt(T z) noexcept;  //1
   template<kyosu::concepts::cayley_dickson_like T> constexpr auto sqrt(T z, K k) noexcept;         //2
 
   // semantic modifyers
   template<concepts::real T> constexpr complexify_t<T> rsqrt[real_only](T z) noexcept;             //1
}

Parameters

• z: Value to for which square root is computed.

Return value

1. Returns the inverse of the principal square root of z. A real typed input z is treated as if complex(z) was entered, unless the option real_only is used in which case the parameter must be a floating_value and the result will the same as if eve::rsqrt was called
2. Returns the inverse of the kth sqrt root of z, k is taken modulo 1; 1 gives the opposite root.