bessel_i

auto kyosu::bessel_i = eve::functor<bessel_i_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, cayley_dickson_like T>    constexpr auto bessel_i(N n, T z)                                 noexcept; //1
   template<eve;scalar_value N, complex_like T, size_t S> constexpr auto bessel_i(N n, T z, std::span<Z, S> cis)            noexcept; //2
   template<eve;scalar_value N, cayley_dickson_like T>    constexpr auto bessel_i[spherical](N n, T z)                      noexcept; //3
   template<eve;scalar_value N, complex_like T, size_t S> constexpr auto bessel_i[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 \(I_n\)(z) (cylindrical).
2. Same as 1, but cis is filled by the lesser orders.
3. returns \(i_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 First Kind
• Wolfram MathWorld: Spherical Modified Bessel Function of the First Kind
• Wikipedia: Bessel function
• DLMF: Modified Bessel functions

Example

#include <eve/wide.hpp>
#include <iomanip>
#include <iostream>
#include <kyosu/kyosu.hpp>
 
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)> js(nb);
  kyosu::bessel_i(v, z, std::span(js));
  auto inc = eve::sign(v);
  auto v0 = eve::frac(v);
  for (int n = 0; n < nb; ++n)
  {
    std::cout << "js[" << n << "]              = " << js[n] << std::endl;
    std::cout << "bessel_i[cylindrical](v0, z) = " << kyosu::bessel_i(v0, z) << std::endl;
    v0 += inc;
  }
  return 0;
}