gsl 1.12.109 → 1.14.5

data/rdoc/dht.rdoc

@@ -0,0 +1,122 @@
+#
+# = Discrete Hankel Transforms
+# This chapter describes functions for performing Discrete Hankel Transforms 
+# (DHTs). 
+#
+# 1. {Definitions}[link:files/rdoc/dht_rdoc.html#1]
+# 1. {Initialization}[link:files/rdoc/dht_rdoc.html#2]
+# 1. {Methods}[link:files/rdoc/dht_rdoc.html#3]
+#
+# == {}[link:index.html"name="1] 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. 
+#
+#
+# == {}[link:index.html"name="2] 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>.
+#
+# == {}[link:index.html"name="3] 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:files/rdoc/sum_rdoc.html]
+# {next}[link:files/rdoc/roots_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#

data/rdoc/diff.rdoc

@@ -0,0 +1,133 @@
+#
+# = 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:files/rdoc/diff_rdoc.html#1]
+# 1. {Diff methods}[link:files/rdoc/diff_rdoc.html#2]
+#
+# == {}[link:index.html"name="1] 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.
+#
+# == {}[link:index.html"name="2] 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:files/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. 
+#
+# == {}[link:index.html"name="3] 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:files/rdoc/interp_rdoc.html]
+# {next}[link:files/rdoc/cheb_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#

data/rdoc/ehandling.rdoc

@@ -0,0 +1,50 @@
+#
+# = Error Handling
+#
+# == {}[link:index.html"name="1] 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).
+#
+# == {}[link:index.html"name="2] 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:files/rdoc/use_rdoc.html]
+# {next}[link:files/rdoc/math_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#

data/rdoc/eigen.rdoc

@@ -0,0 +1,401 @@
+#
+# = Eigensystems
+# === {}[link:index.html"name="0.1] Contentes
+# 1. {Modules and classes}[link:files/rdoc/eigen_rdoc.html#1]
+# 1. {Real Symmetric Matrices}[link:files/rdoc/eigen_rdoc.html#2]
+# 1. {Complex Hermitian Matrices}[link:files/rdoc/eigen_rdoc.html#3]
+# 1. {Real Nonsymmetric Matrices}[link:files/rdoc/eigen_rdoc.html#4] (>= GSL-1.9)
+# 1. {Real Generalized Symmetric-Definite Eigensystems}[link:files/rdoc/eigen_rdoc.html#5] (>= GSL-1.10)
+# 1. {Complex Generalized Hermitian-Definite Eigensystems}[link:files/rdoc/eigen_rdoc.html#6] (>= GSL-1.10)
+# 1. {Real Generalized Nonsymmetric Eigensystems}[link:files/rdoc/eigen_rdoc.html#7] (>= GSL-1.10)
+# 1. {Sorting Eigenvalues and Eigenvectors }[link:files/rdoc/eigen_rdoc.html#8]
+#
+# == {}[link:index.html"name="1] 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)
+#
+# == {}[link:index.html"name="2] Real Symmetric Matrices, GSL::Eigen::Symm module
+# === {}[link:index.html"name="2.1] 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)
+#
+#
+# === {}[link:index.html"name="2.2] 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
+#
+# == {}[link:index.html"name="3] 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
+#
+#
+# == {}[link:index.html"name="4] 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>. 
+#
+# == {}[link:index.html"name="5] 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.
+#
+# == {}[link:index.html"name="6] 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.
+#
+# == {}[link:index.html"name="7] 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.
+#
+# == {}[link:index.html"name="8] 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:files/rdoc/linalg_rdoc.html]
+# {next}[link:files/rdoc/fft_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#