bessel_k

kyosu::bessel_k = eve::functor<bessel_k_t>

inlineconstexpr

Computes the spherical or cylindrical modified Bessel functions of the second kind, 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_k(N n, T z)                                 noexcept; //1
   template<eve;scalar_value N, kyosu::concepts::real T>              constexpr T    bessel_k(N n, T z)                                 noexcept; //1
   template<eve;scalar_value N, kyosu::concepts::complex T, size_t S> constexpr auto bessel_k(N n, T z, std::span<Z, S> cis)            noexcept; //2
   template<eve;scalar_value N, kyosu::concepts::real T, size_t S>    constexpr T    bessel_k(N n, T z, std::span<Z, S> cis)            noexcept; //2
   template<eve;scalar_value N, kyosu::concepts::cayley_dickson T>    constexpr auto bessel_k[spherical](N n, T z)                      noexcept; //3
   template<eve;scalar_value N, kyosu::concepts::real T>              constexpr T    bessel_k[spherical](N n, T z)                      noexcept; //3
   template<eve;scalar_value N, kyosu::concepts::complex T, size_t S> constexpr auto bessel_k[spherical](N n, T z, std::span<Z, S> sis) noexcept; //4
   template<eve;scalar_value N, kyosu::concepts::real T, size_t S>    constexpr T    bessel_k[spherical](N n, T z, std::span<Z, S> sis) noexcept; //4
}

Parameters

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

Return value

1. returns \(K_n\)(z) (cylindrical).
2. Same as 1, but cis is filled by the lesser orders.
3. returns \(k_n\)(z) (spherical).
4. Same as 3, but sis is filled by the lesser orders.

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 option can be used and its result is identical to the regular call (no option).

External references

• Wolfram MathWorld: Modified Bessel Function of the second Kind
• Wolfram MathWorld: Modified Spherical Bessel Function of the second Kind
• Wikipedia: Bessel function
• DLMF: Modified 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)> ks(nb);
  kyosu::bessel_k(v, z, std::span(ks));
  auto inc = eve::sign(v);
  auto v0 =  eve::frac(v);
  for(int n=0; n < nb; ++n)
  {
    std::cout << "ks[" << n << "]              = " << ks[n] << std::endl;
    std::cout << "bessel_k[cylindrical](v0, z) = " << kyosu::bessel_k(v0, z) << std::endl;
    v0 += inc;
  }
  return 0;
}