rb-gsl 1.16.0.5 → 1.16.0.6

data/rdoc/dht.rdoc

@@ -1,122 +0,0 @@
-#
-# = Discrete Hankel Transforms
-# This chapter describes functions for performing Discrete Hankel Transforms
-# (DHTs).
-#
-# 1. {Definitions}[link:rdoc/dht_rdoc.html#label-Definitions]
-# 1. {Initialization}[link:rdoc/dht_rdoc.html#label-Initialization]
-# 1. {Methods}[link:rdoc/dht_rdoc.html#label-Methods]
-#
-# == 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,
-# so that, Suppose that f is band-limited in the sense that g_m=0 for m > M.
-# Then we have the following fundamental sampling theorem. 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 <tt>GSL::Dht</tt> object encapsulates this data.
-# The constructor <tt>GSL::Dht.alloc</tt> returns a <tt>GSL::Dht</tt> object
-# which must be properly initialized with <tt>GSL::Dht#init</tt> before
-# it can be used to perform transforms on data sample vectors,
-# for fixed \nu and M, using the <tt>GSL::Dht#apply</tt> method.
-# 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.
-#
-#
-# == Initialization
-#
-# ---
-# * GSL::Dht.alloc(size)
-# * GSL::Dht.alloc(size, nu, xmax)
-#
-#   These methods allocate a Discrete Hankel transform object <tt>GSL::Dht</tt>
-#   of size <tt>size</tt>.
-#   If three arguments are given, the object is initialized with the values of
-#   <tt>nu, xmax</tt>.
-#
-# ---
-# * GSL::Dht#init(nu, xmax)
-#
-#   This initializes the transform <tt>self</tt> for the given values of <tt>nu</tt> and <tt>xmax</tt>.
-#
-# == Methods
-# ---
-# * GSL::Dht#apply(vin, vout)
-# * GSL::Dht#apply(vin)
-#
-#   This applies the transform <tt>self</tt> to the vector <tt>vin</tt> whose size is
-#   equal to the size of the transform.
-#
-# ---
-# * GSL::Dht#x_sample(n)
-#
-#   This method returns the value of the n'th sample point in the unit interval,
-#   (j_{nu,n+1}/j_{nu,M}) X. These are the points where the function f(t) is
-#   assumed to be sampled.
-#
-# ---
-# * GSL::Dht#k_sample(n)
-#
-#   This method returns the value of the n'th sample point in "k-space",
-#   j_{nu,n+1}/X.
-#
-# ---
-# * GSL::Dht#size
-#
-#   Returns the size of the sample arrays to be transformed
-# ---
-# * GSL::Dht#nu
-#
-#   Returns the Bessel function order
-# ---
-# * GSL::Dht#xmax
-#
-#   Returns the upper limit to the x-sampling domain
-# ---
-# * GSL::Dht#kmax
-#
-#   Returns the upper limit to the k-sampling domain
-#
-# ---
-# * GSL::Dht#j
-#
-#   Returns an array of computed J_nu zeros, j_{nu,s} = \j[s]
-#   as a <tt>GSL::Vector::View</tt>.
-#
-# ---
-# * GSL::Dht#Jjj
-#
-#   Returns an array of transform numerator, J_nu(j_i j_m / j_N)
-#   as a <tt>GSL::Vector::View</tt>.
-#
-# ---
-# * GSL::Dht#J2
-#
-#   Returns an array of transform numerator, J_nu(j_i j_m / j_N).
-#
-# ---
-# * GSL::Dht#coef
-# * GSL::Dht#coef(n, m)
-#
-#   Return the (n,m)-th transform coefficient.
-#
-# {prev}[link:rdoc/sum_rdoc.html]
-# {next}[link:rdoc/roots_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#

data/rdoc/diff.rdoc

@@ -1,133 +0,0 @@
-#
-# = Numerical Differentiation
-# The functions described in this chapter compute numerical derivatives by
-# finite differencing. An adaptive algorithm is used to find the best choice
-# of finite difference and to estimate the error in the derivative.
-#
-# Contentes:
-# 1. {Deriv methods}[link:rdoc/diff_rdoc.html#label-Deriv+methods+%28for+GSL+1.4.90+or+later%29]
-# 1. {Diff methods}[link:rdoc/diff_rdoc.html#label-Diff+Methods+%28obsolete%29]
-#
-# == Deriv methods (for GSL 1.4.90 or later)
-# Numerical derivatives should now be calculated using the
-# <tt>GSL::Deriv.forward, GSL::Deriv.central</tt> and <tt>GSL::Deriv.backward</tt> methods,
-# which accept a step-size argument in addition to the position x.  The
-# original <tt>GSL::Diff</tt> methods (without the step-size) are deprecated.
-#
-# ---
-# * GSL::Deriv.central(f, x, h = 1e-8)
-# * GSL::Function#deriv_central(x, h = 1e-8)
-#
-#   These methods compute the numerical derivative of the function <tt>f</tt>
-#   at the point <tt>x</tt> using an adaptive central difference algorithm with a
-#   step-size of <tt>h</tt>. If a scalar <tt>x</tt> is given, the derivative and an
-#   estimate of its absolute error are returned as an array, [<tt>result, abserr, status</tt>].
-#   If a vector/matrix/array <tt>x</tt> is given, an array of two elements are returned,
-#   [<tt>result, abserr</tt>], here each them is also a vector/matrix/array of the same
-#   dimension of <tt>x</tt>.
-#
-#   The initial value of <tt>h</tt> is used to estimate an optimal step-size,
-#   based on the scaling of the truncation error and round-off error in the
-#   derivative calculation. The derivative is computed using a 5-point rule for
-#   equally spaced abscissae at x-h, x-h/2, x, x+h/2, x, with an error estimate
-#   taken from the difference between the 5-point rule and the corresponding 3-point
-#   rule x-h, x, x+h. Note that the value of the function at x does not contribute
-#   to the derivative calculation, so only 4-points are actually used.
-#
-# ---
-# * GSL::Deriv.forward(f, x, h = 1e-8)
-# * GSL::Function#deriv_forward(x, h = 1e-8)
-#
-#   These methods compute the numerical derivative of the function <tt>f</tt> at
-#   the point <tt>x</tt> using an adaptive forward difference algorithm with a step-size
-#   of <tt>h</tt>. The function is evaluated only at points greater than <tt>x</tt>,
-#   and never at <tt>x</tt> itself. The derivative and an estimate of its absolute error
-#   are returned as an array, [<tt>result, abserr</tt>].
-#   These methods should be used if f(x) has a
-#   discontinuity at <tt>x</tt>, or is undefined for values less than <tt>x</tt>.
-#
-#   The initial value of <tt>h</tt> is used to estimate an optimal step-size, based on the
-#   scaling of the truncation error and round-off error in the derivative calculation.
-#   The derivative at x is computed using an "open" 4-point rule for equally spaced
-#   abscissae at x+h/4, x+h/2, x+3h/4, x+h, with an error estimate taken from the
-#   difference between the 4-point rule and the corresponding 2-point rule x+h/2, x+h.
-#
-# ---
-# * GSL::Deriv.backward(f, x, h)
-# * GSL::Function#deriv_backward(x, h)
-#
-#   These methods compute the numerical derivative of the function <tt>f</tt> at the
-#   point <tt>x</tt> using an adaptive backward difference algorithm with a step-size
-#   of <tt>h</tt>. The function is evaluated only at points less than <tt>x</tt>,
-#   and never at <tt>x</tt> itself. The derivative and an estimate of its absolute error
-#   are returned as an array, [<tt>result, abserr</tt>].
-#   This function should be used if f(x) has a discontinuity at <tt>x</tt>,
-#   or is undefined for values greater than <tt>x</tt>.
-#
-#   These methods are equivalent to calling the method <tt>forward</tt>
-#   with a negative step-size.
-#
-# == Diff Methods (obsolete)
-#
-# ---
-# * GSL::Diff.central(f, x)
-# * GSL::Function#diff_central(x)
-#
-#   These compute the numerical derivative of the function <tt>f</tt> ( {GSL::Function}[link:rdoc/function_rdoc.html] object) at the point <tt>x</tt>
-#   using an adaptive central difference algorithm. The result is returned as an array
-#   which contains the derivative and an estimate of its absolute error.
-#
-# ---
-# * GSL::Diff.forward(f, x)
-# * GSL::Function#diff_forward(x)
-#
-#   These compute the numerical derivative of the function at the point x using an adaptive forward difference algorithm.
-#
-# ---
-# * GSL::Diff.backward(f, x)
-# * GSL::Function#diff_backward(x)
-#
-#   These compute the numerical derivative of the function at the point x using an adaptive backward difference algorithm.
-#
-# == Example
-#
-#      #!/usr/bin/env ruby
-#      require "gsl"
-#
-#      f = GSL::Function.alloc { |x|
-#        pow(x, 1.5)
-#      }
-#
-#      printf ("f(x) = x^(3/2)\n");
-#
-#      x = 2.0
-#      h = 1e-8
-#      result, abserr = f.deriv_central(x, h)
-#      printf("x = 2.0\n");
-#      printf("f'(x) = %.10f +/- %.10f\n", result, abserr);
-#      printf("exact = %.10f\n\n", 1.5 * Math::sqrt(2.0));
-#
-#      x = 0.0
-#      result, abserr = Deriv.forward(f, x, h) # equivalent to f.deriv_forward(x, h)
-#      printf("x = 0.0\n");
-#      printf("f'(x) = %.10f +/- %.10f\n", result, abserr);
-#      printf("exact = %.10f\n", 0.0);
-#
-# The results are
-#
-#      f(x) = x^(3/2)
-#      x = 2.0
-#      f'(x) = 2.1213203120 +/- 0.0000004064
-#      exact = 2.1213203436
-#
-#      x = 0.0
-#      f'(x) = 0.0000000160 +/- 0.0000000339
-#      exact = 0.0000000000
-#
-# {prev}[link:rdoc/interp_rdoc.html]
-# {next}[link:rdoc/cheb_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#

data/rdoc/ehandling.rdoc

@@ -1,50 +0,0 @@
-#
-# = Error Handling
-#
-# == Error codes
-# The GSL routines report an error whenever they cannot perform the task
-# requested of them. For example, a root-finding function would return a
-# non-zero error code if could not converge to the requested accuracy,
-# or exceeded a limit on the number of iterations. Situations like this
-# are a normal occurrence when using any mathematical library and
-# you should check the return status of the functions that you call.
-#
-# Whenever a routine reports an error the return value specifies the type of error.
-# The return value is analogous to the value of the variable errno in the C library.
-# The caller can examine the return code and decide what action to take, including
-# ignoring the error if it is not considered serious.
-#
-# The error code numbers in GSL as <tt>GSL_EDOM</tt> are defined in Ruby/GSL
-# as Ruby constants under the <tt>GSL</tt> module. Here are some of them:
-# * <tt>GSL::EDOM</tt> - Domain error; used by mathematical functions when an
-#   argument value does not fall into the domain over which the function is
-#   defined (like <tt>EDOM</tt> in the C library)
-# * <tt>GSL::ERANGE</tt> - Range error; used by mathematical functions when the
-#   result value is not representable because of overflow or underflow
-#   (like <tt>ERANGE</tt> in the C library)
-# * <tt>GSL::ENOMEM</tt> - No memory available. The system cannot allocate more
-#   virtual memory because its capacity is full (like <tt>ENOMEM</tt> in the
-#   C library). This error is reported when a GSL routine encounters problems
-#   when trying to allocate memory with malloc.
-# * <tt>GSL::EINVAL</tt> - Invalid argument. This is used to indicate various
-#   kinds of problems with passing the wrong argument to a library function
-#   (like <tt>EINVAL</tt> in the C library).
-#
-# == Error handler
-# In Ruby/GSL, the default GSL error handler is replaced by an other one which calls
-# <tt>rb_raise()</tt>. Thus whenever a GSL routine reports a fatal error,
-# a Ruby Exception is generated.
-#
-# ---
-# * GSL::set_error_handler(proc)
-# * GSL::set_error_handler { |reason, file, line, errno| ... }
-#
-#   This replaces the Ruby/GSL default error handler by a user-defined handler
-#   given by a Proc object <tt>proc</tt> or a block.
-#
-# {prev}[link:rdoc/use_rdoc.html]
-# {next}[link:rdoc/math_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#

data/rdoc/eigen.rdoc

@@ -1,401 +0,0 @@
-#
-# = Eigensystems
-# === Contentes
-# 1. {Modules and classes}[link:rdoc/eigen_rdoc.html#label-Modules+and+classes]
-# 1. {Real Symmetric Matrices}[link:rdoc/eigen_rdoc.html#label-Real+Symmetric+Matrices]
-# 1. {Complex Hermitian Matrices}[link:rdoc/eigen_rdoc.html#label-Complex+Hermitian+Matrices]
-# 1. {Real Nonsymmetric Matrices}[link:rdoc/eigen_rdoc.html#label-Real+Nonsymmetric+Matrices+%28%3E%3D+GSL-1.9%29] (>= GSL-1.9)
-# 1. {Real Generalized Symmetric-Definite Eigensystems}[link:rdoc/eigen_rdoc.html#label-Real+Generalized+Symmetric-Definite+Eigensystems+%28GSL-1.10%29] (>= GSL-1.10)
-# 1. {Complex Generalized Hermitian-Definite Eigensystems}[link:rdoc/eigen_rdoc.html#label-Complex+Generalized+Hermitian-Definite+Eigensystems+%28%3E%3D+GSL-1.10%29] (>= GSL-1.10)
-# 1. {Real Generalized Nonsymmetric Eigensystems}[link:rdoc/eigen_rdoc.html#label-Real+Generalized+Nonsymmetric+Eigensystems+%28%3E%3D+GSL-1.10%29] (>= GSL-1.10)
-# 1. {Sorting Eigenvalues and Eigenvectors }[link:rdoc/eigen_rdoc.html#label-Sorting+Eigenvalues+and+Eigenvectors]
-#
-# == Modules and classes
-#
-# * GSL
-#   * Eigen
-#     * EigenValues < Vector
-#     * EigenVectors < Matrix
-#     * Symm (Module)
-#       * Workspace (Class)
-#     * Symmv (Module)
-#       * Workspace (Class)
-#     * Nonsymm (Module, >= GSL-1.9)
-#       * Workspace (Class)
-#     * Nonsymmv (Module, >= GSL-1.9)
-#       * Workspace (Class)
-#     * Gensymm (Module, >= GSL-1.10)
-#       * Workspace (Class)
-#     * Gensymmv (Module, >= GSL-1.10)
-#       * Workspace (Class)
-#     * Herm (Module)
-#       * Workspace (Class)
-#     * Hermv (Module)
-#       * Workspace (Class)
-#       * Vectors < Matrix::Complex
-#     * Genherm (Module, >= GSL-1.10)
-#       * Workspace (Class)
-#     * Genhermv (Module, >= GSL-1.10)
-#       * Workspace (Class)
-#     * Gen (Module, >= GSL-1.10)
-#       * Workspace (Class)
-#     * Genv (Module, >= GSL-1.10)
-#       * Workspace (Class)
-#
-# == Real Symmetric Matrices
-# === Workspace classes
-# ---
-# * GSL::Eigen::Symm::Workspace.alloc(n)
-# * GSL::Eigen::Symmv::Workspace.alloc(n)
-# * GSL::Eigen::Herm::Workspace.alloc(n)
-# * GSL::Eigen::Hermv::Workspace.alloc(n)
-#
-#
-# === Methods to solve eigensystems
-# ---
-# * GSL::Eigen::symm(A)
-# * GSL::Eigen::symm(A, workspace)
-# * GSL::Matrix#eigen_symm
-# * GSL::Matrix#eigen_symm(workspace)
-#
-#   These methods compute the eigenvalues of the real symmetric matrix.
-#   The workspace object <tt>workspace</tt> can be omitted.
-#
-# ---
-# * GSL::Eigen::symmv(A)
-# * GSL::Matrix#eigen_symmv
-#
-#   These methods compute the eigenvalues and eigenvectors of the real symmetric
-#   matrix, and return an array of two elements:
-#   The first is a <tt>GSL::Vector</tt> object which stores all the eigenvalues.
-#   The second is a <tt>GSL::Matrix object</tt>, whose columns contain
-#   eigenvectors.
-#
-# 1. Singleton method of the <tt>GSL::Eigen</tt> module, <tt>GSL::Eigen::symm</tt>
-#
-#         m = GSL::Matrix.alloc([1.0, 1/2.0, 1/3.0, 1/4.0], [1/2.0, 1/3.0, 1/4.0, 1/5.0],
-#                            [1/3.0, 1/4.0, 1/5.0, 1/6.0], [1/4.0, 1/5.0, 1/6.0, 1/7.0])
-#         eigval, eigvec = Eigen::symmv(m)
-#
-# 1. Instance method of <tt>GSL::Matrix</tt> class
-#
-#         eigval, eigvec = m.eigen_symmv
-#
-# == Complex Hermitian Matrices
-# ---
-# * GSL::Eigen::herm(A)
-# * GSL::Eigen::herm(A, workspace)
-# * GSL::Matrix::Complex#eigen_herm
-# * GSL::Matrix::Complex#eigen_herm(workspace)
-#
-#   These methods compute the eigenvalues of the complex hermitian matrix.
-#
-# ---
-# * GSL::Eigen::hermv(A)
-# * GSL::Eigen::hermv(A, workspace)
-# * GSL::Matrix::Complex#eigen_hermv
-# * GSL::Matrix::Complex#eigen_hermv(workspace
-#
-#
-# == Real Nonsymmetric Matrices (>= GSL-1.9)
-#
-# ---
-# * GSL::Eigen::Nonsymm.alloc(n)
-#
-#   This allocates a workspace for computing eigenvalues of n-by-n real
-#   nonsymmetric matrices. The size of the workspace is O(2n).
-#
-# ---
-# * GSL::Eigen::Nonsymm::params(compute_t, balance, wspace)
-# * GSL::Eigen::Nonsymm::Workspace#params(compute_t, balance)
-#
-#   This method sets some parameters which determine how the eigenvalue
-#   problem is solved in subsequent calls to <tt>GSL::Eigen::nonsymm</tt>.
-#   If <tt>compute_t</tt> is set to 1, the full Schur form <tt>T</tt> will be
-#   computed by gsl_eigen_nonsymm. If it is set to 0, <tt>T</tt> will not be
-#   computed (this is the default setting).
-#   Computing the full Schur form <tt>T</tt> requires approximately 1.5-2 times
-#   the number of flops.
-#
-#   If <tt>balance</tt> is set to 1, a balancing transformation is applied to
-#   the matrix prior to computing eigenvalues. This transformation is designed
-#   to make the rows and columns of the matrix have comparable norms, and can
-#   result in more accurate eigenvalues for matrices whose entries vary widely
-#   in magnitude. See section Balancing for more information. Note that the
-#   balancing transformation does not preserve the orthogonality of the Schur
-#   vectors, so if you wish to compute the Schur vectors with
-#   <tt>GSL::Eigen::nonsymm_Z</tt> you will obtain the Schur vectors of the
-#   balanced matrix instead of the original matrix. The relationship will be
-#   where Q is the matrix of Schur vectors for the balanced matrix, and <tt>D</tt>
-#   is the balancing transformation. Then <tt>GSL::Eigen::nonsymm_Z</tt> will
-#   compute a matrix <tt>Z</tt> which satisfies with <tt>Z = D Q</tt>.
-#   Note that <tt>Z</tt> will not be orthogonal. For this reason, balancing is
-#   not performed by default.
-#
-# ---
-# * GSL::Eigen::nonsymm(m, eval, wspace)
-# * GSL::Eigen::nonsymm(m)
-# * GSL::Matrix#eigen_nonsymm()
-# * GSL::Matrix#eigen_nonsymm(wspace)
-# * GSL::Matrix#eigen_nonsymm(eval, wspace)
-#
-#   These methods compute the eigenvalues of the real nonsymmetric matrix <tt>m</tt>
-#   and return them, or store in the vector <tt>eval</tt> if it given.
-#   If <tt>T</tt> is desired, it is stored in <tt>m</tt> on output, however the lower
-#   triangular portion will not be zeroed out. Otherwise, on output, the diagonal
-#   of <tt>m</tt> will contain the 1-by-1 real eigenvalues and 2-by-2 complex
-#   conjugate eigenvalue systems, and the rest of <tt>m</tt> is destroyed.
-#
-# ---
-# * GSL::Eigen::nonsymm_Z(m, eval, Z, wspace)
-# * GSL::Eigen::nonsymm_Z(m)
-# * GSL::Matrix#eigen_nonsymm_Z()
-# * GSL::Matrix#eigen_nonsymm(eval, Z, wspace)
-#
-#   These methods are identical to <tt>GSL::Eigen::nonsymm</tt> except they also
-#   compute the Schur vectors and return them (or store into <tt>Z</tt>).
-#
-# ---
-# * GSL::Eigen::Nonsymmv.alloc(n)
-#
-#   Allocates a workspace for computing eigenvalues and eigenvectors
-#   of n-by-n real nonsymmetric matrices. The size of the workspace is O(5n).
-# ---
-# * GSL::Eigen::nonsymm(m)
-# * GSL::Eigen::nonsymm(m, wspace)
-# * GSL::Eigen::nonsymm(m, eval, evec)
-# * GSL::Eigen::nonsymm(m, eval, evec, wspace)
-# * GSL::Matrix#eigen_nonsymmv()
-# * GSL::Matrix#eigen_nonsymmv(wspace)
-# * GSL::Matrix#eigen_nonsymmv(eval, evec)
-# * GSL::Matrix#eigen_nonsymmv(eval, evec, wspace)
-#
-#   Compute eigenvalues and right eigenvectors of the n-by-n real nonsymmetric
-#   matrix. The computed eigenvectors are normalized to have Euclidean norm 1.
-#   On output, the upper portion of <tt>m</tt> contains the Schur form <tt>T</tt>.
-#
-# == Real Generalized Symmetric-Definite Eigensystems (GSL-1.10)
-# The real generalized symmetric-definite eigenvalue problem is to
-# find eigenvalues <tt>lambda</tt> and eigenvectors <tt>x</tt> such that
-# where <tt>A</tt> and <tt>B</tt> are symmetric matrices, and <tt>B</tt>
-# is positive-definite. This problem reduces to the standard symmetric eigenvalue
-# problem by applying the Cholesky decomposition to <tt>B</tt>:
-# Therefore, the problem becomes <tt>C y = lambda y</tt>
-# where <tt>C = L^{-1} A L^{-t}</tt> is symmetric, and <tt>y = L^t x</tt>.
-# The standard symmetric eigensolver can be applied to the matrix <tt>C</tt>.
-# The resulting eigenvectors are backtransformed to find the vectors of the
-# original problem. The eigenvalues and eigenvectors of the generalized
-# symmetric-definite eigenproblem are always real.
-#
-# ---
-# * GSL::Eigen::Gensymm.alloc(n)
-# * GSL::Eigen::Gensymm::Workspace.alloc(n)
-#
-#   Allocates a workspace for computing eigenvalues of n-by-n real
-#   generalized symmetric-definite eigensystems.
-#   The size of the workspace is O(2n).
-# ---
-# * GSL::Eigen::gensymm(A, B, w)
-#
-#   Computes the eigenvalues of the real generalized symmetric-definite matrix
-#   pair <tt>A, B</tt>, and returns them as a <tt>GSL::Vector</tt>,
-#   using the method outlined above. On output, B contains its Cholesky
-#   decomposition.
-# ---
-# * GSL::Eigen::gensymmv(A, B, w)
-#
-#   Computes the eigenvalues and eigenvectors of the real generalized
-#   symmetric-definite matrix pair <tt>A, B</tt>, and returns
-#   them as a <tt>GSL::Vector</tt> and a <tt>GSL::Matrix</tt>.
-#   The computed eigenvectors are normalized to have unit magnitude.
-#   On output, <tt>B</tt> contains its Cholesky decomposition.
-#
-# == Complex Generalized Hermitian-Definite Eigensystems (>= GSL-1.10)
-# The complex generalized hermitian-definite eigenvalue problem is to
-# find eigenvalues <tt>lambda</tt> and eigenvectors <tt>x</tt> such that
-# where <tt>A</tt> and <tt>B</tt> are hermitian matrices, and <tt>B</tt>
-# is positive-definite. Similarly to the real case, this can be reduced to
-# <tt>C y = lambda y</tt> where <tt>C = L^{-1} A L^{-H}</tt> is hermitian,
-# and <tt>y = L^H x</tt>. The standard hermitian eigensolver can be applied to
-# the matrix <tt>C</tt>. The resulting eigenvectors are backtransformed
-# to find the vectors of the original problem.
-# The eigenvalues of the generalized hermitian-definite eigenproblem are always
-# real.
-#
-# ---
-# * GSL::Eigen::Genherm.alloc(n)
-#
-#   Allocates a workspace for computing eigenvalues of n-by-n complex
-#   generalized hermitian-definite eigensystems.
-#   The size of the workspace is O(3n).
-# ---
-# * GSL::Eigen::genherm(A, B, w)
-#
-#   Computes the eigenvalues of the complex generalized hermitian-definite
-#   matrix pair <tt>A, B</tt>, and returns them as a <tt>GSL::Vector</tt>,
-#   using the method outlined above.
-#   On output, <tt>B</tt> contains its Cholesky decomposition.
-# ---
-# * GSL::Eigen::genherm(A, B, w)
-#
-#   Computes the eigenvalues and eigenvectors of the complex generalized
-#   hermitian-definite matrix pair <tt>A, B</tt>,
-#   and returns them as a <tt>GSL::Vector</tt> and a <tt>GSL::Matrix::Complex</tt>.
-#   The computed eigenvectors are normalized to have unit magnitude.
-#   On output, <tt>B</tt> contains its Cholesky decomposition.
-#
-# == Real Generalized Nonsymmetric Eigensystems (>= GSL-1.10)
-#
-# ---
-# * GSL::Eigen::Gen.alloc(n)
-# * GSL::Eigen::Gen::Workspace.alloc(n)
-#
-#   Allocates a workspace for computing eigenvalues of n-by-n real generalized
-#   nonsymmetric eigensystems. The size of the workspace is O(n).
-#
-# ---
-# * GSL::Eigen::Gen::params(compute_s, compute_t, balance, w)
-# * GSL::Eigen::gen_params(compute_s, compute_t, balance, w)
-#
-#   Set some parameters which determine how the eigenvalue problem is solved
-#   in subsequent calls to <tt>GSL::Eigen::gen</tt>.
-#
-#   If <tt>compute_s</tt> is set to 1, the full Schur form <tt>S</tt> will be
-#   computed by <tt>GSL::Eigen::gen</tt>. If it is set to 0, <tt>S</tt> will
-#   not be computed (this is the default setting). <tt>S</tt> is a quasi upper
-#   triangular matrix with 1-by-1 and 2-by-2 blocks on its diagonal.
-#   1-by-1 blocks correspond to real eigenvalues, and 2-by-2 blocks
-#   correspond to complex eigenvalues.
-#
-#   If <tt>compute_t</tt> is set to 1, the full Schur form <tt>T</tt> will
-#   be computed by <tt>GSL::Eigen::gen</tt>. If it is set to 0, <tt>T</tt>
-#   will not be computed (this is the default setting). <tt>T</tt>
-#   is an upper triangular matrix with non-negative elements on its diagonal.
-#   Any 2-by-2 blocks in <tt>S</tt> will correspond to a 2-by-2 diagonal block
-#   in <tt>T</tt>.
-#
-#   The <tt>balance</tt> parameter is currently ignored, since generalized
-#   balancing is not yet implemented.
-#
-# ---
-# * GSL::Eigen::gen(A, B, w)
-#
-#   Computes the eigenvalues of the real generalized nonsymmetric matrix pair
-#   <tt>A, B</tt>, and returns them as pairs in (alpha, beta),
-#   where alpha is <tt>GSL::Vector::Complex</tt> and beta is <tt>GSL::Vector</tt>.
-#   If beta_i is non-zero, then lambda = alpha_i / beta_i is an eigenvalue.
-#   Likewise, if alpha_i is non-zero, then mu = beta_i / alpha_i is an
-#   eigenvalue of the alternate problem mu A y = B y.
-#   The elements of <tt>beta</tt> are normalized to be non-negative.
-#
-#   If <tt>S</tt> is desired, it is stored in <tt>A</tt> on output.
-#   If <tt>T</tt> is desired, it is stored in <tt>B</tt> on output.
-#   The ordering of eigenvalues in <tt>alpha, beta</tt>
-#   follows the ordering of the diagonal blocks in the Schur forms <tt>S</tt>
-#   and <tt>T</tt>.
-#
-# ---
-# * GSL::Eigen::gen_QZ(A, B, w)
-#
-#   This method is identical to <tt>GSL::Eigen::gen</tt> except it also computes
-#   the left and right Schur vectors and returns them.
-#
-# ---
-# * GSL::Eigen::Genv.alloc(n)
-# * GSL::Eigen::Genv::Workspace.alloc(n)
-#
-#   Allocatesa workspace for computing eigenvalues and eigenvectors of
-#   n-by-n real generalized nonsymmetric eigensystems.
-#   The size of the workspace is O(7n).
-#
-# ---
-# * GSL::Eigen::genv(A, B, w)
-#
-#   Computes eigenvalues and right eigenvectors of the n-by-n real generalized
-#   nonsymmetric matrix pair <tt>A, B</tt>. The eigenvalues and eigenvectors
-#   are returned in <tt>alpha, beta, evec</tt>.
-#   On output, <tt>A, B</tt> contains the generalized Schur form <tt>S, T</tt>.
-#
-# ---
-# * GSL::Eigen::genv_QZ(A, B, w)
-#
-#   This method is identical to <tt>GSL::Eigen::genv</tt> except it also computes
-#   the left and right Schur vectors and returns them.
-#
-# == Sorting Eigenvalues and Eigenvectors
-# ---
-# * GSL::Eigen::symmv_sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-# * GSL::Eigen::Symmv::sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-#
-#   These methods simultaneously sort the eigenvalues stored in the vector
-#   <tt>eval</tt> and the corresponding real eigenvectors stored in the
-#   columns of the matrix <tt>evec</tt> into ascending or descending order
-#   according to the value of the parameter <tt>type</tt>,
-#
-#   * <tt>GSL::Eigen::SORT_VAL_ASC</tt>
-#     ascending order in numerical value
-#   * <tt>GSL::Eigen::SORT_VAL_DESC</tt>
-#     escending order in numerical value
-#   * <tt>GSL::Eigen::SORT_ABS_ASC</tt>
-#     scending order in magnitude
-#   * <tt>GSL::Eigen::SORT_ABS_DESC</tt>
-#     descending order in magnitude
-#
-#   The sorting is carried out in-place!
-#
-# ---
-# * GSL::Eigen::hermv_sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-# * GSL::Eigen::Hermv::sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-#
-#   These methods simultaneously sort the eigenvalues stored in the vector
-#   <tt>eval</tt> and the corresponding complex eigenvectors stored in the columns
-#   of the matrix <tt>evec</tt> into ascending or descending order according
-#   to the value of the parameter <tt>type</tt> as shown above.
-#
-# ---
-# * GSL::Eigen::nonsymmv_sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-# * GSL::Eigen::Nonsymmv::sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-#
-#   Sorts the eigenvalues stored in the vector <tt>eval</tt> and the corresponding
-#   complex eigenvectors stored in the columns of the matrix <tt>evec</tt>
-#   into ascending or descending order according to the value of the
-#   parameter <tt>type</tt> as shown above.
-#   Only <tt>GSL::EIGEN_SORT_ABS_ASC</tt> and <tt>GSL::EIGEN_SORT_ABS_DESC</tt>
-#   are supported due to the eigenvalues being complex.
-#
-# ---
-# * GSL::Eigen::gensymmv_sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-# * GSL::Eigen::Gensymmv::sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-#
-#   Sorts the eigenvalues stored in the vector <tt>eval</tt> and the
-#   corresponding real eigenvectors stored in the columns of the matrix
-#   <tt>evec</tt> into ascending or descending order according to the value of
-#   the parameter <tt>type</tt> as shown above.
-#
-# ---
-# * GSL::Eigen::gensymmv_sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-# * GSL::Eigen::Gensymmv::sort(eval, evec, type = GSL::Eigen::SORT_VAL_ASC)
-#
-#   Sorts the eigenvalues stored in the vector <tt>eval</tt> and the
-#   corresponding complex eigenvectors stored in the columns of the matrix
-#   <tt>evec</tt> into ascending or descending order according to the value of
-#   the parameter <tt>type</tt> as shown above.
-#
-# ---
-# * GSL::Eigen::genv_sort(alpha, beta, evec, type = GSL::Eigen::SORT_VAL_ASC)
-# * GSL::Eigen::Genv::sort(alpha, beta, evec, type = GSL::Eigen::SORT_VAL_ASC)
-#
-#   Sorts the eigenvalues stored in the vectors <tt>alpha, beta</tt> and the
-#   corresponding complex eigenvectors stored in the columns of the matrix
-#   <tt>evec</tt> into ascending or descending order according to the value of
-#   the parameter <tt>type</tt> as shown above. Only <tt>GSL::EIGEN_SORT_ABS_ASC</tt>
-#   and <tt>GSL::EIGEN_SORT_ABS_DESC</tt> are supported due to the eigenvalues
-#   being complex.
-#
-# {prev}[link:rdoc/linalg_rdoc.html]
-# {next}[link:rdoc/fft_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#