Bessel library: A C++ library with routines to evaluate Bessel functions of real or complex arguments

See Refs. [1–3] for more information concerning Bessel functions and their computation.

How to use

The library is in a header-only library style, i.e., there is nothing to build. Therefore, it is very straightforward, you only need to include the bessel-library.hpp file into your project (see the usage examples inside the functions listed in the markdown Available features).

Available features

The following contains a list of the C++ available functions. Click on each for more information about parameters, implementation, examples, and so on.

J_ν(z)—Cylindrical Bessel function of the first kind

bessel::cyl_j(_nu, _z, _scaled, _flags)

Description: Calculation of cylindrical Bessel function of the first kind of integer or real order $\nu$ and real or complex argument $z$, that is, $J_\nu(z)$.
Input parameters:
- _nu: Integer or real order $\nu$ in T1 type, with T1 being int, float or double.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $J_\nu(z)$ in T2 type; for complex $z$, the complex value of $J_\nu(z)$ in std::complex<T2> form. If _scaled = true, it returns $J_\nu(z)\textrm{ }e^{-|\text{Im}(z)|}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (5.4.2) and (5.5.4) of Ref. [2] for, respectively, $\nu \in \mathtt{Z}$ and $\nu \notin \mathtt{Z}$; in the latter case, it yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
 // Declaration of variables
 double nu = 3.5;
 std::complex<double> z = std::complex<double>(1.0, 2.3);
 std::complex<double> result;
 std::complex<double> scaled_result;
 
 // Calculation of a function
 result = bessel::cyl_j( nu, z );

 // Alternative calculation with flags
 result = bessel::cyl_j( nu, z, false, true );

 // Calculation of the scaled version
 scaled_result = bessel::cyl_j( nu, z, true );

 // Printing the results
 std::cout << result << std::endl;
 std::cout << scaled_result;
}

bessel::cyl_j(_nu, _n, _z, _cyl_j, _scaled, _flags)

Description: Concomitant calculation of a number $n \geq 1$ of cylindrical Bessel functions of the first kind of integer or real orders $\nu+k-1$, where $k=1,2,...,n$, and real or complex argument $z$, that is, the sequence $J_\nu(z), J_{\nu+1}(z), ..., J_{\nu+n-1}(z)$.
Input parameters:
- _nu: Integer or real initial order $\nu$ of the sequence in T1 type, T1 being int, float or double.
- _n: Integer greater than zero number $n$ in int type.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _cyl_j: Empty array of size _n, to sequentially store $J_{\nu+k-1}(z)$ for $k=1,2,...,n$, in T2 type for real $z$ or in std::complex<T2> form for complex $z$.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, the real values of $J_\nu(z)$, for $k=1,2,...,n$, are stored in the array _cyl_j in T2 type; for complex $z$, the complex values of $J_{\nu+k-1}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_j in std::complex<T2> form. If _scaled = true, $J_{\nu+k-1}(z)\textrm{ }e^{-|\text{Im}(z)|}$, for $k=1,2,...,n$, are stored.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (5.4.2) and (5.5.4) of Ref. [2] for, respectively, $\nu \in \mathtt{Z}$ and $\nu \notin \mathtt{Z}$; in the latter case, it yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = -1.7;
  std::complex<double> z = std::complex<double>(1.2, 5.3);
  std::complex<double> results [3];
  std::complex<double> scaled_results [3];
  
  // Calculation of functions
  bessel::cyl_j( nu, 3, z, results );

  // Alternative calculation with flags
  bessel::cyl_j( nu, 3, z, results, false, true );

  // Calculation of the scaled versions
  bessel::cyl_j( nu, 3, z, scaled_results, true );

  // Printing the results
  std::cout << results[0] << ", " << results[1] << ", " << results[2] << std::endl;
  std::cout << scaled_results[0] << ", " << scaled_results[1] << ", " << scaled_results[2];
}

Y_ν(z)—Cylindrical Bessel function of the second kind

bessel::cyl_y(_nu, _z, _scaled, _flags)

Description: Calculation of cylindrical Bessel function of the second kind of integer or real order $\nu$ and real or complex argument $z$, that is, $Y_\nu(z)$. Such function is also known as Weber function or Neumann function, and sometimes written as $N_\nu(z)$.
Input parameters:
- _nu: Integer or real order $\nu$ in T1 type, with T1 being int, float or double.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $Y_\nu(z)$ in T2 type; for complex $z$, the complex value of $Y_\nu(z)$ in std::complex<T2> form. If _scaled = true, it returns $Y_\nu(z)\textrm{ }e^{-|\text{Im}(z)|}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (5.4.2) and (5.5.4) of Ref. [2] for, respectively, $\nu \in \mathtt{Z}$ and $\nu \notin \mathtt{Z}$. When $|z|=0$, it yields $-\infty$ if $\nu=0$, or $\infty+i\infty$ otherwise.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = 3.5;
  std::complex<double> z = std::complex<double>(1.0, 2.3);
  std::complex<double> result;
  std::complex<double> scaled_result;

  // Calculation of a function
  result = bessel::cyl_y( nu, z );

  // Alternative calculation with flags
  result = bessel::cyl_y( nu, z, false, true );

  // Calculation of the scaled version
  scaled_result = bessel::cyl_y( nu, z, true );
  
  // Printing the results
  std::cout << result << std::endl;
  std::cout << scaled_result;
}

bessel::cyl_y(_nu, _n, _z, _cyl_y, _scaled, _flags)

Description: Concomitant calculation of a number $n \geq 1$ of cylindrical Bessel functions of the second kind of integer or real orders $\nu+k-1$, where $k=1,2,...,n$, and real or complex argument $z$, that is, the sequence $Y_\nu(z), Y_{\nu+1}(z), ..., Y_{\nu+n-1}(z)$. Such functions are also known as Weber functions or Neumann functions.
Input parameters:
- _nu: Integer or real initial order $\nu$ of the sequence in T1 type, T1 being int, float or double.
- _n: Integer greater than zero number $n$ in int type.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _cyl_y: Empty array of size _n, to sequentially store $Y_{\nu+k-1}(z)$ for $k=1,2,...,n$, in T2 type for real $z$ or in std::complex<T2> form for complex $z$.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, the real values of $Y_\nu(z)$, for $k=1,2,...,n$, are stored in the array _cyl_y in T2 type; for complex $z$, the complex values of $Y_{\nu+k-1}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_y in std::complex<T2> form. If _scaled = true, $Y_{\nu+k-1}(z)\textrm{ }e^{-|\text{Im}(z)|}$, for $k=1,2,...,n$, are stored.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (5.4.2) and (5.5.4) of Ref. [2] for, respectively, $\nu \in \mathtt{Z}$ and $\nu \notin \mathtt{Z}$. When $|z|=0$, it yields $-\infty$ if $\nu=0$, or $\infty+i\infty$ otherwise.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = -1.7;
  std::complex<double> z = std::complex<double>(1.2, 5.3);
  std::complex<double> results [3];
  std::complex<double> scaled_results [3];
  
  // Calculation of functions
  bessel::cyl_y( nu, 3, z, results );

  // Alternative calculation with flags
  bessel::cyl_y( nu, 3, z, results, false, true );

  // Calculation of the scaled versions
  bessel::cyl_y( nu, 3, z, scaled_results, true );

  // Printing the results
  std::cout << results[0] << ", " << results[1] << ", " << results[2] << std::endl;
  std::cout << scaled_results[0] << ", " << scaled_results[1] << ", " << scaled_results[2];
}

H_ν⁽¹⁾(z)—Cylindrical Hankel function of the first kind

bessel::cyl_h1(_nu, _z, _scaled, _flags)

Description: Calculation of cylindrical Hankel function of the first kind of integer or real order $\nu$ and real or complex argument $z$, that is, $H_\nu^{(1)}(z)$. Hankel functions are also known as Bessel function of the third kind.
Input parameters:
- _nu: Integer or real order $\nu$ in T1 type, with T1 being int, float or double.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $H_\nu^{(1)}(z)$ in T2 type; for complex $z$, the complex value of $H_\nu^{(1)}(z)$ in std::complex<T2> form. If _scaled = true, it returns $H_\nu^{(1)}(z)\textrm{ }e^{-iz}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eq. (9.1.6) of Ref. [1]. It yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
 // Declaration of variables
 double nu = 3.5;
 std::complex<double> z = std::complex<double>(1.0, 2.3);
 std::complex<double> result;
 std::complex<double> scaled_result;
 
 // Calculation of a function
 result = bessel::cyl_h1( nu, z );

 // Alternative calculation with flags
 result = bessel::cyl_h1( nu, z, false, true );

 // Calculation of the scaled version
 scaled_result = bessel::cyl_h1( nu, z, true );

 // Printing the results
 std::cout << result << std::endl;
 std::cout << scaled_result;
}

bessel::cyl_h1(_nu, _n, _z, _cyl_h1, _scaled, _flags)

Description: Concomitant calculation of a number $n \geq 1$ of cylindrical Hankel functions of the first kind of integer or real orders $\nu+k-1$, where $k=1,2,...,n$, and real or complex argument $z$, that is, the sequence $H_\nu^{(1)}(z), H_{\nu+1}^{(1)}(z), ..., H_{\nu+n-1}^{(1)}(z)$. Hankel functions are also known as Bessel function of the third kind.
Input parameters:
- _nu: Integer or real initial order $\nu$ of the sequence in T1 type, T1 being int, float or double.
- _n: Integer greater than zero number $n$ in int type.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _cyl_h1: Empty array of size _n, to sequentially store $H_{\nu+k-1}^{(1)}(z)$ for $k=1,2,...,n$, in T2 type for real $z$ or in std::complex<T2> form for complex $z$.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, the real values of $H_{\nu+k-1}^{(1)}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_h1 in T2 type; for complex $z$, the complex values of $H_{\nu+k-1}^{(1)}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_h1 in std::complex<T2> form. If _scaled = true, $H_{\nu+k-1}^{(1)}(z)\textrm{ }e^{-iz}$, for $k=1,2,...,n$, are stored.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eq. (9.1.6) of Ref. [1]. It yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = -1.7;
  std::complex<double> z = std::complex<double>(1.2, 5.3);
  std::complex<double> results [3];
  std::complex<double> scaled_results [3];
  
  // Calculation of functions
  bessel::cyl_h1( nu, 3, z, results );

  // Alternative calculation with flags
  bessel::cyl_h1( nu, 3, z, results, false, true );

  // Calculation of the scaled versions
  bessel::cyl_h1( nu, 3, z, scaled_results, true );

  // Printing the results
  std::cout << results[0] << ", " << results[1] << ", " << results[2] << std::endl;
  std::cout << scaled_results[0] << ", " << scaled_results[1] << ", " << scaled_results[2];
}

H_ν⁽²⁾(z)—Cylindrical Hankel function of the second kind

bessel::cyl_h2(_nu, _z, _scaled, _flags)

Description: Calculation of cylindrical Hankel function of the second kind of integer or real order $\nu$ and real or complex argument $z$, that is, $H_\nu^{(2)}(z)$. Hankel functions are also known as Bessel function of the third kind.
Input parameters:
- _nu: Integer or real order $\nu$ in T1 type, with T1 being int, float or double.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $H_\nu^{(2)}(z)$ in T2 type; for complex $z$, the complex value of $H_\nu^{(2)}(z)$ in std::complex<T2> form. If _scaled = true, it returns $H_\nu^{(2)}(z)\textrm{ }e^{iz}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eq. (9.1.6) of Ref. [1]. It yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
 // Declaration of variables
 double nu = 3.5;
 std::complex<double> z = std::complex<double>(1.0, 2.3);
 std::complex<double> result;
 std::complex<double> scaled_result;
 
 // Calculation of a function
 result = bessel::cyl_h2( nu, z );

 // Alternative calculation with flags
 result = bessel::cyl_h2( nu, z, false, true );

 // Calculation of the scaled version
 scaled_result = bessel::cyl_h2( nu, z, true );

 // Printing the results
 std::cout << result << std::endl;
 std::cout << scaled_result;
}

bessel::cyl_h2(_nu, _n, _z, _cyl_h2, _scaled, _flags)

Description: Concomitant calculation of a number $n \geq 1$ of cylindrical Hankel functions of the second kind of integer or real orders $\nu+k-1$, where $k=1,2,...,n$, and real or complex argument $z$, that is, the sequence $H_\nu^{(2)}(z), H_{\nu+1}^{(2)}(z), ..., H_{\nu+n-1}^{(2)}(z)$. Hankel functions are also known as Bessel function of the third kind.
Input parameters:
- _nu: Integer or real initial order $\nu$ of the sequence in T1 type, T1 being int, float or double.
- _n: Integer greater than zero number $n$ in int type.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _cyl_h2: Empty array of size _n, to sequentially store $H_{\nu+k-1}^{(2)}(z)$ for $k=1,2,...,n$, in T2 type for real $z$ or in std::complex<T2> form for complex $z$.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, the real values of $H_{\nu+k-1}^{(2)}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_h2 in T2 type; for complex $z$, the complex values of $H_{\nu+k-1}^{(2)}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_h2 in std::complex<T2> form. If _scaled = true, $H_{\nu+k-1}^{(2)}(z)\textrm{ }e^{iz}$, for $k=1,2,...,n$, are stored.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eq. (9.1.6) of Ref. [1]. It yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = -1.7;
  std::complex<double> z = std::complex<double>(1.2, 5.3);
  std::complex<double> results [3];
  std::complex<double> scaled_results [3];
  
  // Calculation of functions
  bessel::cyl_h2( nu, 3, z, results );

  // Alternative calculation with flags
  bessel::cyl_h2( nu, 3, z, results, false, true );

  // Calculation of the scaled versions
  bessel::cyl_h2( nu, 3, z, scaled_results, true );

  // Printing the results
  std::cout << results[0] << ", " << results[1] << ", " << results[2] << std::endl;
  std::cout << scaled_results[0] << ", " << scaled_results[1] << ", " << scaled_results[2];
}

I_ν(z)—Modified cylindrical Bessel function of the first kind

bessel::cyl_i(_nu, _z, _scaled, _flags)

Description: Calculation of modified cylindrical Bessel function of the first kind of integer or real order $\nu$ and real or complex argument $z$, that is, $I_\nu(z)$. Such function is also known as cylindrical Bessel function of imaginary argument or sometimes as hyperbolic Bessel function.
Input parameters:
- _nu: Integer or real order $\nu$ in T1 type, with T1 being int, float or double.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $I_\nu(z)$ in T2 type; for complex $z$, the complex value of $I_\nu(z)$ in std::complex<T2> form. If _scaled = true, it returns $I_\nu(z)\textrm{ }e^{-|\text{Re}(z)|}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (6.1.5) and (6.5.4) of Ref. [2] for, respectively, $\nu \in \mathtt{Z}$ and $\nu \notin \mathtt{Z}$; in the latter case, it yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
 // Declaration of variables
 double nu = 3.5;
 std::complex<double> z = std::complex<double>(1.0, 2.3);
 std::complex<double> result;
 std::complex<double> scaled_result;
 
 // Calculation of a function
 result = bessel::cyl_i( nu, z );

 // Alternative calculation with flags
 result = bessel::cyl_i( nu, z, false, true );

 // Calculation of the scaled version
 scaled_result = bessel::cyl_i( nu, z, true );

 // Printing the results
 std::cout << result << std::endl;
 std::cout << scaled_result;
}

bessel::cyl_i(_nu, _n, _z, _cyl_i, _scaled, _flags)

Description: Concomitant calculation of a number $n \geq 1$ of modified cylindrical Bessel functions of the first kind of integer or real orders $\nu+k-1$, where $k=1,2,...,n$, and real or complex argument $z$, that is, the sequence $I_\nu(z), I_{\nu+1}(z), ..., I_{\nu+n-1}(z)$. Such functions are also known as cylindrical Bessel functions of imaginary argument or sometimes as hyperbolic Bessel functions.
Input parameters:
- _nu: Integer or real initial order $\nu$ of the sequence in T1 type, T1 being int, float or double.
- _n: Integer greater than zero number $n$ in int type.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _cyl_i: Empty array of size _n, to sequentially store $I_{\nu+k-1}(z)$ for $k=1,2,...,n$, in T2 type for real $z$ or in std::complex<T2> form for complex $z$.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, the real values of $I_\nu(z)$, for $k=1,2,...,n$, are stored in the array _cyl_i in T2 type; for complex $z$, the complex values of $I_{\nu+k-1}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_i in std::complex<T2> form. If _scaled = true, $I_{\nu+k-1}(z)\textrm{ }e^{-|\text{Re}(z)|}$, for $k=1,2,...,n$, are stored.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (6.1.5) and (6.5.4) of Ref. [2] for, respectively, $\nu \in \mathtt{Z}$ and $\nu \notin \mathtt{Z}$; in the latter case, it yields $\infty+i\infty$ when $|z|=0$.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = -1.7;
  std::complex<double> z = std::complex<double>(1.2, 5.3);
  std::complex<double> results [3];
  std::complex<double> scaled_results [3];
  
  // Calculation of functions
  bessel::cyl_i( nu, 3, z, results );

  // Alternative calculation with flags
  bessel::cyl_i( nu, 3, z, results, false, true );

  // Calculation of the scaled versions
  bessel::cyl_i( nu, 3, z, scaled_results, true );

  // Printing the results
  std::cout << results[0] << ", " << results[1] << ", " << results[2] << std::endl;
  std::cout << scaled_results[0] << ", " << scaled_results[1] << ", " << scaled_results[2];
}

K_ν(z)—Modified cylindrical Bessel function of the second kind

bessel::cyl_k(_nu, _z, _scaled, _flags)

Description: Calculation of modified cylindrical Bessel function of the second kind of integer or real order $\nu$ and real or complex argument $z$, that is, $K_\nu(z)$. Such function is also known as Basset function or MacDonald function.
Input parameters:
- _nu: Integer or real order $\nu$ in T1 type, with T1 being int, float or double.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $K_\nu(z)$ in T2 type; for complex $z$, the complex value of $K_\nu(z)$ in std::complex<T2> form. If _scaled = true, it returns $K_\nu(z)\textrm{ }e^{z}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (6.5.5) of Ref. [2]. When $|z|=0$, it yields $\infty$ if $\nu=0$, or $\infty+i\infty$ otherwise.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = 3.5;
  std::complex<double> z = std::complex<double>(1.0, 2.3);
  std::complex<double> result;
  std::complex<double> scaled_result;

  // Calculation of a function
  result = bessel::cyl_k( nu, z );

  // Alternative calculation with flags
  result = bessel::cyl_k( nu, z, false, true );

  // Calculation of the scaled version
  scaled_result = bessel::cyl_k( nu, z, true );
  
  // Printing the results
  std::cout << result << std::endl;
  std::cout << scaled_result;
}

bessel::cyl_k(_nu, _n, _z, _cyl_k, _scaled, _flags)

Description: Concomitant calculation of a number $n \geq 1$ of modified cylindrical Bessel functions of the second kind of integer or real orders $\nu+k-1$, where $k=1,2,...,n$, and real or complex argument $z$, that is, the sequence $K_\nu(z), K_{\nu+1}(z), ..., K_{\nu+n-1}(z)$. Such functions are also known as Basset functions or MacDonald functions.
Input parameters:
- _nu: Integer or real initial order $\nu$ of the sequence in T1 type, T1 being int, float or double.
- _n: Integer greater than zero number $n$ in int type.
- _z: Real argument $z$ in T2 type, or complex argument $z$ in std::complex<T2> form, with T2 being float or double.
- _cyl_k: Empty array of size _n, to sequentially store $K_{\nu+k-1}(z)$ for $k=1,2,...,n$, in T2 type for real $z$ or in std::complex<T2> form for complex $z$.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, the real values of $K_\nu(z)$, for $k=1,2,...,n$, are stored in the array _cyl_k in T2 type; for complex $z$, the complex values of $K_{\nu+k-1}(z)$, for $k=1,2,...,n$, are stored in the array _cyl_k in std::complex<T2> form. If _scaled = true, $K_{\nu+k-1}(z)\textrm{ }e^{z}$, for $k=1,2,...,n$, are stored.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library. Negative orders are handled by Eqs. (6.5.5) of Ref. [2]. When $|z|=0$, it yields $\infty$ if $\nu=0$, or $\infty+i\infty$ otherwise.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  double nu = -1.7;
  std::complex<double> z = std::complex<double>(1.2, 5.3);
  std::complex<double> results [3];
  std::complex<double> scaled_results [3];
  
  // Calculation of functions
  bessel::cyl_k( nu, 3, z, results );

  // Alternative calculation with flags
  bessel::cyl_k( nu, 3, z, results, false, true );

  // Calculation of the scaled versions
  bessel::cyl_k( nu, 3, z, scaled_results, true );

  // Printing the results
  std::cout << results[0] << ", " << results[1] << ", " << results[2] << std::endl;
  std::cout << scaled_results[0] << ", " << scaled_results[1] << ", " << scaled_results[2];
}

Ai(z)—Airy function of the first kind

bessel::airy_ai(_z, _scaled, _flags)

Description: Calculation of Airy function of the first kind of real or complex argument $z$, that is, $\textrm{Ai}(z)$.
Input parameters:
- _z: Real argument $z$ in T1 type, or complex argument $z$ in std::complex<T1> form, with T1 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $\textrm{Ai}(z)$ in T1 type; for complex $z$, the complex value of $\textrm{Ai}(z)$ in std::complex<T1> form. If _scaled = true, it returns $\textrm{Ai}(z)\textrm{ }e^{(2/3)z\sqrt{z}}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  std::complex<double> z = std::complex<double>(1.0, 2.3);
  std::complex<double> result;
  std::complex<double> scaled_result;

  // Calculation of a function
  result = bessel::airy_ai( z );

  // Alternative calculation with flags
  result = bessel::airy_ai( z, false, true );

  // Calculation of the scaled version
  scaled_result = bessel::airy_ai( z, true );
  
  // Printing the results
  std::cout << result << std::endl;
  std::cout << scaled_result;
}

Bi(z)—Airy function of the second kind

bessel::airy_bi(_z, _scaled, _flags)

Description: Calculation of Airy function of the second kind of real or complex argument $z$, that is, $\textrm{Bi}(z)$.
Input parameters:
- _z: Real argument $z$ in T1 type, or complex argument $z$ in std::complex<T1> form, with T1 being float or double.
- _scaled: Optional bool parameter. If true, returns a scaled version of the result (see Output topic below).
- _flags: Optional bool parameter. If true, print error and warning messages.
Output: For real $z$, it returns $\textrm{Bi}(z)$ in T1 type; for complex $z$, the complex value of $\textrm{Bi}(z)$ in std::complex<T1> form. If _scaled = true, it returns $\textrm{Bi}(z)\textrm{ }e^{-|\textrm{Re}[(2/3)z\sqrt{z}]|}$.
Implementation: In general, the routine is based on the D. E. Amos Fortran 77 routines of the SLATEC library [3]. Such Fortran routines, and all their dependencies, were carefully translated to be used in this library.

Usage example:

#include <iostream>
#include "bessel-library.hpp"

int main()
{
  // Declaration of variables
  std::complex<double> z = std::complex<double>(1.0, 2.3);
  std::complex<double> result;
  std::complex<double> scaled_result;

  // Calculation of a function
  result = bessel::airy_bi( z );

  // Alternative calculation with flags
  result = bessel::airy_bi( z, false, true );

  // Calculation of the scaled version
  scaled_result = bessel::airy_bi( z, true );
  
  // Printing the results
  std::cout << result << std::endl;
  std::cout << scaled_result;
}

New features coming soon

Implementation of spherical versions of the functions.

Authorship

The codes and routines were developed and are updated by Jhonas O. de Sarro (@jodesarro). They are mainly written based on, or a translation of, the content of Refs. [1–3].

Licensing

This project is protected under MIT License.

References

[1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions With Formulas, Graphs, and Mathematical Tables. Washington, D. C.: National Bureau of Standards, 1972.
[2] S. Zhang and J. Jin, Computation of Special Functions. New York: Wiley, 1996.
[3] SLATEC Common Mathematical Library, Version 4.1, July 1993. Comprehensive software library containing over 1400 general purpose mathematical and statistical routines written in Fortran 77. Available at https://www.netlib.org/slatec/ (Accessed: May 25, 2024).

jodesarro / bessel-library

Bessel library: A C++ library with routines to evaluate Bessel functions of real or complex arguments

How to use

Available features

J_ν(z)—Cylindrical Bessel function of the first kind

Y_ν(z)—Cylindrical Bessel function of the second kind

H_ν⁽¹⁾(z)—Cylindrical Hankel function of the first kind

H_ν⁽²⁾(z)—Cylindrical Hankel function of the second kind

I_ν(z)—Modified cylindrical Bessel function of the first kind

K_ν(z)—Modified cylindrical Bessel function of the second kind

Ai(z)—Airy function of the first kind

Bi(z)—Airy function of the second kind

New features coming soon

Authorship

Licensing

References

About

Languages

Bessel library: A C++ library with routines to evaluate Bessel functions of real or complex arguments

How to use

Available features

Jν(z)—Cylindrical Bessel function of the first kind

Yν(z)—Cylindrical Bessel function of the second kind

Hν(1)(z)—Cylindrical Hankel function of the first kind

Hν(2)(z)—Cylindrical Hankel function of the second kind

Iν(z)—Modified cylindrical Bessel function of the first kind

Kν(z)—Modified cylindrical Bessel function of the second kind

Ai(z)—Airy function of the first kind

Bi(z)—Airy function of the second kind

New features coming soon

Authorship

Licensing

References

About

Languages

J_ν(z)—Cylindrical Bessel function of the first kind

Y_ν(z)—Cylindrical Bessel function of the second kind

H_ν⁽¹⁾(z)—Cylindrical Hankel function of the first kind

H_ν⁽²⁾(z)—Cylindrical Hankel function of the second kind

I_ν(z)—Modified cylindrical Bessel function of the first kind

K_ν(z)—Modified cylindrical Bessel function of the second kind