Constants

Detailed Description

These functions allows access to scalar and SIMD values of some mathematical constants. In particular, all libc++ constants are here, sometimes with a different name.

All floating mathematical constants supports a regular call and two decorated calls:

• the regular call provides the floating point representation that is nearest to the mathematical value,
• eve::upper provides the least representable value that is greater than the mathematical value,
• eve::lower provides the greatest representable value that is less than the mathematical value,

About constants names:

• When a name contains an _ it means that preceding the underscore is a 'function or multiplication that must be applied to the following parts:
  • log_2 stands for \(\log(2)\) the natural logarithm of 2
  • log2_e stands for \(\log2(e)\) the logarithm in base 2 of the euler constant,
  • inv_pi is the inverse of \(\pi\).
  • four_pio_3 stands for \(4\pi/3\) (the o meanings over).

Variables
constexpr auto	eve::catalan = functor<catalan_t>
	Callable object computing the catalan constant \(\beta(2) = \sum_0^\infty \frac{(-1)^n}{(2n+1)^2}\).
constexpr auto	eve::cbrt_pi = functor<cbrt_pi_t>
	Callable object computing the constant \(\sqrt[3]\pi\).
constexpr auto	eve::cos_1 = functor<cos_1_t>
	Callable object computing the constant \(\cos1\).
constexpr auto	eve::cosh_1 = functor<cosh_1_t>
	Callable object computing the constant \(\cosh(1)\).
constexpr auto	eve::egamma = functor<egamma_t>
	Callable object computing the Euler-Mascheroni constant : \(\gamma = \lim_{n\to\infty}\left( \sum_{k = 0}^n \frac1k - \log n\right )\).
constexpr auto	eve::γ = functor<egamma_t>
	Unicode alias for eve::egamma, computing the Euler-Mascheroni constant \(\gamma\).
constexpr auto	eve::egamma_sqr = functor<egamma_sqr_t>
	Callable object computing the square of the [Euler-Mascheroni constant](eve::egamma).
constexpr auto	eve::epso_2 = functor<epso_2_t>
	Callable object computing the half of the machine epsilon.
constexpr auto	eve::euler = functor<euler_t>
	Callable object computing the constant e basis of the natural logarithms.
constexpr auto	eve::exp_pi = functor<exp_pi_t>
	Callable object computing the constant \(e^\pi\).
constexpr auto	eve::extreme_value_skewness = functor<extreme_value_skewness_t>
	Callable object computing the extreme value distribution skewness : \(12\sqrt6\zeta(3)/\pi^3\).
constexpr auto	eve::four_minus_pi = functor<four_minus_pi_t>
	Callable object computing the constant \(4-\pi\).
constexpr auto	eve::four_pio_3 = functor<four_pio_3_t>
	Callable object computing the constant \(4\pi/3\).
constexpr auto	eve::glaisher = functor<glaisher_t>
	Callable object computing the Glaisher-Kinkelin constant.
constexpr auto	eve::inv_2eps = functor<inv_2eps_t>
	Callable object computing half the inverse of the machine epsilon.
constexpr auto	eve::inv_2pi = functor<inv_2pi_t>
	Callable object computing the constant \(\frac{1}{2\pi}\).
constexpr auto	eve::inv_e = functor<inv_e_t>
	Callable object computing the constant \(e^{-1}\).
constexpr auto	eve::inv_egamma = functor<inv_egamma_t>
	Callable object computing the inverse of the [Euler-Mascheroni constant](eve::egamma).
constexpr auto	eve::inv_pi = functor<inv_pi_t>
	Callable object computing the constant \(\frac{1}{\pi}\).
constexpr auto	eve::invcbrt_pi = functor<invcbrt_pi_t>
	Callable object computing the constant \(\pi^{-1/3}\).
constexpr auto	eve::invlog10_2 = functor<invlog10_2_t>
	Callable object computing the constant \(1/\log_{10}2\).
constexpr auto	eve::invlog10_e = functor<invlog10_e_t>
	Callable object computing the constant \(1/\log_{10}e\).
constexpr auto	eve::invlog_10 = functor<invlog_10_t>
	Callable object computing \(1/\log10\).
constexpr auto	eve::invlog_2 = functor<invlog_2_t>
	Callable object computing the constant \(1/\log2\).
constexpr auto	eve::invlog_phi = functor<invlog_phi_t>
	Callable object computing the inverse of the logarithm of the golden ratio : \(1/\log((1+\sqrt5)/2)\).
constexpr auto	eve::invsqrt_2 = functor<invsqrt_2_t>
	Callable object computing the constant \(2^{-1/2}\).
constexpr auto	eve::khinchin = functor<khinchin_t>
	Callable object computing the Khinchin constant.
constexpr auto	eve::log10_e = functor<log10_e_t>
	Callable object computing the constant \(\log_{10}e\).
constexpr auto	eve::log2_e = functor<log2_e_t>
	Callable object computing the constant \(\log_2 e\).
constexpr auto	eve::log_10 = functor<log_10_t>
	Callable object computing the constant \(\log 10\).
constexpr auto	eve::log_2 = functor<log_2_t>
	Callable object computing the constant \(\log 2\).
constexpr auto	eve::log_phi = functor<log_phi_t>
	Callable object computing the logarithm of the golden ratio : \(\log((1+\sqrt5)/2)\).
constexpr auto	eve::loglog_2 = functor<loglog_2_t>
	Callable object computing the constant \(\log(\log2)\).
constexpr auto	eve::maxlog = functor<maxlog_t>
	Callable object computing the greatest positive value for which eve::exp is finite.
constexpr auto	eve::maxlog10 = functor<maxlog10_t>
	Callable object computing the greatest positive value for which eve::exp10 is finite.
constexpr auto	eve::maxlog2 = functor<maxlog2_t>
	Callable object computing the greatest positive value for which eve::exp2 is finite.
constexpr auto	eve::minlog = functor<minlog_t>
	Callable object computing the least value for which eve::exp is normal and not zero.
constexpr auto	eve::minlog10 = functor<minlog10_t>
	Callable object computing the least value for which eve::exp10 is normal and not zero.
constexpr auto	eve::minlog10denormal = functor<minlog10denormal_t>
	Callable object computing the least value for which eve::exp10 is denormal and not zero.
constexpr auto	eve::minlog2 = functor<minlog2_t>
	Callable object computing the least value for which eve::exp2 is normal and not zero.
constexpr auto	eve::minlog2denormal = functor<minlog2denormal_t>
	Callable object computing the least value for which eve::exp2 is denormal and not zero.
constexpr auto	eve::minlogdenormal = functor<minlogdenormal_t>
	Callable object computing the least value for which eve::exp is denormal and not zero.
constexpr auto	eve::phi = functor<phi_t>
	Callable object computing the golden ratio : \(\frac{1+\sqrt5}2\).
constexpr auto	eve::pi = functor<pi_t>
	Callable object computing the constant \(\pi\).
constexpr auto	eve::π = functor<pi_t>
	Unicode alias for eve::pi, computing the constant \(\pi\).
constexpr auto	eve::pi2 = functor<pi2_t>
	Callable object computing the square of \(\pi\).
constexpr auto	eve::pi2o_16 = functor<pi2o_16_t>
	Callable object computing the constant \(\pi^2/16\).
constexpr auto	eve::pi2o_6 = functor<pi2o_6_t>
	Callable object computing the constant \(\pi^2/6\).
constexpr auto	eve::pi3 = functor<pi3_t>
	Callable object computing the pi cubed value : \(\pi^3\).
constexpr auto	eve::pi_minus_3 = functor<pi_minus_3_t>
	Callable object computing the constant \(\pi-3\).
constexpr auto	eve::pi_pow_e = functor<pi_pow_e_t>
	Callable object computing the constant \(\pi^e\).
constexpr auto	eve::pio_2 = functor<pio_2_t>
	Callable object computing the constant \(\pi/2\).
constexpr auto	eve::pio_3 = functor<pio_3_t>
	Callable object computing the constant \(\pi/3\).
constexpr auto	eve::pio_4 = functor<pio_4_t>
	Callable object computing the constant \(\pi/4\).
constexpr auto	eve::pio_6 = functor<pio_6_t>
	Callable object computing the constant \(\pi/6\).
constexpr auto	eve::quarter = functor<quarter_t>
	Callable object computing the constant \(1/4\).
constexpr auto	eve::rayleigh_kurtosis = functor<rayleigh_kurtosis_t>
	Callable object computing the Rayleigh kurtosis value : \(3+(6\pi^2-24\pi+16)/(4-\pi^2)\).
constexpr auto	eve::rayleigh_kurtosis_excess = functor<rayleigh_kurtosis_excess_t>
	Callable object computing the Rayleigh kurtosis excess value : \(-(6\pi^2-24\pi+16)/(4-\pi^2)\).
constexpr auto	eve::rayleigh_skewness = functor<rayleigh_skewness_t>
	Callable object computing the Rayleigh skewness value : \(2\sqrt\pi(\pi-3)/(4-\pi^{3/2})\).
constexpr auto	eve::rsqrt_2pi = functor<rsqrt_2pi_t>
	Callable object computing the constant \(1/\sqrt{2\pi}\).
constexpr auto	eve::rsqrt_e = functor<rsqrt_e_t>
	Callable object computing the constant \(1/\sqrt{e}\).
constexpr auto	eve::rsqrt_pi = functor<rsqrt_pi_t>
	Callable object computing the constant \(\pi^{-1/2}\).
constexpr auto	eve::rsqrt_pio_2 = functor<rsqrt_pio_2_t>
	Callable object computing the constant \((\pi/2)^{-1/2}\).
constexpr auto	eve::sin_1 = functor<sin_1_t>
	Callable object computing the constant \(\sin(1)\).
constexpr auto	eve::sinh_1 = functor<sinh_1_t>
	Callable object computing the constant \(\sinh(1)\).
constexpr auto	eve::sixth = functor<sixth_t>
	Callable object computing the constant \(1/6\).
constexpr auto	eve::sqrt_2 = functor<sqrt_2_t>
	Callable object computing the constant \(\sqrt2\).
constexpr auto	eve::sqrt_2pi = functor<sqrt_2pi_t>
	Callable object computing the constant \(\sqrt{2\pi}\).
constexpr auto	eve::sqrt_3 = functor<sqrt_3_t>
	Callable object computing constant \(\sqrt{3}\).
constexpr auto	eve::sqrt_e = functor<sqrt_e_t>
	Callable object computing the constant \(\sqrt{e}\).
constexpr auto	eve::sqrt_pi = functor<sqrt_pi_t>
	Callable object computing the constant \(\sqrt{\pi}\).
constexpr auto	eve::sqrt_pio_2 = functor<sqrt_pio_2_t>
	Callable object computing the constant \(\sqrt{\pi/2}\).
constexpr auto	eve::sqrtlog_4 = functor<sqrtlog_4_t>
	Callable object computing the constant \(\sqrt{\log4}\).
constexpr auto	eve::third = functor<third_t>
	Callable object computing the constant \(1/3\).
constexpr auto	eve::three_o_4 = functor<three_o_4_t>
	Callable object computing the constant \(3/4\).
constexpr auto	eve::three_pio_4 = functor<three_pio_4_t>
	Callable object computing the constant \(3\pi/4\).
constexpr auto	eve::two_o_3 = functor<two_o_3_t>
	Callable object computing the constant \(2/3\).
constexpr auto	eve::two_o_pi = functor<two_o_pi_t>
	Callable object computing the constant \(2/\pi\).
constexpr auto	eve::two_o_sqrt_pi = functor<two_o_sqrt_pi_t>
	Callable object computing the constant \(2/\sqrt\pi\).
constexpr auto	eve::two_pi = functor<two_pi_t>
	Callable object computing the constant \(2\pi\).
constexpr auto	eve::two_pio_3 = functor<two_pio_3_t>
	Callable object computing the constant \(2\pi/3\).
constexpr auto	eve::zeta_2 = functor<zeta_2_t>
	Callable object computing the constant \(\zeta(2)\).
constexpr auto	eve::zeta_3 = functor<zeta_3_t>
	Callable object computing the constant \(\zeta(3)\).

Variable Documentation

catalan

auto eve::catalan = functor<catalan_t>

inlineconstexpr

Callable object computing the catalan constant \(\beta(2) = \sum_0^\infty \frac{(-1)^n}{(2n+1)^2}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
  template< eve::floating_value T > constexpr T catalan(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::catalan(as<T>()) returns the catalan constant \(\beta(2) = \sum_0^\infty \frac{(-1)^n}{(2n+1)^2}\).

External references

• Wolfram MathWorld
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_catalan() { return eve::catalan(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf([](auto i){return eve::is_odd(i)?-1.f:1.f; ; });
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> catalan(as<wide_ft>())                 = " << eve::catalan(eve::as<wide_ft>())                << std::endl
            << "-> catalan(as(wxf))                       = " << eve::catalan(eve::as(wxf))                      << std::endl
            << "-> catalan[upper](as<wide_ft>())         = " << eve::catalan[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> catalan[upper](as(wxf))               = " << eve::catalan[eve::upper](eve::as(wxf))         << std::endl
            << "-> catalan[lower](as<wide_ft>())       = " << eve::catalan[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> catalan[lower](as(wxf))             = " << eve::catalan[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> catalan(as<wide_dt>())           = " << eve::catalan(eve::as<wide_dt>())                << std::endl
            << "-> catalan(as(wxd))                 = " << eve::catalan(eve::as(wxd))                      << std::endl
            << "-> catalan[upper](as<wide_dt>())   = " << eve::catalan[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> catalan[upper](as(wxd))         = " << eve::catalan[eve::upper](eve::as(wxd))         << std::endl
            << "-> catalan[lower](as<wide_dt>()) = " << eve::catalan[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> catalan[lower](as(wxd))       = " << eve::catalan[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> catalan(as<float>())             = " << eve::catalan(eve::as(float())) << std::endl
            << "-> catalan(as<xf))                  = " << eve::catalan(eve::as(xf))      << std::endl
            << "-> catalan(as<double>())            = " << eve::catalan(eve::as(double()))<< std::endl
            << "-> catalan(as<xd))                  = " << eve::catalan(eve::as(xd))      << std::endl;
 
   std::cout << "---- masked" << std::endl
             << "<- wxf                               = " << wxf << std::endl
             << "-> catalan[wxf <  0.0f](as(wxf))     = " << eve::catalan[wxf < 0.0f](eve::as(wxf)) << std::endl
             << "-> catalan[ignore_first(3)](as(wxf)) = " << eve::catalan[eve::ignore_first(3)](eve::as(wxf))  << std::endl;
 
   std::cout << "-> constexpr catalan                 = " << constexpr_catalan<float>() << std::endl;
 
  return 0;
}

cbrt_pi

auto eve::cbrt_pi = functor<cbrt_pi_t>

inlineconstexpr

Callable object computing the constant \(\sqrt[3]\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T cbrt_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::cbrt_pi(as<T>()) returns \(\sqrt[3]\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_cbrt_pi() { return eve::cbrt_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> cbrt_pi(as<wide_ft>())                 = " << eve::cbrt_pi(eve::as<wide_ft>())                << std::endl
            << "-> cbrt_pi(as(wxf))                       = " << eve::cbrt_pi(eve::as(wxf))                      << std::endl
            << "-> cbrt_pi[upper](as<wide_ft>())         = " << eve::cbrt_pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> cbrt_pi[upper](as(wxf))               = " << eve::cbrt_pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> cbrt_pi[lower](as<wide_ft>())       = " << eve::cbrt_pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> cbrt_pi[lower](as(wxf))             = " << eve::cbrt_pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> cbrt_pi(as<wide_dt>())           = " << eve::cbrt_pi(eve::as<wide_dt>())                << std::endl
            << "-> cbrt_pi(as(wxd))                 = " << eve::cbrt_pi(eve::as(wxd))                      << std::endl
            << "-> cbrt_pi[upper](as<wide_dt>())   = " << eve::cbrt_pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> cbrt_pi[upper](as(wxd))         = " << eve::cbrt_pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> cbrt_pi[lower](as<wide_dt>()) = " << eve::cbrt_pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> cbrt_pi[lower](as(wxd))       = " << eve::cbrt_pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> cbrt_pi(as<float>())             = " << eve::cbrt_pi(eve::as(float())) << std::endl
            << "-> cbrt_pi(as<xf))                  = " << eve::cbrt_pi(eve::as(xf))      << std::endl
            << "-> cbrt_pi(as<double>())            = " << eve::cbrt_pi(eve::as(double()))<< std::endl
            << "-> cbrt_pi(as<xd))                  = " << eve::cbrt_pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr cbrt_pi            = " << constexpr_cbrt_pi<float>() << std::endl;
 
  return 0;
}

cos_1

auto eve::cos_1 = functor<cos_1_t>

inlineconstexpr

Callable object computing the constant \(\cos1\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T cos_1(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::cos_1(as<T>()) returns the cosine of 1.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_cos_1() { return eve::cos_1(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> cos_1(as<wide_ft>())                 = " << eve::cos_1(eve::as<wide_ft>())                << std::endl
            << "-> cos_1(as(wxf))                       = " << eve::cos_1(eve::as(wxf))                      << std::endl
            << "-> cos_1[upper](as<wide_ft>())         = " << eve::cos_1[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> cos_1[upper](as(wxf))               = " << eve::cos_1[eve::upper](eve::as(wxf))         << std::endl
            << "-> cos_1[lower](as<wide_ft>())       = " << eve::cos_1[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> cos_1[lower](as(wxf))             = " << eve::cos_1[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> cos_1(as<wide_dt>())           = " << eve::cos_1(eve::as<wide_dt>())                << std::endl
            << "-> cos_1(as(wxd))                 = " << eve::cos_1(eve::as(wxd))                      << std::endl
            << "-> cos_1[upper](as<wide_dt>())   = " << eve::cos_1[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> cos_1[upper](as(wxd))         = " << eve::cos_1[eve::upper](eve::as(wxd))         << std::endl
            << "-> cos_1[lower](as<wide_dt>()) = " << eve::cos_1[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> cos_1[lower](as(wxd))       = " << eve::cos_1[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> cos_1(as<float>())             = " << eve::cos_1(eve::as(float())) << std::endl
            << "-> cos_1(as<xf))                  = " << eve::cos_1(eve::as(xf))      << std::endl
            << "-> cos_1(as<double>())            = " << eve::cos_1(eve::as(double()))<< std::endl
            << "-> cos_1(as<xd))                  = " << eve::cos_1(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr cos_1            = " << constexpr_cos_1<float>() << std::endl;
 
  return 0;
}

cosh_1

auto eve::cosh_1 = functor<cosh_1_t>

inlineconstexpr

Callable object computing the constant \(\cosh(1)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T cosh_1(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::cosh_1(as<T>()) returns the hyperbolic cosine of 1.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_cosh_1() { return eve::cosh_1(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> cosh_1(as<wide_ft>())                 = " << eve::cosh_1(eve::as<wide_ft>())                << std::endl
            << "-> cosh_1(as(wxf))                       = " << eve::cosh_1(eve::as(wxf))                      << std::endl
            << "-> cosh_1[upper](as<wide_ft>())         = " << eve::cosh_1[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> cosh_1[upper](as(wxf))               = " << eve::cosh_1[eve::upper](eve::as(wxf))         << std::endl
            << "-> cosh_1[lower](as<wide_ft>())       = " << eve::cosh_1[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> cosh_1[lower](as(wxf))             = " << eve::cosh_1[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> cosh_1(as<wide_dt>())           = " << eve::cosh_1(eve::as<wide_dt>())                << std::endl
            << "-> cosh_1(as(wxd))                 = " << eve::cosh_1(eve::as(wxd))                      << std::endl
            << "-> cosh_1[upper](as<wide_dt>())   = " << eve::cosh_1[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> cosh_1[upper](as(wxd))         = " << eve::cosh_1[eve::upper](eve::as(wxd))         << std::endl
            << "-> cosh_1[lower](as<wide_dt>()) = " << eve::cosh_1[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> cosh_1[lower](as(wxd))       = " << eve::cosh_1[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> cosh_1(as<float>())             = " << eve::cosh_1(eve::as(float())) << std::endl
            << "-> cosh_1(as<xf))                  = " << eve::cosh_1(eve::as(xf))      << std::endl
            << "-> cosh_1(as<double>())            = " << eve::cosh_1(eve::as(double()))<< std::endl
            << "-> cosh_1(as<xd))                  = " << eve::cosh_1(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr cosh_1            = " << constexpr_cosh_1<float>() << std::endl;
 
  return 0;
}

egamma

auto eve::egamma = functor<egamma_t>

inlineconstexpr

Callable object computing the Euler-Mascheroni constant : \(\gamma = \lim_{n\to\infty}\left( \sum_{k = 0}^n \frac1k - \log n\right )\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T egamma(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::egamma(as<T>()) returns \(\gamma = \lim_{n\to\infty}\left( \sum_{k = 0}^n \frac1k - \log n\right )\). γ is an alias.

External references

• Wolfram MathWorld
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_egamma() { return eve::egamma(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> egamma(as<wide_ft>())       = " << eve::egamma(eve::as<wide_ft>())            << std::endl
            << "-> egamma(as(wxf))             = " << eve::egamma(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> egamma(as<float>())         = " << eve::egamma(eve::as(float())) << std::endl
            << "-> egamma(as(xf))              = " << eve::egamma(eve::as(xf))      << std::endl;
 
  std::cout << "---- unicode alias" << std::endl
            << "-> \u03b3(as(xf))                  = " << eve::γ(eve::as(xf))           << std::endl;
 
 
  std::cout << "-> constexpr egamma            = " << constexpr_egamma<float>() << std::endl;
 
  return 0;
}

egamma_sqr

auto eve::egamma_sqr = functor<egamma_sqr_t>

inlineconstexpr

Callable object computing the square of the [Euler-Mascheroni constant](eve::egamma).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T egamma_sqr(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::egamma_sqr(as<T>()) returns the square of the [Euler-Mascheroni constant](eve::egamma).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_egamma_sqr() { return eve::egamma_sqr(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> egamma_sqr(as<wide_ft>())                 = " << eve::egamma_sqr(eve::as<wide_ft>())                << std::endl
            << "-> egamma_sqr(as(wxf))                       = " << eve::egamma_sqr(eve::as(wxf))                      << std::endl
            << "-> egamma_sqr[upper](as<wide_ft>())         = " << eve::egamma_sqr[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> egamma_sqr[upper](as(wxf))               = " << eve::egamma_sqr[eve::upper](eve::as(wxf))         << std::endl
            << "-> egamma_sqr[lower](as<wide_ft>())       = " << eve::egamma_sqr[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> egamma_sqr[lower](as(wxf))             = " << eve::egamma_sqr[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> egamma_sqr(as<wide_dt>())           = " << eve::egamma_sqr(eve::as<wide_dt>())                << std::endl
            << "-> egamma_sqr(as(wxd))                 = " << eve::egamma_sqr(eve::as(wxd))                      << std::endl
            << "-> egamma_sqr[upper](as<wide_dt>())   = " << eve::egamma_sqr[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> egamma_sqr[upper](as(wxd))         = " << eve::egamma_sqr[eve::upper](eve::as(wxd))         << std::endl
            << "-> egamma_sqr[lower](as<wide_dt>()) = " << eve::egamma_sqr[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> egamma_sqr[lower](as(wxd))       = " << eve::egamma_sqr[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> egamma_sqr(as<float>())             = " << eve::egamma_sqr(eve::as(float())) << std::endl
            << "-> egamma_sqr(as<xf))                  = " << eve::egamma_sqr(eve::as(xf))      << std::endl
            << "-> egamma_sqr(as<double>())            = " << eve::egamma_sqr(eve::as(double()))<< std::endl
            << "-> egamma_sqr(as<xd))                  = " << eve::egamma_sqr(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr egamma_sqr            = " << constexpr_egamma_sqr<float>() << std::endl;
 
  return 0;
}

epso_2

auto eve::epso_2 = functor<epso_2_t>

inlineconstexpr

Callable object computing the half of the machine epsilon.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T epso_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::epso_2(as<T>()) returns the half of the machine epsilon.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_epso_2() { return eve::epso_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> epso_2(as<wide_ft>())       = " << eve::epso_2(eve::as<wide_ft>())            << std::endl
            << "-> epso_2(as(wxf))             = " << eve::epso_2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> epso_2(as<float>())         = " << eve::epso_2(eve::as(float())) << std::endl
            << "-> epso_2(as<xf))              = " << eve::epso_2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr epso_2            = " << constexpr_epso_2<float>() << std::endl;
 
  return 0;
}

euler

auto eve::euler = functor<euler_t>

inlineconstexpr

Callable object computing the constant e basis of the natural logarithms.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T euler(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::euler(as<T>()) returns the basis of the natural logarithms.

External references

• Wolfram MathWorld
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_euler() { return eve::euler(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> euler(as<wide_ft>())        = " << eve::euler(eve::as<wide_ft>())            << std::endl
            << "-> euler(as(wxf))              = " << eve::euler(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> euler(as<float>())         = " << eve::euler(eve::as(float())) << std::endl
            << "-> euler(as<xf))              = " << eve::euler(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr euler            = " << constexpr_euler<float>() << std::endl;
 
  return 0;
}

exp_pi

auto eve::exp_pi = functor<exp_pi_t>

inlineconstexpr

Callable object computing the constant \(e^\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T exp_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::exp_pi(as<T>()) returns \(e^\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_exp_pi() { return eve::exp_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> exp_pi(as<wide_ft>())                 = " << eve::exp_pi(eve::as<wide_ft>())                << std::endl
            << "-> exp_pi(as(wxf))                       = " << eve::exp_pi(eve::as(wxf))                      << std::endl
            << "-> exp_pi[upper](as<wide_ft>())         = " << eve::exp_pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> exp_pi[upper](as(wxf))               = " << eve::exp_pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> exp_pi[lower](as<wide_ft>())       = " << eve::exp_pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> exp_pi[lower](as(wxf))             = " << eve::exp_pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> exp_pi(as<wide_dt>())           = " << eve::exp_pi(eve::as<wide_dt>())                << std::endl
            << "-> exp_pi(as(wxd))                 = " << eve::exp_pi(eve::as(wxd))                      << std::endl
            << "-> exp_pi[upper](as<wide_dt>())   = " << eve::exp_pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> exp_pi[upper](as(wxd))         = " << eve::exp_pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> exp_pi[lower](as<wide_dt>()) = " << eve::exp_pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> exp_pi[lower](as(wxd))       = " << eve::exp_pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> exp_pi(as<float>())             = " << eve::exp_pi(eve::as(float())) << std::endl
            << "-> exp_pi(as<xf))                  = " << eve::exp_pi(eve::as(xf))      << std::endl
            << "-> exp_pi(as<double>())            = " << eve::exp_pi(eve::as(double()))<< std::endl
            << "-> exp_pi(as<xd))                  = " << eve::exp_pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr exp_pi            = " << constexpr_exp_pi<float>() << std::endl;
 
  return 0;
}

extreme_value_skewness

auto eve::extreme_value_skewness = functor<extreme_value_skewness_t>

inlineconstexpr

Callable object computing the extreme value distribution skewness : \(12\sqrt6\zeta(3)/\pi^3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T extreme_value_skewness(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::extreme_value_skewness(as<T>()) returns \(12\sqrt6\zeta(3)/\pi^3\).

Example

// revision 0
#include <eve/module/math.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  using wf_t = eve::wide<float>;
  using wd_t = eve::wide<double>;
 
  std::cout << std::setprecision(9);
  std::cout << "-> extreme_value_skewness(as<float>())          = " << eve::extreme_value_skewness(eve::as<float>())          << "\n";
  std::cout << "-> extreme_value_skewness(as<wf_t>())           = " << eve::extreme_value_skewness(eve::as<wf_t>())           << "\n";
  std::cout << "-> extreme_value_skewness[lower](as<wf_t>())    = " << eve::extreme_value_skewness[eve::lower](eve::as<wf_t>()) << "\n";
  std::cout << "-> extreme_value_skewness[upper](as<wf_t>())    = " << eve::extreme_value_skewness[eve::upper](eve::as<wf_t>()) << "\n";
 
  std::cout << std::setprecision(17);
  std::cout << "-> extreme_value_skewness(as<double>())         = " << eve::extreme_value_skewness(eve::as<double>())         << "\n";
  std::cout << "-> extreme_value_skewness(as<wd_t>())           = " << eve::extreme_value_skewness(eve::as<wd_t>())           << "\n";
  std::cout << "-> extreme_value_skewness[lower](as<wd_t>())    = " << eve::extreme_value_skewness[eve::lower](eve::as<wd_t>()) << "\n";
  std::cout << "-> extreme_value_skewness[upper](as<wd_t>())    = " << eve::extreme_value_skewness[eve::upper](eve::as<wd_t>()) << "\n";
}

four_minus_pi

auto eve::four_minus_pi = functor<four_minus_pi_t>

inlineconstexpr

Callable object computing the constant \(4-\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T four_minus_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::four_minus_pi(as<T>()) returns \(4-\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_four_minus_pi() { return eve::four_minus_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> four_minus_pi(as<wide_ft>())                 = " << eve::four_minus_pi(eve::as<wide_ft>())                << std::endl
            << "-> four_minus_pi(as(wxf))                       = " << eve::four_minus_pi(eve::as(wxf))                      << std::endl
            << "-> four_minus_pi[upper](as<wide_ft>())         = " << eve::four_minus_pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> four_minus_pi[upper](as(wxf))               = " << eve::four_minus_pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> four_minus_pi[lower](as<wide_ft>())       = " << eve::four_minus_pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> four_minus_pi[lower](as(wxf))             = " << eve::four_minus_pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> four_minus_pi(as<wide_dt>())           = " << eve::four_minus_pi(eve::as<wide_dt>())                << std::endl
            << "-> four_minus_pi(as(wxd))                 = " << eve::four_minus_pi(eve::as(wxd))                      << std::endl
            << "-> four_minus_pi[upper](as<wide_dt>())   = " << eve::four_minus_pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> four_minus_pi[upper](as(wxd))         = " << eve::four_minus_pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> four_minus_pi[lower](as<wide_dt>()) = " << eve::four_minus_pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> four_minus_pi[lower](as(wxd))       = " << eve::four_minus_pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> four_minus_pi(as<float>())             = " << eve::four_minus_pi(eve::as(float())) << std::endl
            << "-> four_minus_pi(as<xf))                  = " << eve::four_minus_pi(eve::as(xf))      << std::endl
            << "-> four_minus_pi(as<double>())            = " << eve::four_minus_pi(eve::as(double()))<< std::endl
            << "-> four_minus_pi(as<xd))                  = " << eve::four_minus_pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr four_minus_pi            = " << constexpr_four_minus_pi<float>() << std::endl;
 
  return 0;
}

four_pio_3

auto eve::four_pio_3 = functor<four_pio_3_t>

inlineconstexpr

Callable object computing the constant \(4\pi/3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T four_pio_3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::four_pio_3(as<T>()) returns \(4\pi/3\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_four_pio_3() { return eve::four_pio_3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> four_pio_3(as<wide_ft>())                 = " << eve::four_pio_3(eve::as<wide_ft>())                << std::endl
            << "-> four_pio_3(as(wxf))                       = " << eve::four_pio_3(eve::as(wxf))                      << std::endl
            << "-> four_pio_3[upper](as<wide_ft>())         = " << eve::four_pio_3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> four_pio_3[upper](as(wxf))               = " << eve::four_pio_3[eve::upper](eve::as(wxf))         << std::endl
            << "-> four_pio_3[lower](as<wide_ft>())       = " << eve::four_pio_3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> four_pio_3[lower](as(wxf))             = " << eve::four_pio_3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> four_pio_3(as<wide_dt>())           = " << eve::four_pio_3(eve::as<wide_dt>())                << std::endl
            << "-> four_pio_3(as(wxd))                 = " << eve::four_pio_3(eve::as(wxd))                      << std::endl
            << "-> four_pio_3[upper](as<wide_dt>())   = " << eve::four_pio_3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> four_pio_3[upper](as(wxd))         = " << eve::four_pio_3[eve::upper](eve::as(wxd))         << std::endl
            << "-> four_pio_3[lower](as<wide_dt>()) = " << eve::four_pio_3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> four_pio_3[lower](as(wxd))       = " << eve::four_pio_3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> four_pio_3(as<float>())             = " << eve::four_pio_3(eve::as(float())) << std::endl
            << "-> four_pio_3(as<xf))                  = " << eve::four_pio_3(eve::as(xf))      << std::endl
            << "-> four_pio_3(as<double>())            = " << eve::four_pio_3(eve::as(double()))<< std::endl
            << "-> four_pio_3(as<xd))                  = " << eve::four_pio_3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr four_pio_3            = " << constexpr_four_pio_3<float>() << std::endl;
 
  return 0;
}

glaisher

auto eve::glaisher = functor<glaisher_t>

inlineconstexpr

Callable object computing the Glaisher-Kinkelin constant.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T glaisher(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::glaisher(as<T>()) returns the Glaisher-Kinkelin constant.

External references

• Wolfram MathWorld
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_glaisher() { return eve::glaisher(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> glaisher(as<wide_ft>())                 = " << eve::glaisher(eve::as<wide_ft>())                << std::endl
            << "-> glaisher(as(wxf))                       = " << eve::glaisher(eve::as(wxf))                      << std::endl
            << "-> glaisher[upper](as<wide_ft>())         = " << eve::glaisher[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> glaisher[upper](as(wxf))               = " << eve::glaisher[eve::upper](eve::as(wxf))         << std::endl
            << "-> glaisher[lower](as<wide_ft>())       = " << eve::glaisher[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> glaisher[lower](as(wxf))             = " << eve::glaisher[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> glaisher(as<wide_dt>())           = " << eve::glaisher(eve::as<wide_dt>())                << std::endl
            << "-> glaisher(as(wxd))                 = " << eve::glaisher(eve::as(wxd))                      << std::endl
            << "-> glaisher[upper](as<wide_dt>())   = " << eve::glaisher[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> glaisher[upper](as(wxd))         = " << eve::glaisher[eve::upper](eve::as(wxd))         << std::endl
            << "-> glaisher[lower](as<wide_dt>()) = " << eve::glaisher[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> glaisher[lower](as(wxd))       = " << eve::glaisher[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> glaisher(as<float>())             = " << eve::glaisher(eve::as(float())) << std::endl
            << "-> glaisher(as<xf))                  = " << eve::glaisher(eve::as(xf))      << std::endl
            << "-> glaisher(as<double>())            = " << eve::glaisher(eve::as(double()))<< std::endl
            << "-> glaisher(as<xd))                  = " << eve::glaisher(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr glaisher            = " << constexpr_glaisher<float>() << std::endl;
 
  return 0;
}

inv_2eps

auto eve::inv_2eps = functor<inv_2eps_t>

inlineconstexpr

Callable object computing half the inverse of the machine epsilon.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T inv_2eps(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::inv_2eps(as<T>()) returns half the inverse of the machine epsilon.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_inv_2eps() { return eve::inv_2eps(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> inv_2eps(as<wide_ft>())        = " << eve::inv_2eps(eve::as<wide_ft>())            << std::endl
            << "-> inv_2eps(as(wxf))              = " << eve::inv_2eps(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> inv_2eps(as<float>())         = " << eve::inv_2eps(eve::as(float())) << std::endl
            << "-> inv_2eps(as<xf))              = " << eve::inv_2eps(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr inv_2eps            = " << constexpr_inv_2eps<float>() << std::endl;
 
  return 0;
}

inv_2pi

auto eve::inv_2pi = functor<inv_2pi_t>

inlineconstexpr

Callable object computing the constant \(\frac{1}{2\pi}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T inv_2pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::inv_2pi(as<T>()) returns the inverse of \(2\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_inv_2pi() { return eve::inv_2pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> inv_2pi(as<wide_ft>())                 = " << eve::inv_2pi(eve::as<wide_ft>())                << std::endl
            << "-> inv_2pi(as(wxf))                       = " << eve::inv_2pi(eve::as(wxf))                      << std::endl
            << "-> inv_2pi[upper](as<wide_ft>())         = " << eve::inv_2pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> inv_2pi[upper](as(wxf))               = " << eve::inv_2pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> inv_2pi[lower](as<wide_ft>())       = " << eve::inv_2pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> inv_2pi[lower](as(wxf))             = " << eve::inv_2pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> inv_2pi(as<wide_dt>())           = " << eve::inv_2pi(eve::as<wide_dt>())                << std::endl
            << "-> inv_2pi(as(wxd))                 = " << eve::inv_2pi(eve::as(wxd))                      << std::endl
            << "-> inv_2pi[upper](as<wide_dt>())   = " << eve::inv_2pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> inv_2pi[upper](as(wxd))         = " << eve::inv_2pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> inv_2pi[lower](as<wide_dt>()) = " << eve::inv_2pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> inv_2pi[lower](as(wxd))       = " << eve::inv_2pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> inv_2pi(as<float>())             = " << eve::inv_2pi(eve::as(float())) << std::endl
            << "-> inv_2pi(as<xf))                  = " << eve::inv_2pi(eve::as(xf))      << std::endl
            << "-> inv_2pi(as<double>())            = " << eve::inv_2pi(eve::as(double()))<< std::endl
            << "-> inv_2pi(as<xd))                  = " << eve::inv_2pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr inv_2pi            = " << constexpr_inv_2pi<float>() << std::endl;
 
  return 0;
}

inv_e

auto eve::inv_e = functor<inv_e_t>

inlineconstexpr

Callable object computing the constant \(e^{-1}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T inv_e(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::inv_e(as<T>()) returns athe inverse of the basis of the natural logarithms.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_inv_e() { return eve::inv_e(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> inv_e(as<wide_ft>())                 = " << eve::inv_e(eve::as<wide_ft>())                << std::endl
            << "-> inv_e(as(wxf))                       = " << eve::inv_e(eve::as(wxf))                      << std::endl
            << "-> inv_e[upper](as<wide_ft>())         = " << eve::inv_e[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> inv_e[upper](as(wxf))               = " << eve::inv_e[eve::upper](eve::as(wxf))         << std::endl
            << "-> inv_e[lower](as<wide_ft>())       = " << eve::inv_e[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> inv_e[lower](as(wxf))             = " << eve::inv_e[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> inv_e(as<wide_dt>())           = " << eve::inv_e(eve::as<wide_dt>())                << std::endl
            << "-> inv_e(as(wxd))                 = " << eve::inv_e(eve::as(wxd))                      << std::endl
            << "-> inv_e[upper](as<wide_dt>())   = " << eve::inv_e[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> inv_e[upper](as(wxd))         = " << eve::inv_e[eve::upper](eve::as(wxd))         << std::endl
            << "-> inv_e[lower](as<wide_dt>()) = " << eve::inv_e[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> inv_e[lower](as(wxd))       = " << eve::inv_e[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> inv_e(as<float>())             = " << eve::inv_e(eve::as(float())) << std::endl
            << "-> inv_e(as<xf))                  = " << eve::inv_e(eve::as(xf))      << std::endl
            << "-> inv_e(as<double>())            = " << eve::inv_e(eve::as(double()))<< std::endl
            << "-> inv_e(as<xd))                  = " << eve::inv_e(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr inv_e            = " << constexpr_inv_e<float>() << std::endl;
 
  return 0;
}

inv_egamma

auto eve::inv_egamma = functor<inv_egamma_t>

inlineconstexpr

Callable object computing the inverse of the [Euler-Mascheroni constant](eve::egamma).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T inv_egamma(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::inv_egamma(as<T>()) returns the inverse of the [Euler-Mascheroni constant](eve::egamma).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_inv_egamma() { return eve::inv_egamma(eve::as<T>{}); }
 
int main()
{
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> inv_egamma(as<wide_ft>())                 = " << eve::inv_egamma(eve::as<wide_ft>())                << std::endl
            << "-> inv_egamma[upper](as<wide_ft>())         = " << eve::inv_egamma[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> inv_egamma[lower](as<wide_ft>())       = " << eve::inv_egamma[eve::lower](eve::as<wide_ft>()) << std::endl;
 
 
  std::cout << "---- scalar" << std::endl
            << "-> inv_egamma(as<float>())             = " << eve::inv_egamma(eve::as(float())) << std::endl;
 
 
  std::cout << "-> constexpr inv_egamma            = " << constexpr_inv_egamma<float>() << std::endl;
 
  return 0;
}

inv_pi

auto eve::inv_pi = functor<inv_pi_t>

inlineconstexpr

Callable object computing the constant \(\frac{1}{\pi}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T inv_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::inv_pi(as<T>()) returns the inverse of \(\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_inv_pi() { return eve::inv_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> inv_pi(as<wide_ft>())       = " << eve::inv_pi(eve::as<wide_ft>())            << std::endl
            << "-> inv_pi(as(wxf))             = " << eve::inv_pi(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> inv_pi(as<float>())         = " << eve::inv_pi(eve::as(float())) << std::endl
            << "-> inv_pi(as<xf))              = " << eve::inv_pi(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr inv_pi            = " << constexpr_inv_pi<float>() << std::endl;
 
  return 0;
}

invcbrt_pi

auto eve::invcbrt_pi = functor<invcbrt_pi_t>

inlineconstexpr

Callable object computing the constant \(\pi^{-1/3}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T invcbrt_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::invcbrt_pi(as<T>()) returns the inverse of the cubic root of \(\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_invcbrt_pi() { return eve::invcbrt_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> invcbrt_pi(as<wide_ft>())                 = " << eve::invcbrt_pi(eve::as<wide_ft>())                << std::endl
            << "-> invcbrt_pi(as(wxf))                       = " << eve::invcbrt_pi(eve::as(wxf))                      << std::endl
            << "-> invcbrt_pi[upper](as<wide_ft>())         = " << eve::invcbrt_pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> invcbrt_pi[upper](as(wxf))               = " << eve::invcbrt_pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> invcbrt_pi[lower](as<wide_ft>())       = " << eve::invcbrt_pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> invcbrt_pi[lower](as(wxf))             = " << eve::invcbrt_pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> invcbrt_pi(as<wide_dt>())           = " << eve::invcbrt_pi(eve::as<wide_dt>())                << std::endl
            << "-> invcbrt_pi(as(wxd))                 = " << eve::invcbrt_pi(eve::as(wxd))                      << std::endl
            << "-> invcbrt_pi[upper](as<wide_dt>())   = " << eve::invcbrt_pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> invcbrt_pi[upper](as(wxd))         = " << eve::invcbrt_pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> invcbrt_pi[lower](as<wide_dt>()) = " << eve::invcbrt_pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> invcbrt_pi[lower](as(wxd))       = " << eve::invcbrt_pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> invcbrt_pi(as<float>())             = " << eve::invcbrt_pi(eve::as(float())) << std::endl
            << "-> invcbrt_pi(as<xf))                  = " << eve::invcbrt_pi(eve::as(xf))      << std::endl
            << "-> invcbrt_pi(as<double>())            = " << eve::invcbrt_pi(eve::as(double()))<< std::endl
            << "-> invcbrt_pi(as<xd))                  = " << eve::invcbrt_pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr invcbrt_pi            = " << constexpr_invcbrt_pi<float>() << std::endl;
 
  return 0;
}

invlog10_2

auto eve::invlog10_2 = functor<invlog10_2_t>

inlineconstexpr

Callable object computing the constant \(1/\log_{10}2\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T invlog10_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::invlog10_2(as<T>()) returns the inverse of \(\log_{10}2\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_invlog10_2() { return eve::invlog10_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> invlog10_2(as<wide_ft>())       = " << eve::invlog10_2(eve::as<wide_ft>())            << std::endl
            << "-> invlog10_2(as(wxf))             = " << eve::invlog10_2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> invlog10_2(as<float>())         = " << eve::invlog10_2(eve::as(float())) << std::endl
            << "-> invlog10_2(as<xf))              = " << eve::invlog10_2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr invlog10_2            = " << constexpr_invlog10_2<float>() << std::endl;
 
  return 0;
}

invlog10_e

auto eve::invlog10_e = functor<invlog10_e_t>

inlineconstexpr

Callable object computing the constant \(1/\log_{10}e\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T invlog10_e(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::invlog10_e(as<T>()) returns the inverse of \(\log_{10}e\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_invlog10_e() { return eve::invlog10_e(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> invlog10_e(as<wide_ft>())                 = " << eve::invlog10_e(eve::as<wide_ft>())                << std::endl
            << "-> invlog10_e(as(wxf))                       = " << eve::invlog10_e(eve::as(wxf))                      << std::endl
            << "-> invlog10_e[upper](as<wide_ft>())         = " << eve::invlog10_e[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> invlog10_e[upper](as(wxf))               = " << eve::invlog10_e[eve::upper](eve::as(wxf))         << std::endl
            << "-> invlog10_e[lower](as<wide_ft>())       = " << eve::invlog10_e[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> invlog10_e[lower](as(wxf))             = " << eve::invlog10_e[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> invlog10_e(as<wide_dt>())           = " << eve::invlog10_e(eve::as<wide_dt>())                << std::endl
            << "-> invlog10_e(as(wxd))                 = " << eve::invlog10_e(eve::as(wxd))                      << std::endl
            << "-> invlog10_e[upper](as<wide_dt>())   = " << eve::invlog10_e[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> invlog10_e[upper](as(wxd))         = " << eve::invlog10_e[eve::upper](eve::as(wxd))         << std::endl
            << "-> invlog10_e[lower](as<wide_dt>()) = " << eve::invlog10_e[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> invlog10_e[lower](as(wxd))       = " << eve::invlog10_e[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> invlog10_e(as<float>())             = " << eve::invlog10_e(eve::as(float())) << std::endl
            << "-> invlog10_e(as<xf))                  = " << eve::invlog10_e(eve::as(xf))      << std::endl
            << "-> invlog10_e(as<double>())            = " << eve::invlog10_e(eve::as(double()))<< std::endl
            << "-> invlog10_e(as<xd))                  = " << eve::invlog10_e(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr invlog10_e            = " << constexpr_invlog10_e<float>() << std::endl;
 
  return 0;
}

invlog_10

auto eve::invlog_10 = functor<invlog_10_t>

inlineconstexpr

Callable object computing \(1/\log10\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T invlog_10(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::invlog_10(as<T>()) returns the inverse of \(\log10\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_invlog_10() { return eve::invlog_10(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> invlog_10(as<wide_ft>())       = " << eve::invlog_10(eve::as<wide_ft>())            << std::endl
            << "-> invlog_10(as(wxf))             = " << eve::invlog_10(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> invlog_10(as<float>())         = " << eve::invlog_10(eve::as(float())) << std::endl
            << "-> invlog_10(as<xf))              = " << eve::invlog_10(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr invlog_10            = " << constexpr_invlog_10<float>() << std::endl;
 
  return 0;
}

invlog_2

auto eve::invlog_2 = functor<invlog_2_t>

inlineconstexpr

Callable object computing the constant \(1/\log2\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T invlog_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::invlog_2(as<T>()) returns the inverse of \(\log2\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_invlog_2() { return eve::invlog_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> invlog_2(as<wide_ft>())       = " << eve::invlog_2(eve::as<wide_ft>())            << std::endl
            << "-> invlog_2(as(wxf))             = " << eve::invlog_2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> invlog_2(as<float>())         = " << eve::invlog_2(eve::as(float())) << std::endl
            << "-> invlog_2(as<xf))              = " << eve::invlog_2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr invlog_2            = " << constexpr_invlog_2<float>() << std::endl;
 
  return 0;
}

invlog_phi

auto eve::invlog_phi = functor<invlog_phi_t>

inlineconstexpr

Callable object computing the inverse of the logarithm of the golden ratio : \(1/\log((1+\sqrt5)/2)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T invlog_phi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::invlog_phi(as<T>()) returns the inverse of the logarithm of the golden ratio?

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_invlog_phi() { return eve::invlog_phi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> invlog_phi(as<wide_ft>())                 = " << eve::invlog_phi(eve::as<wide_ft>())                << std::endl
            << "-> invlog_phi(as(wxf))                       = " << eve::invlog_phi(eve::as(wxf))                      << std::endl
            << "-> invlog_phi[upper](as<wide_ft>())         = " << eve::invlog_phi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> invlog_phi[upper](as(wxf))               = " << eve::invlog_phi[eve::upper](eve::as(wxf))         << std::endl
            << "-> invlog_phi[lower](as<wide_ft>())       = " << eve::invlog_phi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> invlog_phi[lower](as(wxf))             = " << eve::invlog_phi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> invlog_phi(as<wide_dt>())           = " << eve::invlog_phi(eve::as<wide_dt>())                << std::endl
            << "-> invlog_phi(as(wxd))                 = " << eve::invlog_phi(eve::as(wxd))                      << std::endl
            << "-> invlog_phi[upper](as<wide_dt>())   = " << eve::invlog_phi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> invlog_phi[upper](as(wxd))         = " << eve::invlog_phi[eve::upper](eve::as(wxd))         << std::endl
            << "-> invlog_phi[lower](as<wide_dt>()) = " << eve::invlog_phi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> invlog_phi[lower](as(wxd))       = " << eve::invlog_phi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> invlog_phi(as<float>())             = " << eve::invlog_phi(eve::as(float())) << std::endl
            << "-> invlog_phi(as<xf))                  = " << eve::invlog_phi(eve::as(xf))      << std::endl
            << "-> invlog_phi(as<double>())            = " << eve::invlog_phi(eve::as(double()))<< std::endl
            << "-> invlog_phi(as<xd))                  = " << eve::invlog_phi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr invlog_phi            = " << constexpr_invlog_phi<float>() << std::endl;
 
  return 0;
}

invsqrt_2

auto eve::invsqrt_2 = functor<invsqrt_2_t>

inlineconstexpr

Callable object computing the constant \(2^{-1/2}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T invsqrt_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::invsqrt_2(as<T>()) returns the inverse of \(\sqrt{2}\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_invsqrt_2() { return eve::invsqrt_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> invsqrt_2(as<wide_ft>())       = " << eve::invsqrt_2(eve::as<wide_ft>())            << std::endl
            << "-> invsqrt_2(as(wxf))             = " << eve::invsqrt_2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> invsqrt_2(as<float>())         = " << eve::invsqrt_2(eve::as(float())) << std::endl
            << "-> invsqrt_2(as<xf))              = " << eve::invsqrt_2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr invsqrt_2            = " << constexpr_invsqrt_2<float>() << std::endl;
 
  return 0;
}

khinchin

auto eve::khinchin = functor<khinchin_t>

inlineconstexpr

Callable object computing the Khinchin constant.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T khinchin(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::khinchin(as<T>()) returns a value of type T with all bits set.

External references

• Wolfram MathWorld
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_khinchin() { return eve::khinchin(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> khinchin(as<wide_ft>())                 = " << eve::khinchin(eve::as<wide_ft>())                << std::endl
            << "-> khinchin(as(wxf))                       = " << eve::khinchin(eve::as(wxf))                      << std::endl
            << "-> khinchin[upper](as<wide_ft>())         = " << eve::khinchin[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> khinchin[upper](as(wxf))               = " << eve::khinchin[eve::upper](eve::as(wxf))         << std::endl
            << "-> khinchin[lower](as<wide_ft>())       = " << eve::khinchin[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> khinchin[lower](as(wxf))             = " << eve::khinchin[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> khinchin(as<wide_dt>())           = " << eve::khinchin(eve::as<wide_dt>())                << std::endl
            << "-> khinchin(as(wxd))                 = " << eve::khinchin(eve::as(wxd))                      << std::endl
            << "-> khinchin[upper](as<wide_dt>())   = " << eve::khinchin[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> khinchin[upper](as(wxd))         = " << eve::khinchin[eve::upper](eve::as(wxd))         << std::endl
            << "-> khinchin[lower](as<wide_dt>()) = " << eve::khinchin[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> khinchin[lower](as(wxd))       = " << eve::khinchin[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> khinchin(as<float>())             = " << eve::khinchin(eve::as(float())) << std::endl
            << "-> khinchin(as<xf))                  = " << eve::khinchin(eve::as(xf))      << std::endl
            << "-> khinchin(as<double>())            = " << eve::khinchin(eve::as(double()))<< std::endl
            << "-> khinchin(as<xd))                  = " << eve::khinchin(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr khinchin            = " << constexpr_khinchin<float>() << std::endl;
 
  return 0;
}

log10_e

auto eve::log10_e = functor<log10_e_t>

inlineconstexpr

Callable object computing the constant \(\log_{10}e\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T log10_e(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::log10_e(as<T>()) returns \(\log_{10}e\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_log10_e() { return eve::log10_e(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> log10_e(as<wide_ft>())       = " << eve::log10_e(eve::as<wide_ft>())            << std::endl
            << "-> log10_e(as(wxf))             = " << eve::log10_e(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> log10_e(as<float>())         = " << eve::log10_e(eve::as(float())) << std::endl
            << "-> log10_e(as<xf))              = " << eve::log10_e(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr log10_e            = " << constexpr_log10_e<float>() << std::endl;
 
  return 0;
}

log2_e

auto eve::log2_e = functor<log2_e_t>

inlineconstexpr

Callable object computing the constant \(\log_2 e\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T log2_e(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::log2_e(as<T>()) returns \(\log_2 e\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_log2_e() { return eve::log2_e(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> log2_e(as<wide_ft>())       = " << eve::log2_e(eve::as<wide_ft>())            << std::endl
            << "-> log2_e(as(wxf))             = " << eve::log2_e(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> log2_e(as<float>())         = " << eve::log2_e(eve::as(float())) << std::endl
            << "-> log2_e(as<xf))              = " << eve::log2_e(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr log2_e            = " << constexpr_log2_e<float>() << std::endl;
 
  return 0;
}

log_10

auto eve::log_10 = functor<log_10_t>

inlineconstexpr

Callable object computing the constant \(\log 10\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T log_10(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::log_10(as<T>()) returns \(\log 10\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_log_10() { return eve::log_10(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> log_10(as<wide_ft>())       = " << eve::log_10(eve::as<wide_ft>())            << std::endl
            << "-> log_10(as(wxf))             = " << eve::log_10(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> log_10(as<float>())         = " << eve::log_10(eve::as(float())) << std::endl
            << "-> log_10(as<xf))              = " << eve::log_10(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr log_10            = " << constexpr_log_10<float>() << std::endl;
 
  return 0;
}

log_2

auto eve::log_2 = functor<log_2_t>

inlineconstexpr

Callable object computing the constant \(\log 2\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T log_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::log_2(as<T>()) returns \(\log 2\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_log_2() { return eve::log_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> log2_e(as<wide_ft>())       = " << eve::log2_e(eve::as<wide_ft>())            << std::endl
            << "-> log2_e(as(wxf))             = " << eve::log2_e(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> log2_e(as<float>())         = " << eve::log2_e(eve::as(float())) << std::endl
            << "-> log2_e(as<xf))              = " << eve::log2_e(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr log_2            = " << constexpr_log_2<float>() << std::endl;
 
  return 0;
}

log_phi

auto eve::log_phi = functor<log_phi_t>

inlineconstexpr

Callable object computing the logarithm of the golden ratio : \(\log((1+\sqrt5)/2)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T log_phi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::log_phi(as<T>()) returns the logarithm of the golden ratio.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_log_phi() { return eve::log_phi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> log_phi(as<wide_ft>())                 = " << eve::log_phi(eve::as<wide_ft>())                << std::endl
            << "-> log_phi(as(wxf))                       = " << eve::log_phi(eve::as(wxf))                      << std::endl
            << "-> log_phi[upper](as<wide_ft>())         = " << eve::log_phi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> log_phi[upper](as(wxf))               = " << eve::log_phi[eve::upper](eve::as(wxf))         << std::endl
            << "-> log_phi[lower](as<wide_ft>())       = " << eve::log_phi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> log_phi[lower](as(wxf))             = " << eve::log_phi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> log_phi(as<wide_dt>())           = " << eve::log_phi(eve::as<wide_dt>())                << std::endl
            << "-> log_phi(as(wxd))                 = " << eve::log_phi(eve::as(wxd))                      << std::endl
            << "-> log_phi[upper](as<wide_dt>())   = " << eve::log_phi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> log_phi[upper](as(wxd))         = " << eve::log_phi[eve::upper](eve::as(wxd))         << std::endl
            << "-> log_phi[lower](as<wide_dt>()) = " << eve::log_phi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> log_phi[lower](as(wxd))       = " << eve::log_phi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> log_phi(as<float>())             = " << eve::log_phi(eve::as(float())) << std::endl
            << "-> log_phi(as<xf))                  = " << eve::log_phi(eve::as(xf))      << std::endl
            << "-> log_phi(as<double>())            = " << eve::log_phi(eve::as(double()))<< std::endl
            << "-> log_phi(as<xd))                  = " << eve::log_phi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr log_phi            = " << constexpr_log_phi<float>() << std::endl;
 
  return 0;
}

loglog_2

auto eve::loglog_2 = functor<loglog_2_t>

inlineconstexpr

Callable object computing the constant \(\log(\log2)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T loglog_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::loglog_2(as<T>()) returns the logarithm of the logarithm of 2.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_loglog_2() { return eve::loglog_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> loglog_2(as<wide_ft>())                 = " << eve::loglog_2(eve::as<wide_ft>())                << std::endl
            << "-> loglog_2(as(wxf))                       = " << eve::loglog_2(eve::as(wxf))                      << std::endl
            << "-> loglog_2[upper](as<wide_ft>())         = " << eve::loglog_2[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> loglog_2[upper](as(wxf))               = " << eve::loglog_2[eve::upper](eve::as(wxf))         << std::endl
            << "-> loglog_2[lower](as<wide_ft>())       = " << eve::loglog_2[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> loglog_2[lower](as(wxf))             = " << eve::loglog_2[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> loglog_2(as<wide_dt>())           = " << eve::loglog_2(eve::as<wide_dt>())                << std::endl
            << "-> loglog_2(as(wxd))                 = " << eve::loglog_2(eve::as(wxd))                      << std::endl
            << "-> loglog_2[upper](as<wide_dt>())   = " << eve::loglog_2[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> loglog_2[upper](as(wxd))         = " << eve::loglog_2[eve::upper](eve::as(wxd))         << std::endl
            << "-> loglog_2[lower](as<wide_dt>()) = " << eve::loglog_2[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> loglog_2[lower](as(wxd))       = " << eve::loglog_2[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> loglog_2(as<float>())             = " << eve::loglog_2(eve::as(float())) << std::endl
            << "-> loglog_2(as<xf))                  = " << eve::loglog_2(eve::as(xf))      << std::endl
            << "-> loglog_2(as<double>())            = " << eve::loglog_2(eve::as(double()))<< std::endl
            << "-> loglog_2(as<xd))                  = " << eve::loglog_2(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr loglog_2            = " << constexpr_loglog_2<float>() << std::endl;
 
  return 0;
}

maxlog

auto eve::maxlog = functor<maxlog_t>

inlineconstexpr

Callable object computing the greatest positive value for which eve::exp is finite.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T maxlog(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::maxlog(as<T>()) returns the greatest positive value for which eve::exp is finite.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_maxlog() { return eve::maxlog(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> maxlog(as<wide_ft>())        = " << eve::maxlog(eve::as<wide_ft>())            << std::endl
            << "-> maxlog(as(wxf))              = " << eve::maxlog(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> maxlog(as<float>())         = " << eve::maxlog(eve::as(float())) << std::endl
            << "-> maxlog(as<xf))              = " << eve::maxlog(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr maxlog            = " << constexpr_maxlog<float>() << std::endl;
 
  return 0;
}

maxlog10

auto eve::maxlog10 = functor<maxlog10_t>

inlineconstexpr

Callable object computing the greatest positive value for which eve::exp10 is finite.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T maxlog10(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::maxlog10(as<T>()) returns the greatest positive value for which eve::exp10 is finite.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_maxlog10() { return eve::maxlog10(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> maxlog10(as<wide_ft>())        = " << eve::maxlog10(eve::as<wide_ft>())            << std::endl
            << "-> maxlog10(as(wxf))              = " << eve::maxlog10(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> maxlog10(as<float>())         = " << eve::maxlog10(eve::as(float())) << std::endl
            << "-> maxlog10(as<xf))              = " << eve::maxlog10(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr maxlog10            = " << constexpr_maxlog10<float>() << std::endl;
 
  return 0;
}

maxlog2

auto eve::maxlog2 = functor<maxlog2_t>

inlineconstexpr

Callable object computing the greatest positive value for which eve::exp2 is finite.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T maxlog2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::maxlog2(as<T>()) returns the greatest positive value for which eve::exp2 is finite.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_maxlog2() { return eve::maxlog2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> maxlog2(as<wide_ft>())        = " << eve::maxlog2(eve::as<wide_ft>())            << std::endl
            << "-> maxlog2(as(wxf))              = " << eve::maxlog2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> maxlog2(as<float>())         = " << eve::maxlog2(eve::as(float())) << std::endl
            << "-> maxlog2(as<xf))              = " << eve::maxlog2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr maxlog2            = " << constexpr_maxlog2<float>() << std::endl;
 
  return 0;
}

minlog

auto eve::minlog = functor<minlog_t>

inlineconstexpr

Callable object computing the least value for which eve::exp is normal and not zero.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T minlog(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::minlog(as<T>()) returns the least value for which eve::exp is normal and not zero.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_minlog() { return eve::minlog(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> minlog(as<wide_ft>())        = " << eve::minlog(eve::as<wide_ft>())            << std::endl
            << "-> minlog(as(wxf))              = " << eve::minlog(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> minlog(as<float>())         = " << eve::minlog(eve::as(float())) << std::endl
            << "-> minlog(as<xf))              = " << eve::minlog(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr minlog            = " << constexpr_minlog<float>() << std::endl;
 
  return 0;
}

minlog10

auto eve::minlog10 = functor<minlog10_t>

inlineconstexpr

Callable object computing the least value for which eve::exp10 is normal and not zero.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T minlog10(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::minlog10(as<T>()) returns the least value for which eve::exp10 is normal and not zero.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_minlog10() { return eve::minlog10(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> minlog10(as<wide_ft>())        = " << eve::minlog10(eve::as<wide_ft>())            << std::endl
            << "-> minlog10(as(wxf))              = " << eve::minlog10(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> minlog10(as<float>())         = " << eve::minlog10(eve::as(float())) << std::endl
            << "-> minlog10(as<xf))              = " << eve::minlog10(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr minlog10            = " << constexpr_minlog10<float>() << std::endl;
 
  return 0;
}

minlog10denormal

auto eve::minlog10denormal = functor<minlog10denormal_t>

inlineconstexpr

Callable object computing the least value for which eve::exp10 is denormal and not zero.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T minlog10denormal(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::minlog10denormal(as<T>()) returns the least value for which eve::exp10 is denormal and not zero.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_minlog10denormal() { return eve::minlog10denormal(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> minlog10denormal(as<wide_ft>())        = " << eve::minlog10denormal(eve::as<wide_ft>())            << std::endl
            << "-> minlog10denormal(as(wxf))              = " << eve::minlog10denormal(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> minlog10denormal(as<float>())         = " << eve::minlog10denormal(eve::as(float())) << std::endl
            << "-> minlog10denormal(as<xf))              = " << eve::minlog10denormal(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr minlog10denormal            = " << constexpr_minlog10denormal<float>() << std::endl;
 
  return 0;
}

minlog2

auto eve::minlog2 = functor<minlog2_t>

inlineconstexpr

Callable object computing the least value for which eve::exp2 is normal and not zero.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T minlog2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::minlog2(as<T>()) returns the least value for which eve::exp2 is normal and not zero.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_minlog2() { return eve::minlog2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> minlog2(as<wide_ft>())        = " << eve::minlog2(eve::as<wide_ft>())            << std::endl
            << "-> minlog2(as(wxf))              = " << eve::minlog2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> minlog2(as<float>())         = " << eve::minlog2(eve::as(float())) << std::endl
            << "-> minlog2(as<xf))              = " << eve::minlog2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr minlog2            = " << constexpr_minlog2<float>() << std::endl;
 
  return 0;
}

minlog2denormal

auto eve::minlog2denormal = functor<minlog2denormal_t>

inlineconstexpr

Callable object computing the least value for which eve::exp2 is denormal and not zero.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T minlog2denormal(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::minlog2denormal(as<T>()) returns the least value for which eve::exp2 is denormal and not zero.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_minlog2denormal() { return eve::minlog2denormal(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> minlog2denormal(as<wide_ft>())        = " << eve::minlog2denormal(eve::as<wide_ft>())            << std::endl
            << "-> minlog2denormal(as(wxf))              = " << eve::minlog2denormal(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> minlog2denormal(as<float>())         = " << eve::minlog2denormal(eve::as(float())) << std::endl
            << "-> minlog2denormal(as<xf))              = " << eve::minlog2denormal(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr minlog2denormal            = " << constexpr_minlog2denormal<float>() << std::endl;
 
  return 0;
}

minlogdenormal

auto eve::minlogdenormal = functor<minlogdenormal_t>

inlineconstexpr

Callable object computing the least value for which eve::exp is denormal and not zero.

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T minlogdenormal(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::minlogdenormal(as<T>()) returns the least value for which eve::exp is denormal and not zero.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_minlogdenormal() { return eve::minlogdenormal(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> minlogdenormal(as<wide_ft>())        = " << eve::minlogdenormal(eve::as<wide_ft>())            << std::endl
            << "-> minlogdenormal(as(wxf))              = " << eve::minlogdenormal(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> minlogdenormal(as<float>())         = " << eve::minlogdenormal(eve::as(float())) << std::endl
            << "-> minlogdenormal(as<xf))              = " << eve::minlogdenormal(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr minlogdenormal            = " << constexpr_minlogdenormal<float>() << std::endl;
 
  return 0;
}

phi

auto eve::phi = functor<phi_t>

inlineconstexpr

Callable object computing the golden ratio : \(\frac{1+\sqrt5}2\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T phi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::phi(as<T>()) returns the golden ratio.

External references

• Wolfram MathWorld
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_phi() { return eve::phi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> phi(as<wide_ft>())       = " << eve::phi(eve::as<wide_ft>())            << std::endl
            << "-> phi(as(wxf))             = " << eve::phi(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> phi(as<float>())         = " << eve::phi(eve::as(float())) << std::endl
            << "-> phi(as<xf))              = " << eve::phi(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr phi            = " << constexpr_phi<float>() << std::endl;
 
  return 0;
}

pi

auto eve::pi = functor<pi_t>

inlineconstexpr

Callable object computing the constant \(\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pi(as<T>()) returns the constant \(\pi\). π is an alias.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_pi() { return eve::pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pi(as<wide_ft>())        = " << eve::pi(eve::as<wide_ft>())            << std::endl
            << "-> pi(as(wxf))              = " << eve::pi(eve::as(wxf))                  << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pi(as<float>())         = " << eve::pi(eve::as(float())) << std::endl
            << "-> pi(as(xf))              = " << eve::pi(eve::as(xf))      << std::endl
            << "-> pi(as(xd))              = " << eve::pi(eve::as(xd))      << std::endl;
 
  std::cout << "---- unicode alias" << std::endl
            << "-> \u03c0(as(xd))               = " << eve::π(eve::as(xd))       << std::endl;
 
  std::cout << "-> constexpr pi            = " << constexpr_pi<float>() << std::endl;
 
  return 0;
}

pi2

auto eve::pi2 = functor<pi2_t>

inlineconstexpr

Callable object computing the square of \(\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pi2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pi2(as<T>()) returns the square of \(\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pi2() { return eve::pi2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pi2(as<wide_ft>())                 = " << eve::pi2(eve::as<wide_ft>())                << std::endl
            << "-> pi2(as(wxf))                       = " << eve::pi2(eve::as(wxf))                      << std::endl
            << "-> pi2[upper](as<wide_ft>())         = " << eve::pi2[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pi2[upper](as(wxf))               = " << eve::pi2[eve::upper](eve::as(wxf))         << std::endl
            << "-> pi2[lower](as<wide_ft>())       = " << eve::pi2[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pi2[lower](as(wxf))             = " << eve::pi2[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pi2(as<wide_dt>())           = " << eve::pi2(eve::as<wide_dt>())                << std::endl
            << "-> pi2(as(wxd))                 = " << eve::pi2(eve::as(wxd))                      << std::endl
            << "-> pi2[upper](as<wide_dt>())   = " << eve::pi2[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pi2[upper](as(wxd))         = " << eve::pi2[eve::upper](eve::as(wxd))         << std::endl
            << "-> pi2[lower](as<wide_dt>()) = " << eve::pi2[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pi2[lower](as(wxd))       = " << eve::pi2[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pi2(as<float>())             = " << eve::pi2(eve::as(float())) << std::endl
            << "-> pi2(as<xf))                  = " << eve::pi2(eve::as(xf))      << std::endl
            << "-> pi2(as<double>())            = " << eve::pi2(eve::as(double()))<< std::endl
            << "-> pi2(as<xd))                  = " << eve::pi2(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pi2            = " << constexpr_pi2<float>() << std::endl;
 
  return 0;
}

pi2o_16

auto eve::pi2o_16 = functor<pi2o_16_t>

inlineconstexpr

Callable object computing the constant \(\pi^2/16\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pi2o_16(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pi2o_16(as<T>()) returns \(\pi^2/16\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pi2o_16() { return eve::pi2o_16(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pi2o_16(as<wide_ft>())                 = " << eve::pi2o_16(eve::as<wide_ft>())                << std::endl
            << "-> pi2o_16(as(wxf))                       = " << eve::pi2o_16(eve::as(wxf))                      << std::endl
            << "-> pi2o_16[upper](as<wide_ft>())         = " << eve::pi2o_16[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pi2o_16[upper](as(wxf))               = " << eve::pi2o_16[eve::upper](eve::as(wxf))         << std::endl
            << "-> pi2o_16[lower](as<wide_ft>())       = " << eve::pi2o_16[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pi2o_16[lower](as(wxf))             = " << eve::pi2o_16[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pi2o_16(as<wide_dt>())           = " << eve::pi2o_16(eve::as<wide_dt>())                << std::endl
            << "-> pi2o_16(as(wxd))                 = " << eve::pi2o_16(eve::as(wxd))                      << std::endl
            << "-> pi2o_16[upper](as<wide_dt>())   = " << eve::pi2o_16[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pi2o_16[upper](as(wxd))         = " << eve::pi2o_16[eve::upper](eve::as(wxd))         << std::endl
            << "-> pi2o_16[lower](as<wide_dt>()) = " << eve::pi2o_16[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pi2o_16[lower](as(wxd))       = " << eve::pi2o_16[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pi2o_16(as<float>())             = " << eve::pi2o_16(eve::as(float())) << std::endl
            << "-> pi2o_16(as<xf))                  = " << eve::pi2o_16(eve::as(xf))      << std::endl
            << "-> pi2o_16(as<double>())            = " << eve::pi2o_16(eve::as(double()))<< std::endl
            << "-> pi2o_16(as<xd))                  = " << eve::pi2o_16(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pi2o_16            = " << constexpr_pi2o_16<float>() << std::endl;
 
  return 0;
}

pi2o_6

auto eve::pi2o_6 = functor<pi2o_6_t>

inlineconstexpr

Callable object computing the constant \(\pi^2/6\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pi2o_6(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pi2o_6(as<T>()) returns \(\pi^2/6\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pi2o_6() { return eve::pi2o_6(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pi2o_6(as<wide_ft>())                 = " << eve::pi2o_6(eve::as<wide_ft>())                << std::endl
            << "-> pi2o_6(as(wxf))                       = " << eve::pi2o_6(eve::as(wxf))                      << std::endl
            << "-> pi2o_6[upper](as<wide_ft>())         = " << eve::pi2o_6[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pi2o_6[upper](as(wxf))               = " << eve::pi2o_6[eve::upper](eve::as(wxf))         << std::endl
            << "-> pi2o_6[lower](as<wide_ft>())       = " << eve::pi2o_6[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pi2o_6[lower](as(wxf))             = " << eve::pi2o_6[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pi2o_6(as<wide_dt>())           = " << eve::pi2o_6(eve::as<wide_dt>())                << std::endl
            << "-> pi2o_6(as(wxd))                 = " << eve::pi2o_6(eve::as(wxd))                      << std::endl
            << "-> pi2o_6[upper](as<wide_dt>())   = " << eve::pi2o_6[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pi2o_6[upper](as(wxd))         = " << eve::pi2o_6[eve::upper](eve::as(wxd))         << std::endl
            << "-> pi2o_6[lower](as<wide_dt>()) = " << eve::pi2o_6[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pi2o_6[lower](as(wxd))       = " << eve::pi2o_6[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pi2o_6(as<float>())             = " << eve::pi2o_6(eve::as(float())) << std::endl
            << "-> pi2o_6(as<xf))                  = " << eve::pi2o_6(eve::as(xf))      << std::endl
            << "-> pi2o_6(as<double>())            = " << eve::pi2o_6(eve::as(double()))<< std::endl
            << "-> pi2o_6(as<xd))                  = " << eve::pi2o_6(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pi2o_6            = " << constexpr_pi2o_6<float>() << std::endl;
 
  return 0;
}

pi3

auto eve::pi3 = functor<pi3_t>

inlineconstexpr

Callable object computing the pi cubed value : \(\pi^3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pi3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pi3(as<T>()) returns \(\pi^3\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pi3() { return eve::pi3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pi3(as<wide_ft>())                 = " << eve::pi3(eve::as<wide_ft>())                << std::endl
            << "-> pi3(as(wxf))                       = " << eve::pi3(eve::as(wxf))                      << std::endl
            << "-> pi3[upper](as<wide_ft>())         = " << eve::pi3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pi3[upper](as(wxf))               = " << eve::pi3[eve::upper](eve::as(wxf))         << std::endl
            << "-> pi3[lower](as<wide_ft>())       = " << eve::pi3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pi3[lower](as(wxf))             = " << eve::pi3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pi3(as<wide_dt>())           = " << eve::pi3(eve::as<wide_dt>())                << std::endl
            << "-> pi3(as(wxd))                 = " << eve::pi3(eve::as(wxd))                      << std::endl
            << "-> pi3[upper](as<wide_dt>())   = " << eve::pi3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pi3[upper](as(wxd))         = " << eve::pi3[eve::upper](eve::as(wxd))         << std::endl
            << "-> pi3[lower](as<wide_dt>()) = " << eve::pi3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pi3[lower](as(wxd))       = " << eve::pi3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pi3(as<float>())             = " << eve::pi3(eve::as(float())) << std::endl
            << "-> pi3(as<xf))                  = " << eve::pi3(eve::as(xf))      << std::endl
            << "-> pi3(as<double>())            = " << eve::pi3(eve::as(double()))<< std::endl
            << "-> pi3(as<xd))                  = " << eve::pi3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pi3            = " << constexpr_pi3<float>() << std::endl;
 
  return 0;
}

pi_minus_3

auto eve::pi_minus_3 = functor<pi_minus_3_t>

inlineconstexpr

Callable object computing the constant \(\pi-3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pi_minus_3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pi_minus_3(as<T>()) returns \(\pi-3\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pi_minus_3() { return eve::pi_minus_3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pi_minus_3(as<wide_ft>())                 = " << eve::pi_minus_3(eve::as<wide_ft>())                << std::endl
            << "-> pi_minus_3(as(wxf))                       = " << eve::pi_minus_3(eve::as(wxf))                      << std::endl
            << "-> pi_minus_3[upper](as<wide_ft>())         = " << eve::pi_minus_3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pi_minus_3[upper](as(wxf))               = " << eve::pi_minus_3[eve::upper](eve::as(wxf))         << std::endl
            << "-> pi_minus_3[lower](as<wide_ft>())       = " << eve::pi_minus_3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pi_minus_3[lower](as(wxf))             = " << eve::pi_minus_3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pi_minus_3(as<wide_dt>())           = " << eve::pi_minus_3(eve::as<wide_dt>())                << std::endl
            << "-> pi_minus_3(as(wxd))                 = " << eve::pi_minus_3(eve::as(wxd))                      << std::endl
            << "-> pi_minus_3[upper](as<wide_dt>())   = " << eve::pi_minus_3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pi_minus_3[upper](as(wxd))         = " << eve::pi_minus_3[eve::upper](eve::as(wxd))         << std::endl
            << "-> pi_minus_3[lower](as<wide_dt>()) = " << eve::pi_minus_3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pi_minus_3[lower](as(wxd))       = " << eve::pi_minus_3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pi_minus_3(as<float>())             = " << eve::pi_minus_3(eve::as(float())) << std::endl
            << "-> pi_minus_3(as<xf))                  = " << eve::pi_minus_3(eve::as(xf))      << std::endl
            << "-> pi_minus_3(as<double>())            = " << eve::pi_minus_3(eve::as(double()))<< std::endl
            << "-> pi_minus_3(as<xd))                  = " << eve::pi_minus_3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pi_minus_3            = " << constexpr_pi_minus_3<float>() << std::endl;
 
  return 0;
}

pi_pow_e

auto eve::pi_pow_e = functor<pi_pow_e_t>

inlineconstexpr

Callable object computing the constant \(\pi^e\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pi_pow_e(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pi_pow_e(as<T>()) returns \(\pi^e\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pi_pow_e() { return eve::pi_pow_e(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pi_pow_e(as<wide_ft>())                 = " << eve::pi_pow_e(eve::as<wide_ft>())                << std::endl
            << "-> pi_pow_e(as(wxf))                       = " << eve::pi_pow_e(eve::as(wxf))                      << std::endl
            << "-> pi_pow_e[upper](as<wide_ft>())         = " << eve::pi_pow_e[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pi_pow_e[upper](as(wxf))               = " << eve::pi_pow_e[eve::upper](eve::as(wxf))         << std::endl
            << "-> pi_pow_e[lower](as<wide_ft>())       = " << eve::pi_pow_e[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pi_pow_e[lower](as(wxf))             = " << eve::pi_pow_e[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pi_pow_e(as<wide_dt>())           = " << eve::pi_pow_e(eve::as<wide_dt>())                << std::endl
            << "-> pi_pow_e(as(wxd))                 = " << eve::pi_pow_e(eve::as(wxd))                      << std::endl
            << "-> pi_pow_e[upper](as<wide_dt>())   = " << eve::pi_pow_e[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pi_pow_e[upper](as(wxd))         = " << eve::pi_pow_e[eve::upper](eve::as(wxd))         << std::endl
            << "-> pi_pow_e[lower](as<wide_dt>()) = " << eve::pi_pow_e[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pi_pow_e[lower](as(wxd))       = " << eve::pi_pow_e[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pi_pow_e(as<float>())             = " << eve::pi_pow_e(eve::as(float())) << std::endl
            << "-> pi_pow_e(as<xf))                  = " << eve::pi_pow_e(eve::as(xf))      << std::endl
            << "-> pi_pow_e(as<double>())            = " << eve::pi_pow_e(eve::as(double()))<< std::endl
            << "-> pi_pow_e(as<xd))                  = " << eve::pi_pow_e(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pi_pow_e            = " << constexpr_pi_pow_e<float>() << std::endl;
 
  return 0;
}

pio_2

auto eve::pio_2 = functor<pio_2_t>

inlineconstexpr

Callable object computing the constant \(\pi/2\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pio_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pio_2(as<T>()) returns \(\pi/2\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_pio_2() { return eve::pio_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pio_2(as<wide_ft>())        = " << eve::pio_2(eve::as<wide_ft>())            << std::endl
            << "-> pio_2(as(wxf))              = " << eve::pio_2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> pio_2(as<float>())         = " << eve::pio_2(eve::as(float())) << std::endl
            << "-> pio_2(as<xf))              = " << eve::pio_2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr pio_2            = " << constexpr_pio_2<float>() << std::endl;
 
  return 0;
}

pio_3

auto eve::pio_3 = functor<pio_3_t>

inlineconstexpr

Callable object computing the constant \(\pi/3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pio_3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pio_3(as<T>()) returns \(\pi/3\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pio_3() { return eve::pio_3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pio_3(as<wide_ft>())                 = " << eve::pio_3(eve::as<wide_ft>())                << std::endl
            << "-> pio_3(as(wxf))                       = " << eve::pio_3(eve::as(wxf))                      << std::endl
            << "-> pio_3[upper](as<wide_ft>())         = " << eve::pio_3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pio_3[upper](as(wxf))               = " << eve::pio_3[eve::upper](eve::as(wxf))         << std::endl
            << "-> pio_3[lower](as<wide_ft>())       = " << eve::pio_3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pio_3[lower](as(wxf))             = " << eve::pio_3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pio_3(as<wide_dt>())           = " << eve::pio_3(eve::as<wide_dt>())                << std::endl
            << "-> pio_3(as(wxd))                 = " << eve::pio_3(eve::as(wxd))                      << std::endl
            << "-> pio_3[upper](as<wide_dt>())   = " << eve::pio_3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pio_3[upper](as(wxd))         = " << eve::pio_3[eve::upper](eve::as(wxd))         << std::endl
            << "-> pio_3[lower](as<wide_dt>()) = " << eve::pio_3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pio_3[lower](as(wxd))       = " << eve::pio_3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pio_3(as<float>())             = " << eve::pio_3(eve::as(float())) << std::endl
            << "-> pio_3(as<xf))                  = " << eve::pio_3(eve::as(xf))      << std::endl
            << "-> pio_3(as<double>())            = " << eve::pio_3(eve::as(double()))<< std::endl
            << "-> pio_3(as<xd))                  = " << eve::pio_3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pio_3            = " << constexpr_pio_3<float>() << std::endl;
 
  return 0;
}

pio_4

auto eve::pio_4 = functor<pio_4_t>

inlineconstexpr

Callable object computing the constant \(\pi/4\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pio_4(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pio_4(as<T>()) returns \(\pi/4\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_pio_4() { return eve::pio_4(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pio_4(as<wide_ft>())        = " << eve::pio_4(eve::as<wide_ft>())            << std::endl
            << "-> pio_4(as(wxf))              = " << eve::pio_4(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> pio_4(as<float>())         = " << eve::pio_4(eve::as(float())) << std::endl
            << "-> pio_4(as<xf))              = " << eve::pio_4(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr pio_4            = " << constexpr_pio_4<float>() << std::endl;
 
  return 0;
}

pio_6

auto eve::pio_6 = functor<pio_6_t>

inlineconstexpr

Callable object computing the constant \(\pi/6\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T pio_6(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::pio_6(as<T>()) returns \(\pi/6\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_pio_6() { return eve::pio_6(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> pio_6(as<wide_ft>())                 = " << eve::pio_6(eve::as<wide_ft>())                << std::endl
            << "-> pio_6(as(wxf))                       = " << eve::pio_6(eve::as(wxf))                      << std::endl
            << "-> pio_6[upper](as<wide_ft>())         = " << eve::pio_6[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> pio_6[upper](as(wxf))               = " << eve::pio_6[eve::upper](eve::as(wxf))         << std::endl
            << "-> pio_6[lower](as<wide_ft>())       = " << eve::pio_6[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> pio_6[lower](as(wxf))             = " << eve::pio_6[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> pio_6(as<wide_dt>())           = " << eve::pio_6(eve::as<wide_dt>())                << std::endl
            << "-> pio_6(as(wxd))                 = " << eve::pio_6(eve::as(wxd))                      << std::endl
            << "-> pio_6[upper](as<wide_dt>())   = " << eve::pio_6[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> pio_6[upper](as(wxd))         = " << eve::pio_6[eve::upper](eve::as(wxd))         << std::endl
            << "-> pio_6[lower](as<wide_dt>()) = " << eve::pio_6[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> pio_6[lower](as(wxd))       = " << eve::pio_6[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> pio_6(as<float>())             = " << eve::pio_6(eve::as(float())) << std::endl
            << "-> pio_6(as<xf))                  = " << eve::pio_6(eve::as(xf))      << std::endl
            << "-> pio_6(as<double>())            = " << eve::pio_6(eve::as(double()))<< std::endl
            << "-> pio_6(as<xd))                  = " << eve::pio_6(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr pio_6            = " << constexpr_pio_6<float>() << std::endl;
 
  return 0;
}

quarter

auto eve::quarter = functor<quarter_t>

inlineconstexpr

Callable object computing the constant \(1/4\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T quarter(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::quarter(as<T>()) returns one quarter.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_quarter() { return eve::quarter(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> quarter(as<wide_ft>())                 = " << eve::quarter(eve::as<wide_ft>())                << std::endl
            << "-> quarter(as(wxf))                       = " << eve::quarter(eve::as(wxf))                      << std::endl
            << "-> quarter[upper](as<wide_ft>())         = " << eve::quarter[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> quarter[upper](as(wxf))               = " << eve::quarter[eve::upper](eve::as(wxf))         << std::endl
            << "-> quarter[lower](as<wide_ft>())       = " << eve::quarter[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> quarter[lower](as(wxf))             = " << eve::quarter[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> quarter(as<wide_dt>())           = " << eve::quarter(eve::as<wide_dt>())                << std::endl
            << "-> quarter(as(wxd))                 = " << eve::quarter(eve::as(wxd))                      << std::endl
            << "-> quarter[upper](as<wide_dt>())   = " << eve::quarter[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> quarter[upper](as(wxd))         = " << eve::quarter[eve::upper](eve::as(wxd))         << std::endl
            << "-> quarter[lower](as<wide_dt>()) = " << eve::quarter[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> quarter[lower](as(wxd))       = " << eve::quarter[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> quarter(as<float>())             = " << eve::quarter(eve::as(float())) << std::endl
            << "-> quarter(as<xf))                  = " << eve::quarter(eve::as(xf))      << std::endl
            << "-> quarter(as<double>())            = " << eve::quarter(eve::as(double()))<< std::endl
            << "-> quarter(as<xd))                  = " << eve::quarter(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr quarter            = " << constexpr_quarter<float>() << std::endl;
 
  return 0;
}

rayleigh_kurtosis

auto eve::rayleigh_kurtosis = functor<rayleigh_kurtosis_t>

inlineconstexpr

Callable object computing the Rayleigh kurtosis value : \(3+(6\pi^2-24\pi+16)/(4-\pi^2)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T rayleigh_kurtosis(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::rayleigh_kurtosis(as<T>()) returns the Rayleigh kurtosis value.

Example

// revision 0
#include <eve/module/math.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  using wf_t = eve::wide<float>;
  using wd_t = eve::wide<double>;
 
  std::cout << std::setprecision(9);
  std::cout << "-> rayleigh_kurtosis(as<float>())          = " << eve::rayleigh_kurtosis(eve::as<float>())          << "\n";
  std::cout << "-> rayleigh_kurtosis(as<wf_t>())           = " << eve::rayleigh_kurtosis(eve::as<wf_t>())           << "\n";
  std::cout << "-> rayleigh_kurtosis[lower](as<wf_t>())    = " << eve::rayleigh_kurtosis[eve::lower](eve::as<wf_t>()) << "\n";
  std::cout << "-> rayleigh_kurtosis[upper](as<wf_t>())    = " << eve::rayleigh_kurtosis[eve::upper](eve::as<wf_t>()) << "\n";
 
  std::cout << std::setprecision(17);
  std::cout << "-> rayleigh_kurtosis(as<double>())         = " << eve::rayleigh_kurtosis(eve::as<double>())         << "\n";
  std::cout << "-> rayleigh_kurtosis(as<wd_t>())           = " << eve::rayleigh_kurtosis(eve::as<wd_t>())           << "\n";
  std::cout << "-> rayleigh_kurtosis[lower](as<wd_t>())    = " << eve::rayleigh_kurtosis[eve::lower](eve::as<wd_t>()) << "\n";
  std::cout << "-> rayleigh_kurtosis[upper](as<wd_t>())    = " << eve::rayleigh_kurtosis[eve::upper](eve::as<wd_t>()) << "\n";
}

rayleigh_kurtosis_excess

auto eve::rayleigh_kurtosis_excess = functor<rayleigh_kurtosis_excess_t>

inlineconstexpr

Callable object computing the Rayleigh kurtosis excess value : \(-(6\pi^2-24\pi+16)/(4-\pi^2)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T rayleigh_kurtosis_excess(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::rayleigh_kurtosis_excess(as<T>()) returns the Rayleigh kurtosis excess value?

Example

// revision 0
#include <eve/module/math.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  using wf_t = eve::wide<float>;
  using wd_t = eve::wide<double>;
 
  std::cout << std::setprecision(9);
  std::cout << "-> rayleigh_kurtosis_excess(as<float>())          = " << eve::rayleigh_kurtosis_excess(eve::as<float>())          << "\n";
  std::cout << "-> rayleigh_kurtosis_excess(as<wf_t>())           = " << eve::rayleigh_kurtosis_excess(eve::as<wf_t>())           << "\n";
  std::cout << "-> rayleigh_kurtosis_excess[lower](as<wf_t>())    = " << eve::rayleigh_kurtosis_excess[eve::lower](eve::as<wf_t>()) << "\n";
  std::cout << "-> rayleigh_kurtosis_excess[upper](as<wf_t>())    = " << eve::rayleigh_kurtosis_excess[eve::upper](eve::as<wf_t>()) << "\n";
 
  std::cout << std::setprecision(17);
  std::cout << "-> rayleigh_kurtosis_excess(as<double>())         = " << eve::rayleigh_kurtosis_excess(eve::as<double>())         << "\n";
  std::cout << "-> rayleigh_kurtosis_excess(as<wd_t>())           = " << eve::rayleigh_kurtosis_excess(eve::as<wd_t>())           << "\n";
  std::cout << "-> rayleigh_kurtosis_excess[lower](as<wd_t>())    = " << eve::rayleigh_kurtosis_excess[eve::lower](eve::as<wd_t>()) << "\n";
  std::cout << "-> rayleigh_kurtosis_excess[upper](as<wd_t>())    = " << eve::rayleigh_kurtosis_excess[eve::upper](eve::as<wd_t>()) << "\n";
}

rayleigh_skewness

auto eve::rayleigh_skewness = functor<rayleigh_skewness_t>

inlineconstexpr

Callable object computing the Rayleigh skewness value : \(2\sqrt\pi(\pi-3)/(4-\pi^{3/2})\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T rayleigh_skewness(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::rayleigh_skewness(as<T>()) returns the Rayleigh skewness.

Example

// revision 0
#include <eve/module/math.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  using wf_t = eve::wide<float>;
  using wd_t = eve::wide<double>;
 
  std::cout << std::setprecision(9);
  std::cout << "-> rayleigh_skewness(as<float>())          = " << eve::rayleigh_skewness(eve::as<float>())          << "\n";
  std::cout << "-> rayleigh_skewness(as<wf_t>())           = " << eve::rayleigh_skewness(eve::as<wf_t>())           << "\n";
  std::cout << "-> rayleigh_skewness[lower](as<wf_t>())    = " << eve::rayleigh_skewness[eve::lower](eve::as<wf_t>()) << "\n";
  std::cout << "-> rayleigh_skewness[upper](as<wf_t>())    = " << eve::rayleigh_skewness[eve::upper](eve::as<wf_t>()) << "\n";
 
  std::cout << std::setprecision(17);
  std::cout << "-> rayleigh_skewness(as<double>())         = " << eve::rayleigh_skewness(eve::as<double>())         << "\n";
  std::cout << "-> rayleigh_skewness(as<wd_t>())           = " << eve::rayleigh_skewness(eve::as<wd_t>())           << "\n";
  std::cout << "-> rayleigh_skewness[lower](as<wd_t>())    = " << eve::rayleigh_skewness[eve::lower](eve::as<wd_t>()) << "\n";
  std::cout << "-> rayleigh_skewness[upper](as<wd_t>())    = " << eve::rayleigh_skewness[eve::upper](eve::as<wd_t>()) << "\n";
}

rsqrt_2pi

auto eve::rsqrt_2pi = functor<rsqrt_2pi_t>

inlineconstexpr

Callable object computing the constant \(1/\sqrt{2\pi}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T rsqrt_2pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::rsqrt_2pi(as<T>()) returns the inverse of \(\sqrt{2\pi}\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_rsqrt_2pi() { return eve::rsqrt_2pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> rsqrt_2pi(as<wide_ft>())                 = " << eve::rsqrt_2pi(eve::as<wide_ft>())                << std::endl
            << "-> rsqrt_2pi(as(wxf))                       = " << eve::rsqrt_2pi(eve::as(wxf))                      << std::endl
            << "-> rsqrt_2pi[upper](as<wide_ft>())         = " << eve::rsqrt_2pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> rsqrt_2pi[upper](as(wxf))               = " << eve::rsqrt_2pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> rsqrt_2pi[lower](as<wide_ft>())       = " << eve::rsqrt_2pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> rsqrt_2pi[lower](as(wxf))             = " << eve::rsqrt_2pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> rsqrt_2pi(as<wide_dt>())           = " << eve::rsqrt_2pi(eve::as<wide_dt>())                << std::endl
            << "-> rsqrt_2pi(as(wxd))                 = " << eve::rsqrt_2pi(eve::as(wxd))                      << std::endl
            << "-> rsqrt_2pi[upper](as<wide_dt>())   = " << eve::rsqrt_2pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> rsqrt_2pi[upper](as(wxd))         = " << eve::rsqrt_2pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> rsqrt_2pi[lower](as<wide_dt>()) = " << eve::rsqrt_2pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> rsqrt_2pi[lower](as(wxd))       = " << eve::rsqrt_2pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> rsqrt_2pi(as<float>())             = " << eve::rsqrt_2pi(eve::as(float())) << std::endl
            << "-> rsqrt_2pi(as<xf))                  = " << eve::rsqrt_2pi(eve::as(xf))      << std::endl
            << "-> rsqrt_2pi(as<double>())            = " << eve::rsqrt_2pi(eve::as(double()))<< std::endl
            << "-> rsqrt_2pi(as<xd))                  = " << eve::rsqrt_2pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr rsqrt_2pi            = " << constexpr_rsqrt_2pi<float>() << std::endl;
 
  return 0;
}

rsqrt_e

auto eve::rsqrt_e = functor<rsqrt_e_t>

inlineconstexpr

Callable object computing the constant \(1/\sqrt{e}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T rsqrt_e(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::rsqrt_e(as<T>()) returns the inverse of the square root of the basis of natural logarithms.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_rsqrt_e() { return eve::rsqrt_e(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> rsqrt_e(as<wide_ft>())                 = " << eve::rsqrt_e(eve::as<wide_ft>())                << std::endl
            << "-> rsqrt_e(as(wxf))                       = " << eve::rsqrt_e(eve::as(wxf))                      << std::endl
            << "-> rsqrt_e[upper](as<wide_ft>())         = " << eve::rsqrt_e[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> rsqrt_e[upper](as(wxf))               = " << eve::rsqrt_e[eve::upper](eve::as(wxf))         << std::endl
            << "-> rsqrt_e[lower](as<wide_ft>())       = " << eve::rsqrt_e[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> rsqrt_e[lower](as(wxf))             = " << eve::rsqrt_e[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> rsqrt_e(as<wide_dt>())           = " << eve::rsqrt_e(eve::as<wide_dt>())                << std::endl
            << "-> rsqrt_e(as(wxd))                 = " << eve::rsqrt_e(eve::as(wxd))                      << std::endl
            << "-> rsqrt_e[upper](as<wide_dt>())   = " << eve::rsqrt_e[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> rsqrt_e[upper](as(wxd))         = " << eve::rsqrt_e[eve::upper](eve::as(wxd))         << std::endl
            << "-> rsqrt_e[lower](as<wide_dt>()) = " << eve::rsqrt_e[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> rsqrt_e[lower](as(wxd))       = " << eve::rsqrt_e[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> rsqrt_e(as<float>())             = " << eve::rsqrt_e(eve::as(float())) << std::endl
            << "-> rsqrt_e(as<xf))                  = " << eve::rsqrt_e(eve::as(xf))      << std::endl
            << "-> rsqrt_e(as<double>())            = " << eve::rsqrt_e(eve::as(double()))<< std::endl
            << "-> rsqrt_e(as<xd))                  = " << eve::rsqrt_e(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr rsqrt_e            = " << constexpr_rsqrt_e<float>() << std::endl;
 
  return 0;
}

rsqrt_pi

auto eve::rsqrt_pi = functor<rsqrt_pi_t>

inlineconstexpr

Callable object computing the constant \(\pi^{-1/2}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T rsqrt_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::rsqrt_pi(as<T>()) returns the inverse of \(\sqrt{\pi}\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_rsqrt_pi() { return eve::rsqrt_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> rsqrt_pi(as<wide_ft>())       = " << eve::rsqrt_pi(eve::as<wide_ft>())            << std::endl
            << "-> rsqrt_pi(as(wxf))             = " << eve::rsqrt_pi(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> rsqrt_pi(as<float>())         = " << eve::rsqrt_pi(eve::as(float())) << std::endl
            << "-> rsqrt_pi(as<xf))              = " << eve::rsqrt_pi(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr rsqrt_pi            = " << constexpr_rsqrt_pi<float>() << std::endl;
 
  return 0;
}

rsqrt_pio_2

auto eve::rsqrt_pio_2 = functor<rsqrt_pio_2_t>

inlineconstexpr

Callable object computing the constant \((\pi/2)^{-1/2}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T rsqrt_pio_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::rsqrt_pio_2(as<T>()) returns the inverse of \(\sqrt{\pi/2}\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_rsqrt_pio_2() { return eve::rsqrt_pio_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> rsqrt_pio_2(as<wide_ft>())       = " << eve::rsqrt_pio_2(eve::as<wide_ft>())            << std::endl
            << "-> rsqrt_pio_2(as(wxf))             = " << eve::rsqrt_pio_2(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> rsqrt_pio_2(as<float>())         = " << eve::rsqrt_pio_2(eve::as(float())) << std::endl
            << "-> rsqrt_pio_2(as<xf))              = " << eve::rsqrt_pio_2(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr rsqrt_pio_2            = " << constexpr_rsqrt_pio_2<float>() << std::endl;
 
  return 0;
}

sin_1

auto eve::sin_1 = functor<sin_1_t>

inlineconstexpr

Callable object computing the constant \(\sin(1)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sin_1(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sin_1(as<T>()) returns the sine of 1.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sin_1() { return eve::sin_1(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sin_1(as<wide_ft>())                 = " << eve::sin_1(eve::as<wide_ft>())                << std::endl
            << "-> sin_1(as(wxf))                       = " << eve::sin_1(eve::as(wxf))                      << std::endl
            << "-> sin_1[upper](as<wide_ft>())         = " << eve::sin_1[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sin_1[upper](as(wxf))               = " << eve::sin_1[eve::upper](eve::as(wxf))         << std::endl
            << "-> sin_1[lower](as<wide_ft>())       = " << eve::sin_1[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sin_1[lower](as(wxf))             = " << eve::sin_1[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sin_1(as<wide_dt>())           = " << eve::sin_1(eve::as<wide_dt>())                << std::endl
            << "-> sin_1(as(wxd))                 = " << eve::sin_1(eve::as(wxd))                      << std::endl
            << "-> sin_1[upper](as<wide_dt>())   = " << eve::sin_1[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sin_1[upper](as(wxd))         = " << eve::sin_1[eve::upper](eve::as(wxd))         << std::endl
            << "-> sin_1[lower](as<wide_dt>()) = " << eve::sin_1[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sin_1[lower](as(wxd))       = " << eve::sin_1[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sin_1(as<float>())             = " << eve::sin_1(eve::as(float())) << std::endl
            << "-> sin_1(as<xf))                  = " << eve::sin_1(eve::as(xf))      << std::endl
            << "-> sin_1(as<double>())            = " << eve::sin_1(eve::as(double()))<< std::endl
            << "-> sin_1(as<xd))                  = " << eve::sin_1(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sin_1            = " << constexpr_sin_1<float>() << std::endl;
 
  return 0;
}

sinh_1

auto eve::sinh_1 = functor<sinh_1_t>

inlineconstexpr

Callable object computing the constant \(\sinh(1)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sinh_1(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sinh_1(as<T>()) returns the hyperbolic sine of 1.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sinh_1() { return eve::sinh_1(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sinh_1(as<wide_ft>())                 = " << eve::sinh_1(eve::as<wide_ft>())                << std::endl
            << "-> sinh_1(as(wxf))                       = " << eve::sinh_1(eve::as(wxf))                      << std::endl
            << "-> sinh_1[upper](as<wide_ft>())         = " << eve::sinh_1[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sinh_1[upper](as(wxf))               = " << eve::sinh_1[eve::upper](eve::as(wxf))         << std::endl
            << "-> sinh_1[lower](as<wide_ft>())       = " << eve::sinh_1[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sinh_1[lower](as(wxf))             = " << eve::sinh_1[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sinh_1(as<wide_dt>())           = " << eve::sinh_1(eve::as<wide_dt>())                << std::endl
            << "-> sinh_1(as(wxd))                 = " << eve::sinh_1(eve::as(wxd))                      << std::endl
            << "-> sinh_1[upper](as<wide_dt>())   = " << eve::sinh_1[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sinh_1[upper](as(wxd))         = " << eve::sinh_1[eve::upper](eve::as(wxd))         << std::endl
            << "-> sinh_1[lower](as<wide_dt>()) = " << eve::sinh_1[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sinh_1[lower](as(wxd))       = " << eve::sinh_1[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sinh_1(as<float>())             = " << eve::sinh_1(eve::as(float())) << std::endl
            << "-> sinh_1(as<xf))                  = " << eve::sinh_1(eve::as(xf))      << std::endl
            << "-> sinh_1(as<double>())            = " << eve::sinh_1(eve::as(double()))<< std::endl
            << "-> sinh_1(as<xd))                  = " << eve::sinh_1(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sinh_1            = " << constexpr_sinh_1<float>() << std::endl;
 
  return 0;
}

sixth

auto eve::sixth = functor<sixth_t>

inlineconstexpr

Callable object computing the constant \(1/6\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sixth(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sixth(as<T>()) returns \(1/6\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sixth() { return eve::sixth(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sixth(as<wide_ft>())                 = " << eve::sixth(eve::as<wide_ft>())                << std::endl
            << "-> sixth(as(wxf))                       = " << eve::sixth(eve::as(wxf))                      << std::endl
            << "-> sixth[upper](as<wide_ft>())         = " << eve::sixth[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sixth[upper](as(wxf))               = " << eve::sixth[eve::upper](eve::as(wxf))         << std::endl
            << "-> sixth[lower](as<wide_ft>())       = " << eve::sixth[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sixth[lower](as(wxf))             = " << eve::sixth[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sixth(as<wide_dt>())           = " << eve::sixth(eve::as<wide_dt>())                << std::endl
            << "-> sixth(as(wxd))                 = " << eve::sixth(eve::as(wxd))                      << std::endl
            << "-> sixth[upper](as<wide_dt>())   = " << eve::sixth[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sixth[upper](as(wxd))         = " << eve::sixth[eve::upper](eve::as(wxd))         << std::endl
            << "-> sixth[lower](as<wide_dt>()) = " << eve::sixth[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sixth[lower](as(wxd))       = " << eve::sixth[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sixth(as<float>())             = " << eve::sixth(eve::as(float())) << std::endl
            << "-> sixth(as<xf))                  = " << eve::sixth(eve::as(xf))      << std::endl
            << "-> sixth(as<double>())            = " << eve::sixth(eve::as(double()))<< std::endl
            << "-> sixth(as<xd))                  = " << eve::sixth(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sixth            = " << constexpr_sixth<float>() << std::endl;
 
  return 0;
}

sqrt_2

auto eve::sqrt_2 = functor<sqrt_2_t>

inlineconstexpr

Callable object computing the constant \(\sqrt2\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sqrt_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sqrt_2(as<T>()) returns the square root of 2.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sqrt_2() { return eve::sqrt_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sqrt_2(as<wide_ft>())                 = " << eve::sqrt_2(eve::as<wide_ft>())                << std::endl
            << "-> sqrt_2(as(wxf))                       = " << eve::sqrt_2(eve::as(wxf))                      << std::endl
            << "-> sqrt_2[upper](as<wide_ft>())         = " << eve::sqrt_2[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sqrt_2[upper](as(wxf))               = " << eve::sqrt_2[eve::upper](eve::as(wxf))         << std::endl
            << "-> sqrt_2[lower](as<wide_ft>())       = " << eve::sqrt_2[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sqrt_2[lower](as(wxf))             = " << eve::sqrt_2[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sqrt_2(as<wide_dt>())           = " << eve::sqrt_2(eve::as<wide_dt>())                << std::endl
            << "-> sqrt_2(as(wxd))                 = " << eve::sqrt_2(eve::as(wxd))                      << std::endl
            << "-> sqrt_2[upper](as<wide_dt>())   = " << eve::sqrt_2[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sqrt_2[upper](as(wxd))         = " << eve::sqrt_2[eve::upper](eve::as(wxd))         << std::endl
            << "-> sqrt_2[lower](as<wide_dt>()) = " << eve::sqrt_2[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sqrt_2[lower](as(wxd))       = " << eve::sqrt_2[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sqrt_2(as<float>())             = " << eve::sqrt_2(eve::as(float())) << std::endl
            << "-> sqrt_2(as<xf))                  = " << eve::sqrt_2(eve::as(xf))      << std::endl
            << "-> sqrt_2(as<double>())            = " << eve::sqrt_2(eve::as(double()))<< std::endl
            << "-> sqrt_2(as<xd))                  = " << eve::sqrt_2(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sqrt_2            = " << constexpr_sqrt_2<float>() << std::endl;
 
  return 0;
}

sqrt_2pi

auto eve::sqrt_2pi = functor<sqrt_2pi_t>

inlineconstexpr

Callable object computing the constant \(\sqrt{2\pi}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sqrt_2pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sqrt_2pi(as<T>()) returns athe square root of \(2\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sqrt_2pi() { return eve::sqrt_2pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sqrt_2pi(as<wide_ft>())                 = " << eve::sqrt_2pi(eve::as<wide_ft>())                << std::endl
            << "-> sqrt_2pi(as(wxf))                       = " << eve::sqrt_2pi(eve::as(wxf))                      << std::endl
            << "-> sqrt_2pi[upper](as<wide_ft>())         = " << eve::sqrt_2pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sqrt_2pi[upper](as(wxf))               = " << eve::sqrt_2pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> sqrt_2pi[lower](as<wide_ft>())       = " << eve::sqrt_2pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sqrt_2pi[lower](as(wxf))             = " << eve::sqrt_2pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sqrt_2pi(as<wide_dt>())           = " << eve::sqrt_2pi(eve::as<wide_dt>())                << std::endl
            << "-> sqrt_2pi(as(wxd))                 = " << eve::sqrt_2pi(eve::as(wxd))                      << std::endl
            << "-> sqrt_2pi[upper](as<wide_dt>())   = " << eve::sqrt_2pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sqrt_2pi[upper](as(wxd))         = " << eve::sqrt_2pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> sqrt_2pi[lower](as<wide_dt>()) = " << eve::sqrt_2pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sqrt_2pi[lower](as(wxd))       = " << eve::sqrt_2pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sqrt_2pi(as<float>())             = " << eve::sqrt_2pi(eve::as(float())) << std::endl
            << "-> sqrt_2pi(as<xf))                  = " << eve::sqrt_2pi(eve::as(xf))      << std::endl
            << "-> sqrt_2pi(as<double>())            = " << eve::sqrt_2pi(eve::as(double()))<< std::endl
            << "-> sqrt_2pi(as<xd))                  = " << eve::sqrt_2pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sqrt_2pi            = " << constexpr_sqrt_2pi<float>() << std::endl;
 
  return 0;
}

sqrt_3

auto eve::sqrt_3 = functor<sqrt_3_t>

inlineconstexpr

Callable object computing constant \(\sqrt{3}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sqrt_3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sqrt_3(as<T>()) returns the square root of 3.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sqrt_3() { return eve::sqrt_3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sqrt_3(as<wide_ft>())                 = " << eve::sqrt_3(eve::as<wide_ft>())                << std::endl
            << "-> sqrt_3(as(wxf))                       = " << eve::sqrt_3(eve::as(wxf))                      << std::endl
            << "-> sqrt_3[upper](as<wide_ft>())         = " << eve::sqrt_3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sqrt_3[upper](as(wxf))               = " << eve::sqrt_3[eve::upper](eve::as(wxf))         << std::endl
            << "-> sqrt_3[lower](as<wide_ft>())       = " << eve::sqrt_3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sqrt_3[lower](as(wxf))             = " << eve::sqrt_3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sqrt_3(as<wide_dt>())           = " << eve::sqrt_3(eve::as<wide_dt>())                << std::endl
            << "-> sqrt_3(as(wxd))                 = " << eve::sqrt_3(eve::as(wxd))                      << std::endl
            << "-> sqrt_3[upper](as<wide_dt>())   = " << eve::sqrt_3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sqrt_3[upper](as(wxd))         = " << eve::sqrt_3[eve::upper](eve::as(wxd))         << std::endl
            << "-> sqrt_3[lower](as<wide_dt>()) = " << eve::sqrt_3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sqrt_3[lower](as(wxd))       = " << eve::sqrt_3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sqrt_3(as<float>())             = " << eve::sqrt_3(eve::as(float())) << std::endl
            << "-> sqrt_3(as<xf))                  = " << eve::sqrt_3(eve::as(xf))      << std::endl
            << "-> sqrt_3(as<double>())            = " << eve::sqrt_3(eve::as(double()))<< std::endl
            << "-> sqrt_3(as<xd))                  = " << eve::sqrt_3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sqrt_3            = " << constexpr_sqrt_3<float>() << std::endl;
 
  return 0;
}

sqrt_e

auto eve::sqrt_e = functor<sqrt_e_t>

inlineconstexpr

Callable object computing the constant \(\sqrt{e}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sqrt_e(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sqrt_e(as<T>()) returns the square root of the basis of the natural logarithms.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sqrt_e() { return eve::sqrt_e(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sqrt_e(as<wide_ft>())                 = " << eve::sqrt_e(eve::as<wide_ft>())                << std::endl
            << "-> sqrt_e(as(wxf))                       = " << eve::sqrt_e(eve::as(wxf))                      << std::endl
            << "-> sqrt_e[upper](as<wide_ft>())         = " << eve::sqrt_e[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sqrt_e[upper](as(wxf))               = " << eve::sqrt_e[eve::upper](eve::as(wxf))         << std::endl
            << "-> sqrt_e[lower](as<wide_ft>())       = " << eve::sqrt_e[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sqrt_e[lower](as(wxf))             = " << eve::sqrt_e[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sqrt_e(as<wide_dt>())           = " << eve::sqrt_e(eve::as<wide_dt>())                << std::endl
            << "-> sqrt_e(as(wxd))                 = " << eve::sqrt_e(eve::as(wxd))                      << std::endl
            << "-> sqrt_e[upper](as<wide_dt>())   = " << eve::sqrt_e[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sqrt_e[upper](as(wxd))         = " << eve::sqrt_e[eve::upper](eve::as(wxd))         << std::endl
            << "-> sqrt_e[lower](as<wide_dt>()) = " << eve::sqrt_e[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sqrt_e[lower](as(wxd))       = " << eve::sqrt_e[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sqrt_e(as<float>())             = " << eve::sqrt_e(eve::as(float())) << std::endl
            << "-> sqrt_e(as<xf))                  = " << eve::sqrt_e(eve::as(xf))      << std::endl
            << "-> sqrt_e(as<double>())            = " << eve::sqrt_e(eve::as(double()))<< std::endl
            << "-> sqrt_e(as<xd))                  = " << eve::sqrt_e(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sqrt_e            = " << constexpr_sqrt_e<float>() << std::endl;
 
  return 0;
}

sqrt_pi

auto eve::sqrt_pi = functor<sqrt_pi_t>

inlineconstexpr

Callable object computing the constant \(\sqrt{\pi}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sqrt_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sqrt_pi(as<T>()) returns the square root of \(\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sqrt_pi() { return eve::sqrt_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sqrt_pi(as<wide_ft>())                 = " << eve::sqrt_pi(eve::as<wide_ft>())                << std::endl
            << "-> sqrt_pi(as(wxf))                       = " << eve::sqrt_pi(eve::as(wxf))                      << std::endl
            << "-> sqrt_pi[upper](as<wide_ft>())         = " << eve::sqrt_pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sqrt_pi[upper](as(wxf))               = " << eve::sqrt_pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> sqrt_pi[lower](as<wide_ft>())       = " << eve::sqrt_pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sqrt_pi[lower](as(wxf))             = " << eve::sqrt_pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sqrt_pi(as<wide_dt>())           = " << eve::sqrt_pi(eve::as<wide_dt>())                << std::endl
            << "-> sqrt_pi(as(wxd))                 = " << eve::sqrt_pi(eve::as(wxd))                      << std::endl
            << "-> sqrt_pi[upper](as<wide_dt>())   = " << eve::sqrt_pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sqrt_pi[upper](as(wxd))         = " << eve::sqrt_pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> sqrt_pi[lower](as<wide_dt>()) = " << eve::sqrt_pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sqrt_pi[lower](as(wxd))       = " << eve::sqrt_pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sqrt_pi(as<float>())             = " << eve::sqrt_pi(eve::as(float())) << std::endl
            << "-> sqrt_pi(as<xf))                  = " << eve::sqrt_pi(eve::as(xf))      << std::endl
            << "-> sqrt_pi(as<double>())            = " << eve::sqrt_pi(eve::as(double()))<< std::endl
            << "-> sqrt_pi(as<xd))                  = " << eve::sqrt_pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sqrt_pi            = " << constexpr_sqrt_pi<float>() << std::endl;
 
  return 0;
}

sqrt_pio_2

auto eve::sqrt_pio_2 = functor<sqrt_pio_2_t>

inlineconstexpr

Callable object computing the constant \(\sqrt{\pi/2}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sqrt_pio_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sqrt_pio_2(as<T>()) returns the square root of \(\pi/2\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sqrt_pio_2() { return eve::sqrt_pio_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sqrt_pio_2(as<wide_ft>())                 = " << eve::sqrt_pio_2(eve::as<wide_ft>())                << std::endl
            << "-> sqrt_pio_2(as(wxf))                       = " << eve::sqrt_pio_2(eve::as(wxf))                      << std::endl
            << "-> sqrt_pio_2[upper](as<wide_ft>())         = " << eve::sqrt_pio_2[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sqrt_pio_2[upper](as(wxf))               = " << eve::sqrt_pio_2[eve::upper](eve::as(wxf))         << std::endl
            << "-> sqrt_pio_2[lower](as<wide_ft>())       = " << eve::sqrt_pio_2[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sqrt_pio_2[lower](as(wxf))             = " << eve::sqrt_pio_2[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sqrt_pio_2(as<wide_dt>())           = " << eve::sqrt_pio_2(eve::as<wide_dt>())                << std::endl
            << "-> sqrt_pio_2(as(wxd))                 = " << eve::sqrt_pio_2(eve::as(wxd))                      << std::endl
            << "-> sqrt_pio_2[upper](as<wide_dt>())   = " << eve::sqrt_pio_2[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sqrt_pio_2[upper](as(wxd))         = " << eve::sqrt_pio_2[eve::upper](eve::as(wxd))         << std::endl
            << "-> sqrt_pio_2[lower](as<wide_dt>()) = " << eve::sqrt_pio_2[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sqrt_pio_2[lower](as(wxd))       = " << eve::sqrt_pio_2[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sqrt_pio_2(as<float>())             = " << eve::sqrt_pio_2(eve::as(float())) << std::endl
            << "-> sqrt_pio_2(as<xf))                  = " << eve::sqrt_pio_2(eve::as(xf))      << std::endl
            << "-> sqrt_pio_2(as<double>())            = " << eve::sqrt_pio_2(eve::as(double()))<< std::endl
            << "-> sqrt_pio_2(as<xd))                  = " << eve::sqrt_pio_2(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sqrt_pio_2            = " << constexpr_sqrt_pio_2<float>() << std::endl;
 
  return 0;
}

sqrtlog_4

auto eve::sqrtlog_4 = functor<sqrtlog_4_t>

inlineconstexpr

Callable object computing the constant \(\sqrt{\log4}\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T sqrtlog_4(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::sqrtlog_4(as<T>()) returns the square root of \(\log4\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_sqrtlog_4() { return eve::sqrtlog_4(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> sqrtlog_4(as<wide_ft>())                 = " << eve::sqrtlog_4(eve::as<wide_ft>())                << std::endl
            << "-> sqrtlog_4(as(wxf))                       = " << eve::sqrtlog_4(eve::as(wxf))                      << std::endl
            << "-> sqrtlog_4[upper](as<wide_ft>())         = " << eve::sqrtlog_4[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> sqrtlog_4[upper](as(wxf))               = " << eve::sqrtlog_4[eve::upper](eve::as(wxf))         << std::endl
            << "-> sqrtlog_4[lower](as<wide_ft>())       = " << eve::sqrtlog_4[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> sqrtlog_4[lower](as(wxf))             = " << eve::sqrtlog_4[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> sqrtlog_4(as<wide_dt>())           = " << eve::sqrtlog_4(eve::as<wide_dt>())                << std::endl
            << "-> sqrtlog_4(as(wxd))                 = " << eve::sqrtlog_4(eve::as(wxd))                      << std::endl
            << "-> sqrtlog_4[upper](as<wide_dt>())   = " << eve::sqrtlog_4[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> sqrtlog_4[upper](as(wxd))         = " << eve::sqrtlog_4[eve::upper](eve::as(wxd))         << std::endl
            << "-> sqrtlog_4[lower](as<wide_dt>()) = " << eve::sqrtlog_4[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> sqrtlog_4[lower](as(wxd))       = " << eve::sqrtlog_4[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> sqrtlog_4(as<float>())             = " << eve::sqrtlog_4(eve::as(float())) << std::endl
            << "-> sqrtlog_4(as<xf))                  = " << eve::sqrtlog_4(eve::as(xf))      << std::endl
            << "-> sqrtlog_4(as<double>())            = " << eve::sqrtlog_4(eve::as(double()))<< std::endl
            << "-> sqrtlog_4(as<xd))                  = " << eve::sqrtlog_4(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr sqrtlog_4            = " << constexpr_sqrtlog_4<float>() << std::endl;
 
  return 0;
}

third

auto eve::third = functor<third_t>

inlineconstexpr

Callable object computing the constant \(1/3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T third(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::third(as<T>()) returns one third.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_third() { return eve::third(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> third(as<wide_ft>())                 = " << eve::third(eve::as<wide_ft>())                << std::endl
            << "-> third(as(wxf))                       = " << eve::third(eve::as(wxf))                      << std::endl
            << "-> third[upper](as<wide_ft>())         = " << eve::third[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> third[upper](as(wxf))               = " << eve::third[eve::upper](eve::as(wxf))         << std::endl
            << "-> third[lower](as<wide_ft>())       = " << eve::third[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> third[lower](as(wxf))             = " << eve::third[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> third(as<wide_dt>())           = " << eve::third(eve::as<wide_dt>())                << std::endl
            << "-> third(as(wxd))                 = " << eve::third(eve::as(wxd))                      << std::endl
            << "-> third[upper](as<wide_dt>())   = " << eve::third[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> third[upper](as(wxd))         = " << eve::third[eve::upper](eve::as(wxd))         << std::endl
            << "-> third[lower](as<wide_dt>()) = " << eve::third[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> third[lower](as(wxd))       = " << eve::third[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> third(as<float>())             = " << eve::third(eve::as(float())) << std::endl
            << "-> third(as<xf))                  = " << eve::third(eve::as(xf))      << std::endl
            << "-> third(as<double>())            = " << eve::third(eve::as(double()))<< std::endl
            << "-> third(as<xd))                  = " << eve::third(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr third            = " << constexpr_third<float>() << std::endl;
 
  return 0;
}

three_o_4

auto eve::three_o_4 = functor<three_o_4_t>

inlineconstexpr

Callable object computing the constant \(3/4\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T three_o_4(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::three_o_4(as<T>()) returns \(3/4\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_three_o_4() { return eve::three_o_4(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> three_o_4(as<wide_ft>())                 = " << eve::three_o_4(eve::as<wide_ft>())                << std::endl
            << "-> three_o_4(as(wxf))                       = " << eve::three_o_4(eve::as(wxf))                      << std::endl
            << "-> three_o_4[upper](as<wide_ft>())         = " << eve::three_o_4[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> three_o_4[upper](as(wxf))               = " << eve::three_o_4[eve::upper](eve::as(wxf))         << std::endl
            << "-> three_o_4[lower](as<wide_ft>())       = " << eve::three_o_4[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> three_o_4[lower](as(wxf))             = " << eve::three_o_4[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> three_o_4(as<wide_dt>())           = " << eve::three_o_4(eve::as<wide_dt>())                << std::endl
            << "-> three_o_4(as(wxd))                 = " << eve::three_o_4(eve::as(wxd))                      << std::endl
            << "-> three_o_4[upper](as<wide_dt>())   = " << eve::three_o_4[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> three_o_4[upper](as(wxd))         = " << eve::three_o_4[eve::upper](eve::as(wxd))         << std::endl
            << "-> three_o_4[lower](as<wide_dt>()) = " << eve::three_o_4[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> three_o_4[lower](as(wxd))       = " << eve::three_o_4[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> three_o_4(as<float>())             = " << eve::three_o_4(eve::as(float())) << std::endl
            << "-> three_o_4(as<xf))                  = " << eve::three_o_4(eve::as(xf))      << std::endl
            << "-> three_o_4(as<double>())            = " << eve::three_o_4(eve::as(double()))<< std::endl
            << "-> three_o_4(as<xd))                  = " << eve::three_o_4(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr three_o_4            = " << constexpr_three_o_4<float>() << std::endl;
 
  return 0;
}

three_pio_4

auto eve::three_pio_4 = functor<three_pio_4_t>

inlineconstexpr

Callable object computing the constant \(3\pi/4\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T three_pio_4(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::three_pio_4(as<T>()) returns \(3\pi/4\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_three_pio_4() { return eve::three_pio_4(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> three_pio_4(as<wide_ft>())                 = " << eve::three_pio_4(eve::as<wide_ft>())                << std::endl
            << "-> three_pio_4(as(wxf))                       = " << eve::three_pio_4(eve::as(wxf))                      << std::endl
            << "-> three_pio_4[upper](as<wide_ft>())         = " << eve::three_pio_4[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> three_pio_4[upper](as(wxf))               = " << eve::three_pio_4[eve::upper](eve::as(wxf))         << std::endl
            << "-> three_pio_4[lower](as<wide_ft>())       = " << eve::three_pio_4[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> three_pio_4[lower](as(wxf))             = " << eve::three_pio_4[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> three_pio_4(as<wide_dt>())           = " << eve::three_pio_4(eve::as<wide_dt>())                << std::endl
            << "-> three_pio_4(as(wxd))                 = " << eve::three_pio_4(eve::as(wxd))                      << std::endl
            << "-> three_pio_4[upper](as<wide_dt>())   = " << eve::three_pio_4[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> three_pio_4[upper](as(wxd))         = " << eve::three_pio_4[eve::upper](eve::as(wxd))         << std::endl
            << "-> three_pio_4[lower](as<wide_dt>()) = " << eve::three_pio_4[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> three_pio_4[lower](as(wxd))       = " << eve::three_pio_4[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> three_pio_4(as<float>())             = " << eve::three_pio_4(eve::as(float())) << std::endl
            << "-> three_pio_4(as<xf))                  = " << eve::three_pio_4(eve::as(xf))      << std::endl
            << "-> three_pio_4(as<double>())            = " << eve::three_pio_4(eve::as(double()))<< std::endl
            << "-> three_pio_4(as<xd))                  = " << eve::three_pio_4(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr three_pio_4            = " << constexpr_three_pio_4<float>() << std::endl;
 
  return 0;
}

two_o_3

auto eve::two_o_3 = functor<two_o_3_t>

inlineconstexpr

Callable object computing the constant \(2/3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T two_o_3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::two_o_3(as<T>()) returns two third.

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_two_o_3() { return eve::two_o_3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> two_o_3(as<wide_ft>())                 = " << eve::two_o_3(eve::as<wide_ft>())                << std::endl
            << "-> two_o_3(as(wxf))                       = " << eve::two_o_3(eve::as(wxf))                      << std::endl
            << "-> two_o_3[upper](as<wide_ft>())         = " << eve::two_o_3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> two_o_3[upper](as(wxf))               = " << eve::two_o_3[eve::upper](eve::as(wxf))         << std::endl
            << "-> two_o_3[lower](as<wide_ft>())       = " << eve::two_o_3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> two_o_3[lower](as(wxf))             = " << eve::two_o_3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> two_o_3(as<wide_dt>())           = " << eve::two_o_3(eve::as<wide_dt>())                << std::endl
            << "-> two_o_3(as(wxd))                 = " << eve::two_o_3(eve::as(wxd))                      << std::endl
            << "-> two_o_3[upper](as<wide_dt>())   = " << eve::two_o_3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> two_o_3[upper](as(wxd))         = " << eve::two_o_3[eve::upper](eve::as(wxd))         << std::endl
            << "-> two_o_3[lower](as<wide_dt>()) = " << eve::two_o_3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> two_o_3[lower](as(wxd))       = " << eve::two_o_3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> two_o_3(as<float>())             = " << eve::two_o_3(eve::as(float())) << std::endl
            << "-> two_o_3(as<xf))                  = " << eve::two_o_3(eve::as(xf))      << std::endl
            << "-> two_o_3(as<double>())            = " << eve::two_o_3(eve::as(double()))<< std::endl
            << "-> two_o_3(as<xd))                  = " << eve::two_o_3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr two_o_3            = " << constexpr_two_o_3<float>() << std::endl;
 
  return 0;
}

two_o_pi

auto eve::two_o_pi = functor<two_o_pi_t>

inlineconstexpr

Callable object computing the constant \(2/\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T two_o_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::two_o_pi(as<T>()) returns \(2/\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_two_o_pi() { return eve::two_o_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> two_o_pi(as<wide_ft>())       = " << eve::two_o_pi(eve::as<wide_ft>())            << std::endl
            << "-> two_o_pi(as(wxf))             = " << eve::two_o_pi(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> two_o_pi(as<float>())         = " << eve::two_o_pi(eve::as(float())) << std::endl
            << "-> two_o_pi(as<xf))              = " << eve::two_o_pi(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr two_o_pi            = " << constexpr_two_o_pi<float>() << std::endl;
 
  return 0;
}

two_o_sqrt_pi

auto eve::two_o_sqrt_pi = functor<two_o_sqrt_pi_t>

inlineconstexpr

Callable object computing the constant \(2/\sqrt\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T two_o_sqrt_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::two_o_sqrt_pi(as<T>()) returns \(2/\sqrt\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_two_o_sqrt_pi() { return eve::two_o_sqrt_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> two_o_sqrt_pi(as<wide_ft>())                 = " << eve::two_o_sqrt_pi(eve::as<wide_ft>())                << std::endl
            << "-> two_o_sqrt_pi(as(wxf))                       = " << eve::two_o_sqrt_pi(eve::as(wxf))                      << std::endl
            << "-> two_o_sqrt_pi[upper](as<wide_ft>())         = " << eve::two_o_sqrt_pi[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> two_o_sqrt_pi[upper](as(wxf))               = " << eve::two_o_sqrt_pi[eve::upper](eve::as(wxf))         << std::endl
            << "-> two_o_sqrt_pi[lower](as<wide_ft>())       = " << eve::two_o_sqrt_pi[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> two_o_sqrt_pi[lower](as(wxf))             = " << eve::two_o_sqrt_pi[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> two_o_sqrt_pi(as<wide_dt>())           = " << eve::two_o_sqrt_pi(eve::as<wide_dt>())                << std::endl
            << "-> two_o_sqrt_pi(as(wxd))                 = " << eve::two_o_sqrt_pi(eve::as(wxd))                      << std::endl
            << "-> two_o_sqrt_pi[upper](as<wide_dt>())   = " << eve::two_o_sqrt_pi[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> two_o_sqrt_pi[upper](as(wxd))         = " << eve::two_o_sqrt_pi[eve::upper](eve::as(wxd))         << std::endl
            << "-> two_o_sqrt_pi[lower](as<wide_dt>()) = " << eve::two_o_sqrt_pi[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> two_o_sqrt_pi[lower](as(wxd))       = " << eve::two_o_sqrt_pi[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> two_o_sqrt_pi(as<float>())             = " << eve::two_o_sqrt_pi(eve::as(float())) << std::endl
            << "-> two_o_sqrt_pi(as<xf))                  = " << eve::two_o_sqrt_pi(eve::as(xf))      << std::endl
            << "-> two_o_sqrt_pi(as<double>())            = " << eve::two_o_sqrt_pi(eve::as(double()))<< std::endl
            << "-> two_o_sqrt_pi(as<xd))                  = " << eve::two_o_sqrt_pi(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr two_o_sqrt_pi            = " << constexpr_two_o_sqrt_pi<float>() << std::endl;
 
  return 0;
}

two_pi

auto eve::two_pi = functor<two_pi_t>

inlineconstexpr

Callable object computing the constant \(2\pi\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T two_pi(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::two_pi(as<T>()) returns \(2\pi\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
 
template<typename T>
consteval auto constexpr_two_pi() { return eve::two_pi(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> two_pi(as<wide_ft>())       = " << eve::two_pi(eve::as<wide_ft>())            << std::endl
            << "-> two_pi(as(wxf))             = " << eve::two_pi(eve::as(wxf))                  << std::endl;
 
  double       xf;
 
  std::cout << "---- scalar" << std::endl
            << "-> two_pi(as<float>())         = " << eve::two_pi(eve::as(float())) << std::endl
            << "-> two_pi(as<xf))              = " << eve::two_pi(eve::as(xf))      << std::endl;
 
 
  std::cout << "-> constexpr two_pi            = " << constexpr_two_pi<float>() << std::endl;
 
  return 0;
}

two_pio_3

auto eve::two_pio_3 = functor<two_pio_3_t>

inlineconstexpr

Callable object computing the constant \(2\pi/3\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T two_pio_3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::two_pio_3(as<T>()) returns \(2\pi/3\).

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_two_pio_3() { return eve::two_pio_3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> two_pio_3(as<wide_ft>())                 = " << eve::two_pio_3(eve::as<wide_ft>())                << std::endl
            << "-> two_pio_3(as(wxf))                       = " << eve::two_pio_3(eve::as(wxf))                      << std::endl
            << "-> two_pio_3[upper](as<wide_ft>())         = " << eve::two_pio_3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> two_pio_3[upper](as(wxf))               = " << eve::two_pio_3[eve::upper](eve::as(wxf))         << std::endl
            << "-> two_pio_3[lower](as<wide_ft>())       = " << eve::two_pio_3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> two_pio_3[lower](as(wxf))             = " << eve::two_pio_3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> two_pio_3(as<wide_dt>())           = " << eve::two_pio_3(eve::as<wide_dt>())                << std::endl
            << "-> two_pio_3(as(wxd))                 = " << eve::two_pio_3(eve::as(wxd))                      << std::endl
            << "-> two_pio_3[upper](as<wide_dt>())   = " << eve::two_pio_3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> two_pio_3[upper](as(wxd))         = " << eve::two_pio_3[eve::upper](eve::as(wxd))         << std::endl
            << "-> two_pio_3[lower](as<wide_dt>()) = " << eve::two_pio_3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> two_pio_3[lower](as(wxd))       = " << eve::two_pio_3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> two_pio_3(as<float>())             = " << eve::two_pio_3(eve::as(float())) << std::endl
            << "-> two_pio_3(as<xf))                  = " << eve::two_pio_3(eve::as(xf))      << std::endl
            << "-> two_pio_3(as<double>())            = " << eve::two_pio_3(eve::as(double()))<< std::endl
            << "-> two_pio_3(as<xd))                  = " << eve::two_pio_3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr two_pio_3            = " << constexpr_two_pio_3<float>() << std::endl;
 
  return 0;
}

zeta_2

auto eve::zeta_2 = functor<zeta_2_t>

inlineconstexpr

Callable object computing the constant \(\zeta(2)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T zeta_2(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::zeta_2(as<T>()) returns \(\zeta(2)\).

External references

• Wolfram MathWorld
• DLMF
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_zeta_2() { return eve::zeta_2(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> zeta_2(as<wide_ft>())                 = " << eve::zeta_2(eve::as<wide_ft>())                << std::endl
            << "-> zeta_2(as(wxf))                       = " << eve::zeta_2(eve::as(wxf))                      << std::endl
            << "-> zeta_2[upper](as<wide_ft>())         = " << eve::zeta_2[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> zeta_2[upper](as(wxf))               = " << eve::zeta_2[eve::upper](eve::as(wxf))         << std::endl
            << "-> zeta_2[lower](as<wide_ft>())       = " << eve::zeta_2[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> zeta_2[lower](as(wxf))             = " << eve::zeta_2[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> zeta_2(as<wide_dt>())           = " << eve::zeta_2(eve::as<wide_dt>())                << std::endl
            << "-> zeta_2(as(wxd))                 = " << eve::zeta_2(eve::as(wxd))                      << std::endl
            << "-> zeta_2[upper](as<wide_dt>())   = " << eve::zeta_2[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> zeta_2[upper](as(wxd))         = " << eve::zeta_2[eve::upper](eve::as(wxd))         << std::endl
            << "-> zeta_2[lower](as<wide_dt>()) = " << eve::zeta_2[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> zeta_2[lower](as(wxd))       = " << eve::zeta_2[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> zeta_2(as<float>())             = " << eve::zeta_2(eve::as(float())) << std::endl
            << "-> zeta_2(as<xf))                  = " << eve::zeta_2(eve::as(xf))      << std::endl
            << "-> zeta_2(as<double>())            = " << eve::zeta_2(eve::as(double()))<< std::endl
            << "-> zeta_2(as<xd))                  = " << eve::zeta_2(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr zeta_2            = " << constexpr_zeta_2<float>() << std::endl;
 
  return 0;
}

zeta_3

auto eve::zeta_3 = functor<zeta_3_t>

inlineconstexpr

Callable object computing the constant \(\zeta(3)\).

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   template< eve::floating_value T >
   T zeta_3(as<T> x) noexcept;
}

Parameters

• x : Type wrapper instance embedding the type of the constant.

Return value

The call eve::zeta_3(as<T>()) returns \(\zeta(3)\).

External references

• Wolfram MathWorld
• DLMF
• Wikipedia

Example

#include <eve/module/math.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float>;
using wide_dt = eve::wide<double>;
 
template<typename T>
consteval auto constexpr_zeta_3() { return eve::zeta_3(eve::as<T>{}); }
 
int main()
{
  wide_ft wxf;
  wide_dt wxd;
 
  std::cout << "---- simd"  << std::setprecision(9) << std::endl
            << "-> zeta_3(as<wide_ft>())                 = " << eve::zeta_3(eve::as<wide_ft>())                << std::endl
            << "-> zeta_3(as(wxf))                       = " << eve::zeta_3(eve::as(wxf))                      << std::endl
            << "-> zeta_3[upper](as<wide_ft>())         = " << eve::zeta_3[eve::upper](eve::as<wide_ft>())   << std::endl
            << "-> zeta_3[upper](as(wxf))               = " << eve::zeta_3[eve::upper](eve::as(wxf))         << std::endl
            << "-> zeta_3[lower](as<wide_ft>())       = " << eve::zeta_3[eve::lower](eve::as<wide_ft>()) << std::endl
            << "-> zeta_3[lower](as(wxf))             = " << eve::zeta_3[eve::lower](eve::as(wxf))       << std::endl
            << std::setprecision(17)
            << "-> zeta_3(as<wide_dt>())           = " << eve::zeta_3(eve::as<wide_dt>())                << std::endl
            << "-> zeta_3(as(wxd))                 = " << eve::zeta_3(eve::as(wxd))                      << std::endl
            << "-> zeta_3[upper](as<wide_dt>())   = " << eve::zeta_3[eve::upper](eve::as<wide_dt>())   << std::endl
            << "-> zeta_3[upper](as(wxd))         = " << eve::zeta_3[eve::upper](eve::as(wxd))         << std::endl
            << "-> zeta_3[lower](as<wide_dt>()) = " << eve::zeta_3[eve::lower](eve::as<wide_dt>()) << std::endl
            << "-> zeta_3[lower](as(wxd))       = " << eve::zeta_3[eve::lower](eve::as(wxd))       << std::endl;
 
  float        xf;
  double       xd;
 
  std::cout << "---- scalar" << std::endl
            << "-> zeta_3(as<float>())             = " << eve::zeta_3(eve::as(float())) << std::endl
            << "-> zeta_3(as<xf))                  = " << eve::zeta_3(eve::as(xf))      << std::endl
            << "-> zeta_3(as<double>())            = " << eve::zeta_3(eve::as(double()))<< std::endl
            << "-> zeta_3(as<xd))                  = " << eve::zeta_3(eve::as(xd))      << std::endl;
 
 
  std::cout << "-> constexpr zeta_3            = " << constexpr_zeta_3<float>() << std::endl;
 
  return 0;
}