Detailed Description

These functions allows performing hyperbolic computations

Variables
constexpr auto	eve::cosh = functor<cosh_t>
	elementwise_callable object computing the hyperbolic cosine: \(\frac{e^x+e^{-x}}2\).
constexpr auto	eve::coth = functor<coth_t>
	elementwise_callable object computing the hyperbolic cotangent: \(\frac{e^x+e^{-x}}{e^x-e^{-x}}\).
constexpr auto	eve::csch = functor<csch_t>
	elementwise_callable object computing \(\frac2{e^x+e^{-x}}\).
constexpr auto	eve::gd = functor<gd_t>
	elementwise_callable object computing the gudermanian gd: \(\int_0^\infty 1/\cosh x dx\).
constexpr auto	eve::sech = functor<sech_t>
	elementwise_callable object computing \(\frac2{e^x-e^{-x}}\).
constexpr auto	eve::sinh = functor<sinh_t>
	elementwise_callable object computing \(\frac{e^x-e^{-x}}2\).
constexpr auto	eve::sinhc = functor<sinhc_t>
	elementwise_callable object computing \(\frac{e^x-e^{-x}}{2x}\).
constexpr auto	eve::sinhcosh = functor<sinhcosh_t>
	Callable object performing the simultaneous computations of the hyperbolic sine and cosine.
constexpr auto	eve::tanh = functor<tanh_t>
	elementwise_callable object computing \(\frac{e^x-e^{-x}}{e^x+e^{-x}}\).

Variable Documentation

◆ cosh

auto eve::cosh = functor<cosh_t>

inlineconstexpr

elementwise_callable object computing the hyperbolic cosine: \(\frac{e^x+e^{-x}}2\).

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto cosh(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto cosh[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto cosh[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

x: floating value.
c: Conditional expression masking the operation.
m: Logical value masking the operation.

Return value

Returns the elementwise hyperbolic cosine of the input. In particular:
- If the element is \(\pm0\), \(1\) is returned.
- If the element is \(\pm\infty\), \(+\infty\) is returned.
- If the element is a NaN, NaN is returned.
The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 0.25, 0.5, 2.0, -0.0, -0.25,
                  eve::minf(eve::as<double>()), eve::nan(eve::as<double>())};
 
  std::cout << "<- wf                      = " << wf << "\n";
 
  std::cout << "-> cosh(wf)                = " << eve::cosh(wf) << "\n";
  std::cout << "-> cosh[ignore_last(2)](wf)= " << eve::cosh[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> cosh[wf > 0.0](wf)      = " << eve::cosh[wf > 0.0](wf) << "\n";
}

◆ coth

auto eve::coth = functor<coth_t>

inlineconstexpr

elementwise_callable object computing the hyperbolic cotangent: \(\frac{e^x+e^{-x}}{e^x-e^{-x}}\).

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto coth(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto coth[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto coth[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

x: floating value.
c: Conditional expression masking the operation.
m: Logical value masking the operation.

Return value

Returns the elementwise hyperbolic cotangent of the input. In particular:
- If the element is \(\pm0\), \(\pm\infty\) is returned.
- If the element is \(\pm\infty\), \(\pm1\) is returned.
- If the element is a NaN, NaN is returned.
The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 1.0, 2.0, -0.0, -1.0, -2.0,
                  eve::inf(eve::as<double>()), eve::nan(eve::as<double>())};
 
  std::cout << "<- wf                      = " << wf << "\n";
 
  std::cout << "-> coth(wf)                = " << eve::coth(wf) << "\n";
  std::cout << "-> coth[ignore_last(2)](wf)= " << eve::coth[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> coth[wf != -2.0f](wf)   = " << eve::coth[wf != -2.0f](wf) << "\n";
}

◆ csch

auto eve::csch = functor<csch_t>

inlineconstexpr

elementwise_callable object computing \(\frac2{e^x+e^{-x}}\).

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto csch(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto csch[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto csch[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

x: floating value.
c: Conditional expression masking the operation.
m: Logical value masking the operation.

Return value

Returns the elementwise hyperbolic cosecant of the input. In particular:
- If the element is \(\pm0\), \(\pm\infty\) is returned.
- If the element is \(\pm\infty\), \(\pm0\) is returned.
- If the element is a NaN, NaN is returned.
The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 0.25, 0.5, 2.0, -0.0, -0.25,
                  eve::minf(eve::as<double>()), eve::nan(eve::as<double>())};
 
  std::cout << "<- wf                      = " << wf << "\n";
 
  std::cout << "-> csch(wf)                = " << eve::csch(wf) << "\n";
  std::cout << "-> csch[ignore_last(2)](wf)= " << eve::csch[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> csch[wf > 0.0](wf)      = " << eve::csch[wf > 0.0](wf) << "\n";
}

◆ gd

auto eve::gd = functor<gd_t>

inlineconstexpr

elementwise_callable object computing the gudermanian gd: \(\int_0^\infty 1/\cosh x dx\).

The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide<float> wf = [](auto i, auto c) { return 2.f*(i-c/2);};
 
  std::cout << "<- wf                    = " << wf << "\n";
 
  std::cout << "-> gd(wf)                = " << eve::gd(wf) << "\n";
  std::cout << "-> gd[ignore_last(2)](wf)= " << eve::gd[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> gd[wf != -2.0](wf)    = " << eve::gd[wf != -2.0](wf) << "\n";
}

Defined in Header

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto gd(floating_value auto x)                          noexcept; // 1
 
   // Semantic option
   constexpr auto gd[raw](floating_value auto x)                     noexcept; // 2
   constexpr auto gd[fast] (floating_value auto x)                   noexcept; // 2
 
   // Lanes masking
   constexpr auto gd[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto gd[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

x: floating value.
c: Conditional expression masking the operation.
m: Logical value masking the operation.

Return value

Returns the elementwise gudermanian of the input. In particular:
- If the element is \(\pm0\), \(0\) is returned.
- If the element is \(\pm\infty\), \(\pm\pi/2\) is returned.
- If the element is a NaN, NaN is returned.
The raw and fast options use internally less accuate but faster versions.

◆ sech

auto eve::sech = functor<sech_t>

inlineconstexpr

elementwise_callable object computing \(\frac2{e^x-e^{-x}}\).

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto sech(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto sech[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto sech[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

 * `x`: [floating value](@ref eve::floating_value).
 * `c`: [Conditional expression](@ref eve::conditional_expr) masking the operation.
 * `m`: [Logical value](@ref eve::logical_value) masking the operation.

Return value

Returns the elementwise hyperbolic secant of the input. In particular:
- If the element is \(\pm0\), 1 is returned.
- If the element is \(\pm\infty\), \(+0\) is returned.
- If the element is a NaN, NaN is returned.
The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 0.25, 0.5, 2.0, -0.0, -0.25,
                  eve::minf(eve::as<double>()), eve::nan(eve::as<double>())};
 
  std::cout << "<- wf                      = " << wf << "\n";
 
  std::cout << "-> sech(wf)                = " << eve::sech(wf) << "\n";
  std::cout << "-> sech[ignore_last(2)](wf)= " << eve::sech[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> sech[wf > 0.0](wf)      = " << eve::sech[wf > 0.0](wf) << "\n";
}

◆ sinh

auto eve::sinh = functor<sinh_t>

inlineconstexpr

elementwise_callable object computing \(\frac{e^x-e^{-x}}2\).

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto sinh(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto sinh[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto sinh[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

 * `x`: [floating value](@ref eve::floating_value).
 * `c`: [Conditional expression](@ref eve::conditional_expr) masking the operation.
 * `m`: [Logical value](@ref eve::logical_value) masking the operation.

Return value

Returns the elementwise hyperbolic sine of the input. In particular:
- If the element is \(\pm0\), \(\pm0\) is returned.
- If the element is \(\pm\infty\), \(\pm\infty\) returned.
- If the element is a NaN, NaN is returned.
The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 0.25, 0.5, 2.0, -0.0, -0.25,
                  eve::minf(eve::as<double>()), eve::nan(eve::as<double>())};
 
  std::cout << "<- wf                      = " << wf << "\n";
 
  std::cout << "-> sinh(wf)                = " << eve::sinh(wf) << "\n";
  std::cout << "-> sinh[ignore_last(2)](wf)= " << eve::sinh[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> sinh[wf != -2.0f](wf)   = " << eve::sinh[wf != -2.0f](wf) << "\n";
  {
    float const nan = std::numeric_limits<float>::quiet_NaN();
    float buf[8] = {10.f, 0.f, -0.f, nan, 0.5f, 0.5f, 0.5f, 0.5f};
    eve::wide<float> a{&buf[0]};
    std::cout<<a<<std::endl;
    auto r = eve::sinh(a);
    std::cout << r << "\n";
  }
  {
    float buf[8] = {10.f, 0.f, -0.f, 0.f, 0.5f, 0.5f, 0.5f, 0.5f};
    eve::wide<float> a{&buf[0]};
    std::cout<<a<<std::endl;
    auto r = eve::sinh(a);
    std::cout << r << "\n";
  }
 
}

◆ sinhc

auto eve::sinhc = functor<sinhc_t>

inlineconstexpr

elementwise_callable object computing \(\frac{e^x-e^{-x}}{2x}\).

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto sinhc(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto sinhc[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto sinhc[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

x: floating value.

Return value

Returns the elementwise hyperbolic sine of the input divided by the input. In particular:
- If the element is \(\pm0\), \(1\) is returned.
- If the element is \(\pm\infty\), \(\pm\infty\) is returned.
- If the element is a Nan, NaN is returned.
The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 1.5, 2.0, 20.25, -10.0, -2.0,
                  eve::inf(eve::as<double>()), eve::nan(eve::as<double>())};
  std::cout << "<- wf = " << wf << "\n";
 
  std::cout << "-> sinhc(wf)                = " << eve::sinhc(wf) << "\n";
  std::cout << "-> sinhc[ignore_last(2)](wf)= " << eve::sinhc[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> sinhc[wf != -2.0f](wf)   = " << eve::sinhc[wf != -2.0f](wf) << "\n";
}

◆ sinhcosh

auto eve::sinhcosh = functor<sinhcosh_t>

inlineconstexpr

Callable object performing the simultaneous computations of the hyperbolic sine and cosine.

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto sinhcosh(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto sinhcosh[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto sinhcosh[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

 * `x`: [floating value](@ref eve::floating_value).
 * `c`: [Conditional expression](@ref eve::conditional_expr) masking the operation.
 * `m`: [Logical value](@ref eve::logical_value) masking the operation.

}

Return value

1 .The computation returns a tuple-like whose elements are sinh(x) and cosh(x)

The operation is performed conditionally.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 0.25, 0.5, 2.0, -0.0, -0.25,
                  eve::minf(eve::as<double>()), eve::nan(eve::as<double>())};
 
  std::cout << "<- wf           = " << wf << "\n";
 
  std::cout << "-> sinhcosh(wf) = " << eve::sinhcosh(wf) << "\n";
}

◆ tanh

auto eve::tanh = functor<tanh_t>

inlineconstexpr

elementwise_callable object computing \(\frac{e^x-e^{-x}}{e^x+e^{-x}}\).

Header file

#include <eve/module/math.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto tanh(floating_value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto tanh[conditional_expr auto c](floating_value auto x) noexcept; // 2
   constexpr auto tanh[logical_value auto m](floating_value auto x)    noexcept; // 2
}

Parameters

x: floating value.
c: Conditional expression masking the operation.
m: Logical value masking the operation.

Return value

Returns the elementwise hyperbolic tangent of the input. In particular:
- If the element is \(\pm0\), \(\pm0\) is returned.
- If the element is \(\pm\infty\), \(\pm1\) returned.
- If the element is a NaN, NaN is returned.

External references

Example

// revision 1
#include <eve/module/math.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf = {0.0, 0.25, 0.5, 2.0, -0.0, -0.25,
                  eve::minf(eve::as<double>()), eve::nan(eve::as<double>())};
 
  std::cout << "<- wf = " << wf << "\n";
 
  std::cout << "-> tanh(wf)                = " << eve::tanh(wf) << "\n";
  std::cout << "-> tanh[ignore_last(2)](wf)= " << eve::tanh[eve::ignore_last(2)](wf) << "\n";
  std::cout << "-> tanh[wf != -2.0f](wf)   = " << eve::tanh[wf != -2.0f](wf) << "\n";
}

	E.V.E v2023.02.15

Detailed Description

Variables

Variable Documentation

◆ cosh

Header file

Callable Signatures

External references

Example

◆ coth

Header file

Callable Signatures

External references

Example

◆ csch

Header file

Callable Signatures

External references

Example

◆ gd

External references

Example

Callable Signatures

◆ sech

Header file

Callable Signatures

External references

Example

◆ sinh

Header file

Callable Signatures

External references

Example

◆ sinhc

Header file

Callable Signatures

External references

Example

◆ sinhcosh

Header file

Callable Signatures

External references

Example

◆ tanh

Header file

Callable Signatures

External references

Example