rb-gsl 1.16.0.2 → 1.16.0.3.rc1

data/rdoc/diff.rdoc

@@ -1,14 +1,14 @@
 #
 # = 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. 
+# 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#1]
-# 1. {Diff methods}[link:rdoc/diff_rdoc.html#2]
+# 1. {Deriv methods}[link:diff_rdoc.html#label-Deriv+methods+%28for+GSL+1.4.90+or+later%29]
+# 1. {Diff methods}[link:diff_rdoc.html#label-Diff+Methods+%28obsolete%29]
 #
-# == {}[link:index.html"name="1] Deriv methods (for GSL 1.4.90 or later)
+# == 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
@@ -18,78 +18,78 @@
 # * 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 
+#   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 
+#   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 
+#   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 
+#   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>, 
+#   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> 
+#   These methods are equivalent to calling the method <tt>forward</tt>
 #   with a negative step-size.
 #
-# == {}[link:index.html"name="2] Diff Methods (obsolete)
+# == 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 
+#   These compute the numerical derivative of the function <tt>f</tt> ( {GSL::Function}[link: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. 
+#   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. 
+#   These compute the numerical derivative of the function at the point x using an adaptive backward difference algorithm.
 #
-# == {}[link:index.html"name="3] Example
+# == Example
 #
 #      #!/usr/bin/env ruby
 #      require "gsl"
@@ -124,10 +124,10 @@
 #      f'(x) = 0.0000000160 +/- 0.0000000339
 #      exact = 0.0000000000
 #
-# {prev}[link:rdoc/interp_rdoc.html]
-# {next}[link:rdoc/cheb_rdoc.html]
+# {prev}[link:interp_rdoc.html]
+# {next}[link:cheb_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #

data/rdoc/ehandling.rdoc

@@ -1,7 +1,7 @@
 #
 # = Error Handling
 #
-# == {}[link:index.html"name="1] Error codes
+# == 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,
@@ -30,7 +30,7 @@
 #   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
+# == 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.
@@ -42,9 +42,9 @@
 #   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]
+# {prev}[link:use_rdoc.html]
+# {next}[link:math_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #

data/rdoc/eigen.rdoc

@@ -1,16 +1,16 @@
 #
 # = Eigensystems
-# === {}[link:index.html"name="0.1] Contentes
-# 1. {Modules and classes}[link:rdoc/eigen_rdoc.html#1]
-# 1. {Real Symmetric Matrices}[link:rdoc/eigen_rdoc.html#2]
-# 1. {Complex Hermitian Matrices}[link:rdoc/eigen_rdoc.html#3]
-# 1. {Real Nonsymmetric Matrices}[link:rdoc/eigen_rdoc.html#4] (>= GSL-1.9)
-# 1. {Real Generalized Symmetric-Definite Eigensystems}[link:rdoc/eigen_rdoc.html#5] (>= GSL-1.10)
-# 1. {Complex Generalized Hermitian-Definite Eigensystems}[link:rdoc/eigen_rdoc.html#6] (>= GSL-1.10)
-# 1. {Real Generalized Nonsymmetric Eigensystems}[link:rdoc/eigen_rdoc.html#7] (>= GSL-1.10)
-# 1. {Sorting Eigenvalues and Eigenvectors }[link:rdoc/eigen_rdoc.html#8]
-#
-# == {}[link:index.html"name="1] Modules and classes
+# === Contentes
+# 1. {Modules and classes}[link:eigen_rdoc.html#label-Modules+and+classes]
+# 1. {Real Symmetric Matrices}[link:eigen_rdoc.html#label-Real+Symmetric+Matrices]
+# 1. {Complex Hermitian Matrices}[link:eigen_rdoc.html#label-Complex+Hermitian+Matrices]
+# 1. {Real Nonsymmetric Matrices}[link:eigen_rdoc.html#label-Real+Nonsymmetric+Matrices+%28%3E%3D+GSL-1.9%29] (>= GSL-1.9)
+# 1. {Real Generalized Symmetric-Definite Eigensystems}[link:eigen_rdoc.html#label-Real+Generalized+Symmetric-Definite+Eigensystems+%28GSL-1.10%29] (>= GSL-1.10)
+# 1. {Complex Generalized Hermitian-Definite Eigensystems}[link: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:eigen_rdoc.html#label-Real+Generalized+Nonsymmetric+Eigensystems+%28%3E%3D+GSL-1.10%29] (>= GSL-1.10)
+# 1. {Sorting Eigenvalues and Eigenvectors }[link:eigen_rdoc.html#label-Sorting+Eigenvalues+and+Eigenvectors]
+#
+# == Modules and classes
 #
 # * GSL
 #   * Eigen
@@ -42,8 +42,8 @@
 #     * 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
+# == Real Symmetric Matrices
+# === Workspace classes
 # ---
 # * GSL::Eigen::Symm::Workspace.alloc(n)
 # * GSL::Eigen::Symmv::Workspace.alloc(n)
@@ -51,24 +51,24 @@
 # * GSL::Eigen::Hermv::Workspace.alloc(n)
 #
 #
-# === {}[link:index.html"name="2.2] Methods to solve eigensystems
+# === 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. 
+#   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 
+#   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 
+#   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>
@@ -81,14 +81,14 @@
 #
 #         eigval, eigvec = m.eigen_symmv
 #
-# == {}[link:index.html"name="3] Complex Hermitian Matrices
+# == 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. 
+#   These methods compute the eigenvalues of the complex hermitian matrix.
 #
 # ---
 # * GSL::Eigen::hermv(A)
@@ -97,38 +97,38 @@
 # * GSL::Matrix::Complex#eigen_hermv(workspace
 #
 #
-# == {}[link:index.html"name="4] Real Nonsymmetric Matrices (>= GSL-1.9)
+# == Real Nonsymmetric Matrices (>= GSL-1.9)
 #
 # ---
 # * GSL::Eigen::Nonsymm.alloc(n)
 #
-#   This allocates a workspace for computing eigenvalues of n-by-n real 
+#   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 
+#   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 
+#   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 
+#   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>. 
+#   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.
 #
@@ -139,12 +139,12 @@
 # * 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. 
+#   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)
@@ -152,13 +152,13 @@
 # * 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 
+#   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 
+#   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)
@@ -170,81 +170,81 @@
 # * 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 
+#   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>. 
+#   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> 
+# == 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. 
+# 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). 
+#   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>, 
+#   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. 
+#   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. 
+# == 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). 
+#   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. 
+#   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. 
+#   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)
+# == Real Generalized Nonsymmetric Eigensystems (>= GSL-1.10)
 #
 # ---
 # * GSL::Eigen::Gen.alloc(n)
@@ -257,79 +257,79 @@
 # * 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 
+#   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_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>. 
+#   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. 
+#   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>. 
+#   <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. 
+#   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> 
+#   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>. 
+#   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 
+#   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). 
+#   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>. 
+#   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 
+#   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
+# == 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 
+#   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>
@@ -347,55 +347,55 @@
 # * 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 
+#   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. 
+#   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. 
+#   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. 
+#   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 
+#   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. 
+#   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]
+# {prev}[link:linalg_rdoc.html]
+# {next}[link:fft_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #