This chapter describes functions for performing Discrete Hankel Transforms (DHTs).  The functions are declared in the header file gsl_dht.h.

Definitions
===========

The discrete Hankel transform acts on a vector of sampled data, where the samples are assumed to have been taken at points related to the zeroes of a Bessel function of fixed order; compare this to the case of the discrete Fourier transform, where samples are taken at points related to the zeroes of the sine or cosine function.

Specifically, let f(t) be a function on the unit interval. Then the finite \nu-Hankel transform of f(t) is defined to be the set of numbers g_m given by,

     g_m = \int_0^1 t dt J_\nu(j_(\nu,m)t) f(t),

so that,

     f(t) = \sum_{m=1}^\infty (2 J_\nu(j_(\nu,m)x) / J_(\nu+1)(j_(\nu,m))^2) g_m.

Suppose that f is band-limited in the sense that g_m=0 for m > M. Then we have the following fundamental sampling theorem.

     g_m = (2 / j_(\nu,M)^2)
           \sum_{k=1}^{M-1} f(j_(\nu,k)/j_(\nu,M))
               (J_\nu(j_(\nu,m) j_(\nu,k) / j_(\nu,M)) / J_(\nu+1)(j_(\nu,k))^2).

It is this discrete expression which defines the discrete Hankel transform. The kernel in the summation above defines the matrix of the \nu-Hankel transform of size M-1.  The coefficients of this matrix, being dependent on \nu and M, must be precomputed and stored; the gsl_dht object encapsulates this data.  The allocation function gsl_dht_alloc returns a gsl_dht object which must be properly initialized with gsl_dht_init before it can be used to perform transforms on data sample vectors, for fixed \nu and M, using the gsl_dht_apply function. The implementation allows a scaling of the fundamental interval, for convenience, so that one can assume the function is defined on the interval [0,X], rather than the unit interval.

Notice that by assumption f(t) vanishes at the endpoints of the interval, consistent with the inversion formula and the sampling formula given above. Therefore, this transform corresponds to an orthogonal expansion in eigenfunctions of the Dirichlet problem for the Bessel differential equation.

Functions
=========

 -- Function: gsl_dht * gsl_dht_alloc (size_t SIZE)
     This function allocates a Discrete Hankel transform object of size SIZE.

 -- Function: int gsl_dht_init (gsl_dht * T, double NU, double XMAX)
     This function initializes the transform T for the given values of NU and X.

 -- Function: gsl_dht * gsl_dht_new (size_t SIZE, double NU, double XMAX)
     This function allocates a Discrete Hankel transform object of size SIZE and initializes it for the given values of NU and X.

 -- Function: void gsl_dht_free (gsl_dht * T)
     This function frees the transform T.

 -- Function: int gsl_dht_apply (const gsl_dht * T, double * F_IN, double * F_OUT)
     This function applies the transform T to the array F_IN whose size is equal to the size of the transform.  The result is stored in the array F_OUT which must be of the same length.

 -- Function: double gsl_dht_x_sample (const gsl_dht * T, int N)
     This function returns the value of the N-th sample point in the unit interval, $(j_\nu,n+1 / j_\nu,M) X$ (j_{\nu,n+1}/j_{\nu,M}) X. These are the points where the function f(t) is assumed to be sampled.

 -- Function: double gsl_dht_k_sample (const gsl_dht * T, int N)
     This function returns the value of the N-th sample point in ``k-space'', $j_\nu,n+1 / X$ j_{\nu,n+1}/X.

References and Further Reading
==============================

The algorithms used by these functions are described in the following papers,

  H. Fisk Johnson, Comp. Phys. Comm. 43, 181 (1987).

  D. Lemoine, J. Chem. Phys. 101, 3936 (1994).