bessel_h

kyosu::bessel_h = eve::functor<bessel_h_t>

inlineconstexpr

Computes the spherical or cylindrical Hankel functions, extended to the complex plane and cayley_dickson algebras.

#include <kyosu/functions.hpp>

Callable Signatures

namespace kyosu
{
   template<eve;scalar_value N, kyosu::concepts::cayley_dickson T>    constexpr auto bessel_h(N n, T z)                                       noexcept; //1
   template<eve;scalar_value N, kyosu::concepts::real T>              constexpr T    bessel_h(N n, T z)                                       noexcept; //1
   template<eve;scalar_value N, kyosu::concepts::complex T, size_t S> constexpr auto bessel_h(N n, T z, std::span<Z, S> chs)                  noexcept; //2
   template<eve;scalar_value N, kyosu::concepts::real T, size_t S>    constexpr T    bessel_h(N n, T z, std::span<Z, S> chs)                  noexcept; //2
 
   template<eve;scalar_value N, kyosu::concepts::cayley_dickson T>    constexpr auto bessel_h[spherical](N n, T z)                            noexcept; //3
   template<eve;scalar_value N, kyosu::concepts::real T>              constexpr T    bessel_h[spherical](N n, T z)                            noexcept; //3
   template<eve;scalar_value N, kyosu::concepts::complex T, size_t S> constexpr auto bessel_h[spherical](N n, T z, std::span<Z, S> shs)       noexcept; //4
   template<eve;scalar_value N, kyosu::concepts::real T, size_t S>    constexpr T    bessel_h[spherical](N n, T z, std::span<Z, S> shs)       noexcept; //4
 
   template<eve;scalar_value N, kyosu::concepts::cayley_dickson T>    constexpr auto bessel_h[kind_2](/*any previous overloads*/)             noexcept; //5
   template<eve;scalar_value N, kyosu::concepts::cayley_dickson T>    constexpr auto bessel_h[kind_2][spherical](/*any previous overloads*/)  noexcept; //6
}

Parameters

• n: scalar order (integral or floating)
• z: Value to process.
• shs, chs : std::span of T

Return value

1. returns \(H_n\)(z) (cylindrical first kind).
2. Same as 1, but chs is filled by the lesser orders.
3. returns \(h_n\)(z) (spherical).
4. Same as 3, but shs is filled by the lesser orders.
5. Same as 1., 2., 3., 4. but returns second kind Hankel functions values.
6. Same as 1., 2., 3., 4. but returns second kind spherical Hankel functions values.

Note

• Let \( i = \lfloor |n| \rfloor \) and \( j=|n|-i\). If \(n\) is positive the lesser order are \((\pm j, \pm(j+1), \dots, \pm(j+i)) \) with \(+\) sign if \(n\) is positive and \(-\) sign if \(n\) is negative.
• The span parameters are filled according the minimum of their allocated size and \(i\).
• cylindical and kind_1 options can be used and their results are identical to the regular call (no option).

External references

• Wolfram MathWorld: Hankel Function
• Wikipedia: Bessel function
• DLMF: Bessel functions

Example

#include <kyosu/kyosu.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  std::cout<< std::setprecision(16) << std::endl;
  using w_t = eve::wide<double, eve::fixed<2>>;
  auto z = kyosu::complex(w_t(20.0, 1.5), w_t(0.0, 1.5));
  auto v = -(2+1/3.0);
  int nb = int(eve::abs(v)+1);
  std::cout << "z                    " << z << std::endl;
  std::vector<decltype(z)> hs(nb);
  kyosu::bessel_h(v, z, std::span(hs));
  auto inc = eve::sign(v);
  auto v0 =  eve::frac(v);
  for(int n=0; n < nb; ++n)
  {
    std::cout << "hs[" << n << "]              = " << hs[n] << std::endl;
    std::cout << "bessel_h[cylindrical](v0, z) = " << kyosu::bessel_h(v0, z) << std::endl;
    v0 += inc;
  }
  return 0;
}