src/parsec/disk-image/parsec/parsec-benchmark/pkgs/libs/gsl/src/doc/dht.texi

@cindex discrete Hankel transforms
@cindex Hankel transforms, discrete
@cindex transforms, Hankel
This chapter describes functions for performing Discrete Hankel
Transforms (DHTs).  The functions are declared in the header file
@file{gsl_dht.h}.

@menu
* Discrete Hankel Transform Definition::  
* Discrete Hankel Transform Functions::  
* Discrete Hankel Transform References::  
@end menu

@node Discrete Hankel Transform Definition
@section 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 @math{f(t)} be a function on the unit interval.
Then the finite @math{\nu}-Hankel transform of @math{f(t)} is defined
to be the set of numbers @math{g_m} given by,
@tex
\beforedisplay
$$
g_m = \int_0^1 t dt\, J_\nu(j_{\nu,m}t) f(t),
$$
\afterdisplay
@end tex
@ifinfo
@example
g_m = \int_0^1 t dt J_\nu(j_(\nu,m)t) f(t),
@end example

@end ifinfo
@noindent
so that,
@tex
\beforedisplay
$$
f(t) = \sum_{m=1}^\infty {{2 J_\nu(j_{\nu,m}x)}\over{J_{\nu+1}(j_{\nu,m})^2}} g_m.
$$
\afterdisplay
@end tex
@ifinfo
@example
f(t) = \sum_@{m=1@}^\infty (2 J_\nu(j_(\nu,m)x) / J_(\nu+1)(j_(\nu,m))^2) g_m.
@end example

@end ifinfo
@noindent
Suppose that @math{f} is band-limited in the sense that
@math{g_m=0} for @math{m > M}. Then we have the following
fundamental sampling theorem.
@tex
\beforedisplay
$$
g_m = {{2}\over{j_{\nu,M}^2}}
      \sum_{k=1}^{M-1} f\left({{j_{\nu,k}}\over{j_{\nu,M}}}\right)
          {{J_\nu(j_{\nu,m} j_{\nu,k} / j_{\nu,M})}\over{J_{\nu+1}(j_{\nu,k})^2}}.
$$
\afterdisplay
@end tex
@ifinfo
@example
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).
@end example

@end ifinfo
@noindent
It is this discrete expression which defines the discrete Hankel
transform. The kernel in the summation above defines the matrix of the
@math{\nu}-Hankel transform of size @math{M-1}.  The coefficients of
this matrix, being dependent on @math{\nu} and @math{M}, must be
precomputed and stored; the @code{gsl_dht} object encapsulates this
data.  The allocation function @code{gsl_dht_alloc} returns a
@code{gsl_dht} object which must be properly initialized with
@code{gsl_dht_init} before it can be used to perform transforms on data
sample vectors, for fixed @math{\nu} and @math{M}, using the
@code{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 @math{[0,X]}, rather than the unit
interval.

Notice that by assumption @math{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.


@node Discrete Hankel Transform Functions
@section Functions

@deftypefun {gsl_dht *} gsl_dht_alloc (size_t @var{size})
This function allocates a Discrete Hankel transform object of size
@var{size}.
@end deftypefun

@deftypefun int gsl_dht_init (gsl_dht * @var{t}, double @var{nu}, double @var{xmax})
This function initializes the transform @var{t} for the given values of
@var{nu} and @var{x}.
@end deftypefun

@deftypefun {gsl_dht *} gsl_dht_new (size_t @var{size}, double @var{nu}, double @var{xmax})
This function allocates a Discrete Hankel transform object of size
@var{size} and initializes it for the given values of @var{nu} and
@var{x}.
@end deftypefun

@deftypefun void gsl_dht_free (gsl_dht * @var{t})
This function frees the transform @var{t}.
@end deftypefun

@deftypefun int gsl_dht_apply (const gsl_dht * @var{t}, double * @var{f_in}, double * @var{f_out})
This function applies the transform @var{t} to the array @var{f_in}
whose size is equal to the size of the transform.  The result is stored
in the array @var{f_out} which must be of the same length.
@end deftypefun

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

@deftypefun double gsl_dht_k_sample (const gsl_dht * @var{t}, int @var{n})
This function returns the value of the @var{n}-th sample point in ``k-space'',
@c{${{j_{\nu,n+1}} / X}$}
@math{j_@{\nu,n+1@}/X}.
@end deftypefun

@node Discrete Hankel Transform References
@section References and Further Reading

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

@itemize @asis
@item
H. Fisk Johnson, Comp.@: Phys.@: Comm.@: 43, 181 (1987).
@end itemize

@itemize @asis
@item
D. Lemoine, J. Chem.@: Phys.@: 101, 3936 (1994).
@end itemize