rb-gsl 1.16.0.2 → 1.16.0.3.rc1

data/rdoc/interp.rdoc

@@ -1,44 +1,44 @@
 #
 # = Interpolation
-# This chapter describes functions for performing interpolation. 
-# The library provides a variety of interpolation methods, including 
-# Cubic splines and Akima splines. The interpolation types are interchangeable, 
-# allowing different methods to be used without recompiling. Interpolations can 
-# be defined for both normal and periodic boundary conditions. Additional 
-# functions are available for computing derivatives and integrals of 
-# interpolating functions. 
-#
-# 1. {Interpolation classes}[link:rdoc/interp_rdoc.html#1]
-# 1. {Initializing interpolation objects}[link:rdoc/interp_rdoc.html#2]
-# 1. {Index Look-up and Acceleration}[link:rdoc/interp_rdoc.html#3]
-# 1. {Evaluation of Interpolating Functions}[link:rdoc/interp_rdoc.html#4]
-# 1. {Higher level interface: GSL::Spline class}[link:rdoc/interp_rdoc.html#5]
-#    1. {Class initialization}[link:rdoc/interp_rdoc.html#5.1]
-#    1. {Evaluation}[link:rdoc/interp_rdoc.html#5.2]
-#    1. {Finding and acceleration}[link:rdoc/interp_rdoc.html#5.3]
-#
-# == {}[link:index.html"name="1] Interpolation Classes
+# This chapter describes functions for performing interpolation.
+# The library provides a variety of interpolation methods, including
+# Cubic splines and Akima splines. The interpolation types are interchangeable,
+# allowing different methods to be used without recompiling. Interpolations can
+# be defined for both normal and periodic boundary conditions. Additional
+# functions are available for computing derivatives and integrals of
+# interpolating functions.
+#
+# 1. {Interpolation classes}[link:interp_rdoc.html#label-Interpolation+Classes]
+# 1. {Initializing interpolation objects}[link:interp_rdoc.html#label-Initializing+interpolation+objects]
+# 1. {Index Look-up and Acceleration}[link:interp_rdoc.html#label-Index+Look-up+and+Acceleration]
+# 1. {Evaluation of Interpolating Functions}[link:interp_rdoc.html#label-Evaluation+of+Interpolating+Functions]
+# 1. {Higher level interface: GSL::Spline class}[link:interp_rdoc.html#label-Higher+level+interface]
+#    1. {Class initialization}[link:interp_rdoc.html#label-Class+initialization]
+#    1. {Evaluation}[link:interp_rdoc.html#label-Evaluation]
+#    1. {Finding and acceleration}[link:interp_rdoc.html#label-Finding+and+acceleration]
+#
+# == Interpolation Classes
 # * GSL
 #   * Interp (class)
 #     * Accel (class)
 #   * Spline (class)
-#   
-# == {}[link:index.html"name="2] Initializing interpolation objects
+#
+# == Initializing interpolation objects
 #
 # ---
 # * GSL::Interp.alloc(T, n)
 # * GSL::Interp.alloc(T, x, y)
 # * GSL::Interp.alloc(x, y)
 #
-#   These methods create an  interpolation object of type <tt>T</tt> for <tt>n</tt> 
+#   These methods create an  interpolation object of type <tt>T</tt> for <tt>n</tt>
 #   data-points.
 #
-#   The library provides six types, which are specifiled by an identifier of a 
+#   The library provides six types, which are specifiled by an identifier of a
 #   constant or a string:
 #
 #   * Interp::LINEAR or "linear"
 #
-#     Linear interpolation. This interpolation method does not require any additional memory.   
+#     Linear interpolation. This interpolation method does not require any additional memory.
 #   * Interp::POLYNOMIAL or "polynomial"
 #
 #     Polynomial interpolation. This method should only be used for interpolating small numbers of points because polynomial interpolation introduces large oscillations, even for well-behaved datasets. The number of terms in the interpolating polynomial is equal to the number of points.
@@ -49,24 +49,24 @@
 #   * Interp::CSPLINE_PERIODIC or "gsl_cspline_periodic" or "cspline_periodic"
 #
 #     Cubic spline with periodic boundary conditions
-#   * Interp::AKIMA or "akima"    
+#   * Interp::AKIMA or "akima"
 #
 #     Non-rounded Akima spline with natural boundary conditions. This method uses the non-rounded corner algorithm of Wodicka.
-#   * Interp::AKIMA_PERIODIC or "akima_periodic"    
+#   * Interp::AKIMA_PERIODIC or "akima_periodic"
 #
 #     Non-rounded Akima spline with periodic boundary conditions. This method uses the non-rounded corner algorithm of Wodicka.
-#   
+#
 #     * ex: For cubic spline for 10 points,
 #         sp = Interp.alloc("cspline", 10)
 #
 # ---
 # * GSL::Interp#init(xa, ya)
 #
-#   This method initializes the interpolation object interp for the data 
-#   <tt>(xa,ya)</tt> where <tt>xa</tt> and <tt>ya</tt> are vectors. 
-#   The interpolation object (<tt>GSL::Interp</tt>) does not save the data 
-#   vectors <tt>xa, ya</tt> and only stores the static state computed from the data. 
-#   The <tt>xa</tt> vector is always assumed to be strictly ordered; the behavior 
+#   This method initializes the interpolation object interp for the data
+#   <tt>(xa,ya)</tt> where <tt>xa</tt> and <tt>ya</tt> are vectors.
+#   The interpolation object (<tt>GSL::Interp</tt>) does not save the data
+#   vectors <tt>xa, ya</tt> and only stores the static state computed from the data.
+#   The <tt>xa</tt> vector is always assumed to be strictly ordered; the behavior
 #   for other arrangements is not defined.
 #
 #
@@ -80,27 +80,27 @@
 # ---
 # * GSL::Interp#min_size
 #
-#   This returns the minimum number of points required by the interpolation 
-#   type of <tt>self</tt>. For example, Akima spline interpolation requires 
+#   This returns the minimum number of points required by the interpolation
+#   type of <tt>self</tt>. For example, Akima spline interpolation requires
 #   a minimum of 5 points.
 #
-# == {}[link:index.html"name="3] Index Look-up and Acceleration 
+# == Index Look-up and Acceleration
 # ---
 # * GSL::Interp.bsearch(xa, x, index_lo, index_hi)
 #
-#   This returns the index i of the vector <tt>xa</tt> such that 
-#   <tt>xa[i] <= x < x[i+1]</tt>. The index is searched for in the range 
+#   This returns the index i of the vector <tt>xa</tt> such that
+#   <tt>xa[i] <= x < x[i+1]</tt>. The index is searched for in the range
 #   <tt>[index_lo,index_hi]</tt>.
 #
 #
 # ---
 # * GSL::Interp#accel
 #
-#   In C level, the library requires a <tt>gsl_interp_accel</tt> object, 
-#   but it is hidden in Ruby/GSL. It is automatically allocated 
-#   when a <tt>GSL::Interp</tt> object is created, stored in it, 
-#   and destroyed when the <tt>Interp</tt> object 
-#   is cleaned by the Ruby GC. 
+#   In C level, the library requires a <tt>gsl_interp_accel</tt> object,
+#   but it is hidden in Ruby/GSL. It is automatically allocated
+#   when a <tt>GSL::Interp</tt> object is created, stored in it,
+#   and destroyed when the <tt>Interp</tt> object
+#   is cleaned by the Ruby GC.
 #   This method is used to access to the <tt>Interp::Accel</tt> object
 #   stored in <tt>self</tt>.
 #
@@ -109,54 +109,54 @@
 # * GSL::Interp#accel_find(xa, x)
 # * GSL::Interp::Accel#find(xa, x)
 #
-#   This method performs a lookup action on the data array <tt>xa</tt>. 
-#   This is how lookups are performed during evaluation 
-#   of an interpolation. The function returns an index <tt>i</tt> such that 
+#   This method performs a lookup action on the data array <tt>xa</tt>.
+#   This is how lookups are performed during evaluation
+#   of an interpolation. The function returns an index <tt>i</tt> such that
 #   <tt>xa[i] <= x < xa[i+1]</tt>.
 #
 #
-# == {}[link:index.html"name="4] Evaluation of Interpolating Functions 
+# == Evaluation of Interpolating Functions
 #
 # ---
 # * GSL::Interp#eval(xa, ya, x)
 # * GSL::Interp#eval_e(xa, ya, x)
 #
-#   These methods return the interpolated value for a given point <tt>x</tt>, 
+#   These methods return the interpolated value for a given point <tt>x</tt>,
 #   using the interpolation object <tt>self</tt>, data vectors <tt>xa</tt> and <tt>ya</tt>.
 #   The data <tt>x</tt> can be a <tt>Numeric, Vector, Matrix</tt> or an <tt>NArray</tt>.
 # ---
 # * GSL::Interp#eval_deriv(xa, ya, x)
 # * GSL::Interp#eval_deriv_e(xa, ya, x)
 #
-#   These methods return the derivative of an interpolated function for a 
-#   given point <tt>x</tt>, using the interpolation object <tt>self</tt>, 
+#   These methods return the derivative of an interpolated function for a
+#   given point <tt>x</tt>, using the interpolation object <tt>self</tt>,
 #   data vectors <tt>xa</tt> and <tt>ya</tt>.
 #
 # ---
 # * GSL::Interp#eval_deriv2(xa, ya, x)
 # * GSL::Interp#eval_deriv2_e(xa, ya, x)
 #
-#   These methods return the second derivative of an interpolated function 
-#   for a given point <tt>x</tt>, using the interpolation object <tt>self</tt>, 
+#   These methods return the second derivative of an interpolated function
+#   for a given point <tt>x</tt>, using the interpolation object <tt>self</tt>,
 #   data vectors <tt>xa</tt> and <tt>ya</tt>.
 #
 # ---
 # * GSL::Interp#eval_integ(xa, ya, a, b)
 # * GSL::Interp#eval_integ_e(xa, ya, a, b)
 #
-#   These methods return the numerical integral result of an interpolated 
-#   function over the range <tt>[a, b]</tt>, using the interpolation object <tt>self</tt>, 
+#   These methods return the numerical integral result of an interpolated
+#   function over the range <tt>[a, b]</tt>, using the interpolation object <tt>self</tt>,
 #   data vectors <tt>xa</tt> and <tt>ya</tt>.
 #
-# == {}[link:index.html"name="5] Higher level interface: GSL::Spline class
-# === {}[link:index.html"name="5.1] Class initialization
+# == Higher level interface
+# === Class initialization
 #
 # ---
 # * GSL::Spline.alloc(T, n)
 # * GSL::Spline.alloc(T, x, y)
 # * GSL::Spline.alloc(x, y, T)
 #
-#   This creates a <tt>GSL::Spline</tt> object of type <tt>T</tt> for <tt>n</tt> 
+#   This creates a <tt>GSL::Spline</tt> object of type <tt>T</tt> for <tt>n</tt>
 #   data-points. The type <tt>T</tt> is the same as <tt>GSL::Interp</tt> class.
 #
 #   These two are equivalent.
@@ -170,8 +170,8 @@
 # ---
 # * GSL::Spline#init(xa, ya)
 #
-#   This initializes a <tt>GSL::Spline</tt> object <tt>self</tt> for the data 
-#   (<tt>xa, ya</tt>) where <tt>xa</tt> and <tt>ya</tt> are Ruby arrays of equal sizes 
+#   This initializes a <tt>GSL::Spline</tt> object <tt>self</tt> for the data
+#   (<tt>xa, ya</tt>) where <tt>xa</tt> and <tt>ya</tt> are Ruby arrays of equal sizes
 #   or <tt>GSL::Vector</tt>.
 #
 # ---
@@ -179,7 +179,7 @@
 #
 #   This returns the name of the spline type used by <tt>self</tt>.
 #
-# === {}[link:index.html"name="5.2] Evaluation
+# === Evaluation
 # ---
 # * GSL::Spline#eval(x)
 #
@@ -188,10 +188,10 @@
 #
 #   NOTE: In a GSL-C program, a <tt>gsl_interp_accel</tt> object is required to use
 #   the function <tt>gsl_spline_eval</tt>.
-#   In Ruby/GSL, the <tt>gsl_interp_accel</tt> is hidden, it is automatically 
-#   allocated when a <tt>GSL::Spline</tt> object is created, 
-#   and also destroyed when the <tt>Spline</tt> object 
-#   is cleaned by the Ruby GC. The accel object can be accessed via the method 
+#   In Ruby/GSL, the <tt>gsl_interp_accel</tt> is hidden, it is automatically
+#   allocated when a <tt>GSL::Spline</tt> object is created,
+#   and also destroyed when the <tt>Spline</tt> object
+#   is cleaned by the Ruby GC. The accel object can be accessed via the method
 #   <tt>GSL::Spline#accel</tt>.
 #
 # ---
@@ -209,23 +209,23 @@
 #
 #   Returns the numerical integral over the range [<tt>a, b</tt>].
 #
-# === {}[link:index.html"name="5.3] Finding and acceleration
+# === Finding and acceleration
 # ---
 # * GSL::Spline#find(xa, x)
 # * GSL::Spline#accel_find(xa, x)
 #
-#   This method performs a lookup action on the data array <tt>xa</tt>. 
-#   This is how lookups are performed during evaluation 
-#   of an interpolation. The function returns an index <tt>i</tt> such that 
+#   This method performs a lookup action on the data array <tt>xa</tt>.
+#   This is how lookups are performed during evaluation
+#   of an interpolation. The function returns an index <tt>i</tt> such that
 #   <tt>xa[i] <= x < xa[i+1]</tt>.
 #
 # See also the GSL manual and the examples in <tt>examples/</tt>
 #
-# {prev}[link:rdoc/odeiv_rdoc.html]
-# {next}[link:rdoc/diff_rdoc.html]
+# {prev}[link:odeiv_rdoc.html]
+# {next}[link:diff_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #
-#   
+#

data/rdoc/intro.rdoc

@@ -1,27 +1,27 @@
 #
 # = Introduction
 #
-# The GNU Scientific Library ({GSL}[http://sources.redhat.com/gsl/"target="_top])
+# The GNU Scientific Library ({GSL}[https://gnu.org/software/gsl/])
 # is a collection of routines for numerical computing.
 # The routines have been written from scratch in C, and present a modern Applications
 # Programming Interface (API) for C programmers, allowing wrappers to be
 # written for very  high level languages. The source code is distributed
 # under the GNU General Public License.
 #
-# {Ruby/GSL}[http://rubyforge.org/projects/rb-gsl/"target="_top] is a Ruby
+# {Ruby/GSL}[https://blackwinter.github.com/rb-gsl] is a Ruby
 # extension for GSL. This provides higher-level interfaces to the GSL functions.
 #
-# == {}[link:index.html"name="1] Requirements
+# == Requirements
 # * GSL (1.4 or later recommended)
 # * ANSI C compiler
 # * Ruby (1.8 or later recommended)
 #
-# == {}[link:index.html"name="2] Installation
+# == Installation
 # See {here}[link:index.html].
 #
-# {next}[link:rdoc/use_rdoc.html]
+# {next}[link:use_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #

data/rdoc/linalg.rdoc

@@ -2,23 +2,23 @@
 # = Linear Algebra
 #
 # Contents:
-# 1. {LU Decomposition}[link:rdoc/linalg_rdoc.html#1]
-# 1. {QR Decomposition}[link:rdoc/linalg_rdoc.html#2]
-# 1. {QR Decomposition with Column Pivoting}[link:rdoc/linalg_rdoc.html#3]
-# 1. {Singular Value Decomposition}[link:rdoc/linalg_rdoc.html#4]
-# 1. {Cholesky Decomposition}[link:rdoc/linalg_rdoc.html#5]
-# 1. {Tridiagonal Decomposition of Real Symmetric Matrices}[link:rdoc/linalg_rdoc.html#6]
-# 1. {Tridiagonal Decomposition of Hermitian Matrices}[link:rdoc/linalg_rdoc.html#7]
-# 1. {Hessenberg Decomposition of Real Matrices}[link:rdoc/linalg_rdoc.html#8]
-# 1. {Hessenberg-Triangular Decomposition of Real Matrices}[link:rdoc/linalg_rdoc.html#9]
-# 1. {Bidiagonalization}[link:rdoc/linalg_rdoc.html#10]
-# 1. {Householder Transformations}[link:rdoc/linalg_rdoc.html#11]
-# 1. {Householder solver for linear systems}[link:rdoc/linalg_rdoc.html#12]
-# 1. {Tridiagonal Systems}[link:rdoc/linalg_rdoc.html#13]
-# 1. {Balancing}[link:rdoc/linalg_rdoc.html#14]
-# 1. {NArray}[link:rdoc/linalg_rdoc.html#15]
-#
-# == {}[link:index.html"name="1] LU Decomposition
+# 1. {LU Decomposition}[link:linalg_rdoc.html#label-LU+Decomposition]
+# 1. {QR Decomposition}[link:linalg_rdoc.html#label-QR+decomposition]
+# 1. {QR Decomposition with Column Pivoting}[link:linalg_rdoc.html#label-QR+Decomposition+with+Column+Pivoting]
+# 1. {Singular Value Decomposition}[link:linalg_rdoc.html#label-Singular+Value+Decomposition]
+# 1. {Cholesky Decomposition}[link:linalg_rdoc.html#label-Cholesky+Decomposition]
+# 1. {Tridiagonal Decomposition of Real Symmetric Matrices}[link:linalg_rdoc.html#label-Tridiagonal+Decomposition+of+Real+Symmetric+Matrices]
+# 1. {Tridiagonal Decomposition of Hermitian Matrices}[link:linalg_rdoc.html#label-Tridiagonal+Decomposition+of+Hermitian+Matrices]
+# 1. {Hessenberg Decomposition of Real Matrices}[link:linalg_rdoc.html#label-Hessenberg+Decomposition+of+Real+Matrices]
+# 1. {Hessenberg-Triangular Decomposition of Real Matrices}[link:linalg_rdoc.html#label-Hessenberg-Triangular+Decomposition+of+Real+Matrices]
+# 1. {Bidiagonalization}[link:linalg_rdoc.html#label-Bidiagonalization]
+# 1. {Householder Transformations}[link:linalg_rdoc.html#label-Householder+Transformations]
+# 1. {Householder solver for linear systems}[link:linalg_rdoc.html#label-Householder+solver+for+linear+systems]
+# 1. {Tridiagonal Systems}[link:linalg_rdoc.html#label-Tridiagonal+Systems]
+# 1. {Balancing}[link:linalg_rdoc.html#label-Balancing]
+# 1. {NArray}[link:linalg_rdoc.html#label-NArray]
+#
+# == LU Decomposition
 # ---
 # * GSL::Linalg::LU.decomp(A)
 # * GSL::Matrix#LU_decomp
@@ -31,9 +31,9 @@
 # 1. Singleton method of the <tt>GSL::Linalg::LU</tt> module
 #
 #         >> m = Matrix[1..9, 3, 3]
-#         => GSL::Matrix: 
-#         [ 1.000e+00 2.000e+00 3.000e+00 
-#           4.000e+00 5.000e+00 6.000e+00 
+#         => GSL::Matrix:
+#         [ 1.000e+00 2.000e+00 3.000e+00
+#           4.000e+00 5.000e+00 6.000e+00
 #           7.000e+00 8.000e+00 9.000e+00 ]
 #         >> lu, perm, sign = Linalg::LU.decomp(m)
 #
@@ -47,7 +47,7 @@
 # * GSL::Matrix#LU_solve(b)
 # * GSL::Linalg::LUMatrix#solve(perm, b)
 #
-#   The following is an example to solve a linear system 
+#   The following is an example to solve a linear system
 #
 #      A x = b, b = [1, 2, 3, 4]
 #
@@ -57,20 +57,20 @@
 #
 #         A = Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
 #                    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
-#         lu, perm, sign = A.LU_decomp         
+#         lu, perm, sign = A.LU_decomp
 #         b = Vector[1, 2, 3, 4]
-#         x = Linalg::LU.solve(lu, perm, b)    
+#         x = Linalg::LU.solve(lu, perm, b)
 #
 # 1. Instance method of <tt>GSL::Linalg::LUMatrix</tt> class
 #
 #         lu, perm, sign = A.LU_decomp  # lu is an instance of Linalg::LUMatrix class
 #         b = Vector[1, 2, 3, 4]
-#         x = lu.solve(perm, b)    
+#         x = lu.solve(perm, b)
 #
 # 1. Solve directly
 #
 #         x = Linalg::LU.solve(A, b)  # LU decomposition is calculated internally (A is not modified)
-#  
+#
 # ---
 # * GSL::Linalg::LU.svx(A, b)
 # * GSL::Linalg::LU.svx(lu, perm, b)
@@ -83,7 +83,7 @@
 # ---
 # * GSL::Linalg::LU.refine(A, lu, perm, b, x)
 #
-#   This method applys an iterative improvement to <tt>x</tt>, 
+#   This method applys an iterative improvement to <tt>x</tt>,
 #   the solution of <tt>A x = b</tt>, using the LU decomposition of <tt>A</tt>.
 #
 # ---
@@ -102,9 +102,9 @@
 #
 #   These methods return the determinant of the matrix.
 #
-# === {}[link:index.html"name="1.1] {Complex LU decomposition}[link:rdoc/linalg_complex_rdoc.html]
+# === {Complex LU decomposition}[link:linalg_complex_rdoc.html]
 #
-# == {}[link:index.html"name="2] QR decomposition
+# == QR decomposition
 #
 # ---
 # * GSL::Linalg::QR_decomp(A)
@@ -142,7 +142,7 @@
 #   * Ex4:
 #       qr, tau = m.QR_decomp
 #       x = qr.solve(tau, b)
-#  
+#
 # ---
 # * GSL::Linalg::QR.svx(A, x)
 # * GSL::Linalg::QR.svx(QR, tau, x)
@@ -161,26 +161,26 @@
 #
 #   Ex:
 #     >> m = Matrix[1..9, 3, 3]
-#     => GSL::Matrix: 
-#     [ 1.000e+00 2.000e+00 3.000e+00 
-#       4.000e+00 5.000e+00 6.000e+00 
+#     => GSL::Matrix:
+#     [ 1.000e+00 2.000e+00 3.000e+00
+#       4.000e+00 5.000e+00 6.000e+00
 #       7.000e+00 8.000e+00 9.000e+00 ]
 #     >> qr, tau = m.QR_decomp
-#     >> q, r = qr.unpack(tau)  
+#     >> q, r = qr.unpack(tau)
 #     >> q*r               # Reconstruct the metrix m
-#     => GSL::Matrix: 
-#     [ 1.000e+00 2.000e+00 3.000e+00 
-#       4.000e+00 5.000e+00 6.000e+00 
+#     => GSL::Matrix:
+#     [ 1.000e+00 2.000e+00 3.000e+00
+#       4.000e+00 5.000e+00 6.000e+00
 #       7.000e+00 8.000e+00 9.000e+00 ]
 #
 # ---
 # * GSL::Linalg::QR.QRsolve(Q, R, tau)
 #
-#   This method solves the system <tt>R x = Q^T b</tt> for <tt>x</tt>. 
-#   It can be used when the QR decomposition of a matrix is available 
+#   This method solves the system <tt>R x = Q^T b</tt> for <tt>x</tt>.
+#   It can be used when the QR decomposition of a matrix is available
 #   in unpacked form as <tt>Q,R</tt>.
 #
-# == {}[link:index.html"name="3] QR Decomposition with Column Pivoting
+# == QR Decomposition with Column Pivoting
 # ---
 # * GSL::Linalg::QRPT.decomp(A)
 # * GSL::Matrix#QRPT_decomp
@@ -214,7 +214,7 @@
 # * GSL::Matrix#QRPT_solve(A, b)
 # * GSL::Linalg::QRPQMatrix#solve(qr, tau, perm, b)
 #
-#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of 
+#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of
 #   <tt>A</tt> into <tt>QR, tau, perm</tt>. The solution <tt>x</tt> is returned as a Vector.
 #
 #   * Ex1:
@@ -234,15 +234,15 @@
 # * GSL::Linalg::QRPT.svx(qr, tau, perm, b)
 # * GSL::Matrix#QRPT_svx(A, b)
 #
-#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of 
+#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of
 #   <tt>A</tt> into <tt>QR, tau, perm</tt>. The input <tt>b</tt> is overwritten by the solution
 #   <tt>x</tt>.
 #
 # ---
 # * GSL::Linalg::QRPT.QRsolve(q, r, tau, perm, b)
 #
-#   This method solves the system <tt>R P^T x = Q^T b</tt> for x. 
-#   It can be used when the QR decomposition of a matrix is available in 
+#   This method solves the system <tt>R P^T x = Q^T b</tt> for x.
+#   It can be used when the QR decomposition of a matrix is available in
 #   unpacked form as <tt>q, r</tt> obtained by the method <tt>decomp2</tt>.
 #
 #   * Ex:
@@ -257,51 +257,51 @@
 # * GSL::Linalg::QRPTMatrix#Rsvx(perm, b)
 #
 #
-# == {}[link:index.html"name="4] Singular Value Decomposition
+# == Singular Value Decomposition
 # ---
 # * GSL::Linalg::SV.decomp(A[, work])
-# * GSL::Matrix#SV_decomp([work])
+# * \GSL::Matrix#SV_decomp([work])
 #
-#   These methods factorize the M-by-N matrix <tt>A</tt> into the singular value 
+#   These methods factorize the M-by-N matrix <tt>A</tt> into the singular value
 #   decomposition <tt>A = U S V^T</tt> using  the Golub-Reinsch SVD algorithm,
 #   and return an array <tt>[U, V, S]</tt>.
 #
-#   Ex: 
+#   Ex:
 #      >> m = Matrix[[3, 5, 2], [5, 1, 4], [7, 6, 3]]
-#      => GSL::Matrix: 
-#      [ 3.000e+00 5.000e+00 2.000e+00 
-#        5.000e+00 1.000e+00 4.000e+00 
+#      => GSL::Matrix:
+#      [ 3.000e+00 5.000e+00 2.000e+00
+#        5.000e+00 1.000e+00 4.000e+00
 #        7.000e+00 6.000e+00 3.000e+00 ]
 #      >> u, v, s = m.SV_decomp  # u, v: Matrix, s: Vector (singular values)
 #      >> u*u.trans              # u is orthnormal
-#      => GSL::Matrix: 
-#      [  1.000e+00  2.452e-17 -4.083e-16 
-#         2.452e-17  1.000e+00 -3.245e-16 
+#      => GSL::Matrix:
+#      [  1.000e+00  2.452e-17 -4.083e-16
+#         2.452e-17  1.000e+00 -3.245e-16
 #        -4.083e-16 -3.245e-16  1.000e+00 ]
 #      >> v*v.trans              # v is also orthnormal
-#      => GSL::Matrix: 
-#      [  1.000e+00  3.555e-17 -1.867e-16 
-#         3.555e-17  1.000e+00 -1.403e-16 
+#      => GSL::Matrix:
+#      [  1.000e+00  3.555e-17 -1.867e-16
+#         3.555e-17  1.000e+00 -1.403e-16
 #        -1.867e-16 -1.403e-16  1.000e+00 ]
 #      >> u*Matrix.diagonal(s)*v.trans # Reconstruct the matrix
-#      => GSL::Matrix: 
-#      [ 3.000e+00 5.000e+00 2.000e+00 
-#        5.000e+00 1.000e+00 4.000e+00 
+#      => GSL::Matrix:
+#      [ 3.000e+00 5.000e+00 2.000e+00
+#        5.000e+00 1.000e+00 4.000e+00
 #        7.000e+00 6.000e+00 3.000e+00 ]
 #
 # ---
 # * GSL::Linalg::SV.decomp_mod(A)
 # * GSL::Matrix#SV_decomp_mod
 #
-#   These compute the SVD using the modified Golub-Reinsch algorithm, 
+#   These compute the SVD using the modified Golub-Reinsch algorithm,
 #   which is faster for M>>N.
 #
 # ---
 # * GSL::Linalg::SV.decomp_jacobi(A)
 # * GSL::Matrix#SV_decomp_jacobi
 #
-#   These compute the SVD using one-sided Jacobi orthogonalization. 
-#   The Jacobi method can compute singular values to higher relative accuracy 
+#   These compute the SVD using one-sided Jacobi orthogonalization.
+#   The Jacobi method can compute singular values to higher relative accuracy
 #   than Golub-Reinsch algorithms.
 #
 # ---
@@ -309,7 +309,7 @@
 # * GSL::Linalg::SV.solve(U, V, S, b)
 # * GSL::Matrix#SV_solve(b)
 #
-#   These methods solve the system <tt>A x = b</tt> using the singular value 
+#   These methods solve the system <tt>A x = b</tt> using the singular value
 #   decomposition <tt>U, S, V</tt> of <tt>A</tt>.
 #
 #   * Ex1:
@@ -322,39 +322,39 @@
 #   * Ex3:
 #       x = m.SV_solve(b)
 #
-# == {}[link:index.html"name="6] Cholesky Decomposition
-# A symmetric, positive definite square matrix <tt>A</tt> has a Cholesky decomposition 
-# into a product of a lower triangular matrix L and its transpose L^T, 
-# as <tt>A = L L^T</tt>. This is sometimes referred to as taking the square-root of a 
-# matrix. The Cholesky decomposition can only be carried out when all the eigenvalues 
-# of the matrix are positive. This decomposition can be used to convert the linear 
-# system <tt>A x = b</tt> into a pair of triangular systems (<tt>L y = b, L^T x = y</tt>), 
+# == Cholesky Decomposition
+# A symmetric, positive definite square matrix <tt>A</tt> has a Cholesky decomposition
+# into a product of a lower triangular matrix L and its transpose L^T,
+# as <tt>A = L L^T</tt>. This is sometimes referred to as taking the square-root of a
+# matrix. The Cholesky decomposition can only be carried out when all the eigenvalues
+# of the matrix are positive. This decomposition can be used to convert the linear
+# system <tt>A x = b</tt> into a pair of triangular systems (<tt>L y = b, L^T x = y</tt>),
 # which can be solved by forward and back-substitution.
 #
 # ---
 # * GSL::Linalg::Cholesky.decomp(A)
 #
-#   This method factorizes the positive-definite square matrix <tt>A</tt> 
-#   into the Cholesky decomposition <tt>A = L L^T</tt>. 
-#   The upper triangular part of the matrix returned contains L^T, the diagonal terms 
-#   being identical for both L and L^T. If the matrix is not positive-definite 
+#   This method factorizes the positive-definite square matrix <tt>A</tt>
+#   into the Cholesky decomposition <tt>A = L L^T</tt>.
+#   The upper triangular part of the matrix returned contains L^T, the diagonal terms
+#   being identical for both L and L^T. If the matrix is not positive-definite
 #   then the decomposition will fail.
 #
-#   Ex: 
+#   Ex:
 #     >> m = Matrix.pascal(3)
 #     => GSL::Matrix
-#     [  1.000e+00  1.000e+00  1.000e+00 
-#        1.000e+00  2.000e+00  3.000e+00 
+#     [  1.000e+00  1.000e+00  1.000e+00
+#        1.000e+00  2.000e+00  3.000e+00
 #        1.000e+00  3.000e+00  6.000e+00 ]
 #     >> c = Linalg::Cholesky.decomp(m)
 #     => GSL::Linalg::Cholesky::CholeskyMatrix
-#     [  1.000e+00  1.000e+00  1.000e+00 
-#        1.000e+00  1.000e+00  2.000e+00 
+#     [  1.000e+00  1.000e+00  1.000e+00
+#        1.000e+00  1.000e+00  2.000e+00
 #        1.000e+00  2.000e+00  1.000e+00 ]
 #     >> l = c.lower
 #     => GSL::Matrix
-#     [  1.000e+00  0.000e+00  0.000e+00 
-#        1.000e+00  1.000e+00  0.000e+00 
+#     [  1.000e+00  0.000e+00  0.000e+00
+#        1.000e+00  1.000e+00  0.000e+00
 #        1.000e+00  2.000e+00  1.000e+00 ]
 #     >> (l*l.trans) == m
 #     => true
@@ -363,122 +363,122 @@
 # * GSL::Linalg::Cholesky.solve(cholesky, b)
 # * GSL::Linalg::Cholesky.svx(cholesky, x)
 #
-#   These methods solve the system <tt>A x = b</tt> using the Cholesky decomposition 
+#   These methods solve the system <tt>A x = b</tt> using the Cholesky decomposition
 #   of <tt>A</tt> into the matrix <tt>cholesky</tt> given by <tt>GSL::Linalg::Cholesky.decomp</tt>.
 #
-# === {}[link:index.html"name="5.1] {Complex Cholesky decomposition}[link:rdoc/cholesky_complex_rdoc.html]
+# === {Complex Cholesky decomposition}[link:cholesky_complex_rdoc.html]
 #
-# == {}[link:index.html"name="6] Tridiagonal Decomposition of Real Symmetric Matrices 
+# == Tridiagonal Decomposition of Real Symmetric Matrices
 # ---
 # * GSL::Linalg::Symmtd::decomp(A)
 #
-#   Factorizes the symmetric square matrix <tt>A</tt> into the symmetric 
+#   Factorizes the symmetric square matrix <tt>A</tt> into the symmetric
 #   tridiagonal decomposition Q T Q^T, and returns the results
-#   <tt>(A', tau)</tt>. On output the diagonal and subdiagonal part of the 
-#   matrix <tt>A'</tt>  contain the tridiagonal matrix <tt>T</tt>. 
-#   The remaining lower triangular part of the matrix <tt>A'</tt> contains 
-#   the Householder vectors which, together with the Householder 
-#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>. 
-#   This storage scheme is the same as used by LAPACK. 
-#   The upper triangular part of <tt>A</tt> is not referenced. 
+#   <tt>(A', tau)</tt>. On output the diagonal and subdiagonal part of the
+#   matrix <tt>A'</tt>  contain the tridiagonal matrix <tt>T</tt>.
+#   The remaining lower triangular part of the matrix <tt>A'</tt> contains
+#   the Householder vectors which, together with the Householder
+#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>.
+#   This storage scheme is the same as used by LAPACK.
+#   The upper triangular part of <tt>A</tt> is not referenced.
 # ---
 # * GSL::Linalg::Symmtd::unpack(A', tau)
 #
-#   Unpacks the encoded symmetric tridiagonal decomposition <tt>(A', tau)</tt> 
-#   obtained from <tt>GSL::Linalg::Symmtd::decomp</tt> into the orthogonal 
-#   matrix <tt>Q</tt>, the vector of diagonal elements <tt>diag</tt> 
-#   and the vector of subdiagonal elements <tt>subdiag</tt>. 
+#   Unpacks the encoded symmetric tridiagonal decomposition <tt>(A', tau)</tt>
+#   obtained from <tt>GSL::Linalg::Symmtd::decomp</tt> into the orthogonal
+#   matrix <tt>Q</tt>, the vector of diagonal elements <tt>diag</tt>
+#   and the vector of subdiagonal elements <tt>subdiag</tt>.
 # ---
 # * GSL::Linalg::Symmtd::unpack_T(A', tau)
 #
-#   Unpacks the diagonal and subdiagonal of the encoded symmetric tridiagonal 
-#   decomposition <tt>(A', tau)</tt> obtained from 
-#   <tt>GSL::Linalg::Symmtd::decomp</tt> into the vectors 
-#   <tt>diag</tt> and <tt>subdiag</tt>. 
+#   Unpacks the diagonal and subdiagonal of the encoded symmetric tridiagonal
+#   decomposition <tt>(A', tau)</tt> obtained from
+#   <tt>GSL::Linalg::Symmtd::decomp</tt> into the vectors
+#   <tt>diag</tt> and <tt>subdiag</tt>.
 #
-# == {}[link:index.html"name="7] Tridiagonal Decomposition of Hermitian Matrices 
+# == Tridiagonal Decomposition of Hermitian Matrices
 # ---
 # * GSL::Linalg::Hermtd::decomp(A)
 #
-#   Factorizes the hermitian matrix <tt>A</tt> into the symmetric tridiagonal 
-#   decomposition U T U^T, and returns the result as <tt>(A', tau)</tt>. 
+#   Factorizes the hermitian matrix <tt>A</tt> into the symmetric tridiagonal
+#   decomposition U T U^T, and returns the result as <tt>(A', tau)</tt>.
 #   On output the real parts of the diagonal and subdiagonal part of the
-#   matrix <tt>A'</tt> contain the tridiagonal matrix <tt>T</tt>. 
-#   The remaining lower triangular part of the matrix <tt>A'</tt> contains 
-#   the Householder vectors which, together with the Householder 
-#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>. 
-#   This storage scheme is the same as used by LAPACK. 
-#   The upper triangular part of <tt>A</tt> and imaginary parts of the diagonal 
-#   are not referenced. 
+#   matrix <tt>A'</tt> contain the tridiagonal matrix <tt>T</tt>.
+#   The remaining lower triangular part of the matrix <tt>A'</tt> contains
+#   the Householder vectors which, together with the Householder
+#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>.
+#   This storage scheme is the same as used by LAPACK.
+#   The upper triangular part of <tt>A</tt> and imaginary parts of the diagonal
+#   are not referenced.
 #
 # ---
 # * GSL::Linalg::Hermtd::unpack(A', tau)
 #
-#   Unpacks the encoded tridiagonal decomposition <tt>(A', tau)</tt> 
-#   obtained from <tt>GSL::Linalg::Hermtd::decomp</tt> into the unitary matrix 
-#   <tt>U</tt>, the real vector of diagonal elements <tt>diag</tt> and 
-#   the real vector of subdiagonal elements <tt>subdiag</tt>. 
+#   Unpacks the encoded tridiagonal decomposition <tt>(A', tau)</tt>
+#   obtained from <tt>GSL::Linalg::Hermtd::decomp</tt> into the unitary matrix
+#   <tt>U</tt>, the real vector of diagonal elements <tt>diag</tt> and
+#   the real vector of subdiagonal elements <tt>subdiag</tt>.
 #
 # ---
 # * GSL::Linalg::Hermtd::unpack_T(A', tau)
 #
-#   Unpacks the diagonal and subdiagonal of the encoded tridiagonal 
-#   decomposition <tt>(A, tau)</tt> obtained from the 
-#   <tt>GSL::Linalg::Hermtd::decomp</tt> 
-#   into the real vectors <tt>diag</tt> and <tt>subdiag</tt>. 
+#   Unpacks the diagonal and subdiagonal of the encoded tridiagonal
+#   decomposition <tt>(A, tau)</tt> obtained from the
+#   <tt>GSL::Linalg::Hermtd::decomp</tt>
+#   into the real vectors <tt>diag</tt> and <tt>subdiag</tt>.
 #
-# == {}[link:index.html"name="8] Hessenberg Decomposition of Real Matrices 
+# == Hessenberg Decomposition of Real Matrices
 # ---
 # * GSL::Linalg::Hessenberg::decomp(A)
 # * GSL::Linalg::hessenberg_decomp(A)
 #
-#   Computes the Hessenberg decomposition of the matrix <tt>A</tt> 
+#   Computes the Hessenberg decomposition of the matrix <tt>A</tt>
 #   by applying the similarity transformation <tt>H = U^T A U</tt>, and returns
-#   the result as <tt>(A', tau</tt>. On output, <tt>H</tt> is stored in the upper 
-#   portion of <tt>A'</tt>. The information required to construct the matrix 
-#   <tt>U</tt> is stored in the lower triangular portion of <tt>A'</tt>. 
-#   <tt>U</tt> is a product of N - 2 Householder matrices. 
-#   The Householder vectors are stored in the lower portion of <tt>A'</tt> 
-#   (below the subdiagonal) and the Householder coefficients are stored 
+#   the result as <tt>(A', tau</tt>. On output, <tt>H</tt> is stored in the upper
+#   portion of <tt>A'</tt>. The information required to construct the matrix
+#   <tt>U</tt> is stored in the lower triangular portion of <tt>A'</tt>.
+#   <tt>U</tt> is a product of N - 2 Householder matrices.
+#   The Householder vectors are stored in the lower portion of <tt>A'</tt>
+#   (below the subdiagonal) and the Householder coefficients are stored
 #   in the vector <tt>tau</tt>.
 #
 # ---
 # * GSL::Linalg::Hessenberg::unpack(A', tau)
 # * GSL::Linalg::hessenberg_unpack(A', tau)
 #
-#   Constructs the orthogonal matrix <tt>U</tt> and returns it 
-#   from the information stored  in the Hessenberg matrix <tt>A'</tt> 
-#   along with the vector <tt>tau</tt>. <tt>A'</tt> and <tt>tau</tt> 
+#   Constructs the orthogonal matrix <tt>U</tt> and returns it
+#   from the information stored  in the Hessenberg matrix <tt>A'</tt>
+#   along with the vector <tt>tau</tt>. <tt>A'</tt> and <tt>tau</tt>
 #   are outputs from <tt>GSL::Linalg::Hessenberg::decomp</tt>.
 #
 # ---
 # * GSL::Linalg::Hessenberg::unpack_accum(A', tau, V = I)
 # * GSL::Linalg::hessenberg_unpack_accum(A', tau, V = I)
 #
-#   This method is similar to <tt>GSL::Linalg::Hessenberg::unpack</tt>, 
-#   except it accumulates the matrix <tt>U</tt> into <tt>V</tt>, so that 
-#   <tt>V' = VU</tt>, and returns <tt>V</tt>. Setting V to the identity matrix 
-#   provides the same result <tt>GSL::Linalg::Hessenberg::unpack</tt>. 
+#   This method is similar to <tt>GSL::Linalg::Hessenberg::unpack</tt>,
+#   except it accumulates the matrix <tt>U</tt> into <tt>V</tt>, so that
+#   <tt>V' = VU</tt>, and returns <tt>V</tt>. Setting V to the identity matrix
+#   provides the same result <tt>GSL::Linalg::Hessenberg::unpack</tt>.
 #
 # ---
 # * GSL::Linalg::Hessenberg::set_zero(A')
 # * GSL::Linalg::hessenberg_set_zero(A')
 #
-#   Sets the lower triangular portion of <tt>A'</tt>, below the subdiagonal, 
-#   to zero. 
-#   It is useful for clearing out the Householder vectors after calling 
+#   Sets the lower triangular portion of <tt>A'</tt>, below the subdiagonal,
+#   to zero.
+#   It is useful for clearing out the Householder vectors after calling
 #   <tt>GSL::Linalg::Hessenberg::decomp</tt>.
 #
-# == {}[link:index.html"name="9] Hessenberg-Triangular Decomposition of Real Matrices 
+# == Hessenberg-Triangular Decomposition of Real Matrices
 # ---
 # * GSL::Linalg::hesstri_decomp(A, B)
 # * GSL::Linalg::hesstri_decomp(A, B, work)
 # * GSL::Linalg::hesstri_decomp(A, B, U, V)
 # * GSL::Linalg::hesstri_decomp(A, B, U, V, work)
 #
-#   Compute the Hessenberg-Triangular decomposition of the matrix pair 
+#   Compute the Hessenberg-Triangular decomposition of the matrix pair
 #   <tt>(A, B)</tt>, and return <tt>(H, R</tt>.
-#   If U and V are provided (they may be null), the similarity 
+#   If U and V are provided (they may be null), the similarity
 #   transformations are stored in them. <tt>work</tt> is an additional workspace
 #   of length <tt>N</tt>.
 #
@@ -488,14 +488,14 @@
 # * GSL::Linalg::hesstri_decomp!(A, B, U, V)
 # * GSL::Linalg::hesstri_decomp!(A, B, U, V, work)
 #
-#   Compute the Hessenberg-Triangular decomposition of the matrix pair 
-#   <tt>(A, B)</tt>. On output, <tt>H</tt> is stored in <tt>A</tt>, 
+#   Compute the Hessenberg-Triangular decomposition of the matrix pair
+#   <tt>(A, B)</tt>. On output, <tt>H</tt> is stored in <tt>A</tt>,
 #   and <tt>R</tt> is stored in <tt>B</tt>.
-#   If U and V are provided (they may be null), the similarity 
+#   If U and V are provided (they may be null), the similarity
 #   transformations are stored in them. <tt>work</tt> is an additional workspace
 #   of length <tt>N</tt>.
 #
-# == {}[link:index.html"name="10] Bidiagonalization
+# == Bidiagonalization
 # ---
 # * GSL::Linalg::Bidiag::decomp!(A)
 # * GSL::Linalg::bidiag_decomp!(A)
@@ -512,71 +512,71 @@
 # * GSL::Linalg::bidiag_unpack_B
 #
 #
-# == {}[link:index.html"name="11] Householder Transformations
+# == Householder Transformations
 # ---
 # * GSL::Linalg::Householder::transform(v)
 # * GSL::Linalg::HH::transform(v)
 # * GSL::Vector#householder_transform
 #
-#   These methods prepare a Householder transformation P = I - tau v v^T 
-#   which can be used to zero all the elements of the input vector except the first. 
-#   On output the transformation is stored in the vector <tt>v</tt> 
+#   These methods prepare a Householder transformation P = I - tau v v^T
+#   which can be used to zero all the elements of the input vector except the first.
+#   On output the transformation is stored in the vector <tt>v</tt>
 #   and the scalar tau is returned.
 #
 # ---
 # * GSL::Linalg::Householder::hm(tau, v, A)
 # * GSL::Linalg::HH::hm(tau, v, A)
 #
-#   These methods apply the Householder matrix P defined by the scalar 
-#   <tt>tau</tt> and the vector <tt>v</tt> to the left-hand side of the matrix <tt>A</tt>. 
+#   These methods apply the Householder matrix P defined by the scalar
+#   <tt>tau</tt> and the vector <tt>v</tt> to the left-hand side of the matrix <tt>A</tt>.
 #   On output the result P A is stored in <tt>A</tt>.
 #
 # ---
 # * GSL::Linalg::Householder::mh(tau, v, A)
 # * GSL::Linalg::HH::mh(tau, v, A)
 #
-#   These methods apply the Householder matrix P defined by the scalar <tt>tau</tt> 
-#   and the vector <tt>v</tt> to the right-hand side of the matrix <tt>A</tt>. 
+#   These methods apply the Householder matrix P defined by the scalar <tt>tau</tt>
+#   and the vector <tt>v</tt> to the right-hand side of the matrix <tt>A</tt>.
 #   On output the result A P is stored in <tt>A</tt>.
 #
 # ---
 # * GSL::Linalg::Householder::hv(tau, v, w)
 # * GSL::Linalg::HH::hv(tau, v, w)
 #
-#   These methods apply the Householder transformation P defined by the scalar 
-#   <tt>tau</tt> and the vector <tt>v</tt> to the vector <tt>w</tt>. 
+#   These methods apply the Householder transformation P defined by the scalar
+#   <tt>tau</tt> and the vector <tt>v</tt> to the vector <tt>w</tt>.
 #   On output the result P w is stored in <tt>w</tt>.
 #
-# == {}[link:index.html"name="12] Householder solver for linear systems
+# == Householder solver for linear systems
 # ---
 # * GSL::Linalg::HH.solve(A, b)
 # * GSL::Matrix#HH_solve(b)
 #
-#   These methods solve the system <tt>A x = b</tt> directly using Householder 
+#   These methods solve the system <tt>A x = b</tt> directly using Householder
 #   transformations. The matrix <tt>A</tt> is not modified.
 # ---
 # * GSL::Linalg::HH.solve!(A, b)
 # * GSL::Matrix#HH_solve!(b)
 #
-#   These methods solve the system <tt>A x = b</tt> directly using Householder 
-#   transformations. The matrix <tt>A</tt> is destroyed by the 
+#   These methods solve the system <tt>A x = b</tt> directly using Householder
+#   transformations. The matrix <tt>A</tt> is destroyed by the
 #   Householder transformations.
 #
 # ---
 # * GSL::Linalg::HH.svx(A, b)
 # * GSL::Matrix#HH_svx(b)
 #
-#   These methods solve the system <tt>A x = b</tt> in-place directly using Householder 
+#   These methods solve the system <tt>A x = b</tt> in-place directly using Householder
 #   transformations. The input vector <tt>b</tt> is replaced by the solution.
 #
-# == {}[link:index.html"name="13] Tridiagonal Systems
+# == Tridiagonal Systems
 # ---
 # * GSL::Linglg::solve_tridiag(diag, e, f, b)
 # * GSL::Linglg::Tridiag::solve(diag, e, f, b)
 #
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt> 
-#   is tridiagonal ( N >= 2). The super-diagonal and sub-diagonal vectors <tt>e</tt> 
-#   and <tt>f</tt> must be one element shorter than the diagonal vector <tt>diag</tt>. 
+#   These methods solve the general N-by-N system A x = b where <tt>A</tt>
+#   is tridiagonal ( N >= 2). The super-diagonal and sub-diagonal vectors <tt>e</tt>
+#   and <tt>f</tt> must be one element shorter than the diagonal vector <tt>diag</tt>.
 #   The form of <tt>A</tt> for the 4-by-4 case is shown below,
 #        A = ( d_0 e_0  0   0  )
 #            ( f_0 d_1 e_1  0  )
@@ -587,9 +587,9 @@
 # * GSL::Linglg::solve_symm_tridiag(diag, e, b)
 # * GSL::Linglg::Tridiag::solve_symm(diag, e, b)
 #
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is 
-#   symmetric tridiagonal ( N >= 2). The off-diagonal vector <tt>e</tt> must 
-#   be one element shorter than the diagonal vector <tt>diag</tt>. 
+#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is
+#   symmetric tridiagonal ( N >= 2). The off-diagonal vector <tt>e</tt> must
+#   be one element shorter than the diagonal vector <tt>diag</tt>.
 #   The form of <tt>A</tt> for the 4-by-4 case is shown below,
 #        A = ( d_0 e_0  0   0  )
 #            ( e_0 d_1 e_1  0  )
@@ -600,9 +600,9 @@
 # * GSL::Linglg::solve_cyc_tridiag(diag, e, f, b)
 # * GSL::Linglg::Tridiag::solve_cyc(diag, e, f, b)
 #
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is 
-#   cyclic tridiagonal ( N >= 3). The cyclic super-diagonal and sub-diagonal 
-#   vectors <tt>e</tt> and <tt>f</tt> must have the same number of elements as the 
+#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is
+#   cyclic tridiagonal ( N >= 3). The cyclic super-diagonal and sub-diagonal
+#   vectors <tt>e</tt> and <tt>f</tt> must have the same number of elements as the
 #   diagonal vector <tt>diag</tt>. The form of <tt>A</tt> for the 4-by-4 case is shown below,
 #        A = ( d_0 e_0  0  f_3 )
 #            ( f_0 d_1 e_1  0  )
@@ -613,40 +613,40 @@
 # * GSL::Linglg::solve_symm_cyc_tridiag(diag, e, b)
 # * GSL::Linglg::Tridiag::solve_symm_cyc(diag, e, b)
 #
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt> 
-#   is symmetric cyclic tridiagonal ( N >= 3). The cyclic off-diagonal vector <tt>e</tt> 
-#   must have the same number of elements as the diagonal vector <tt>diag</tt>. 
+#   These methods solve the general N-by-N system A x = b where <tt>A</tt>
+#   is symmetric cyclic tridiagonal ( N >= 3). The cyclic off-diagonal vector <tt>e</tt>
+#   must have the same number of elements as the diagonal vector <tt>diag</tt>.
 #   The form of <tt>A</tt> for the 4-by-4 case is shown below,
 #        A = ( d_0 e_0  0  e_3 )
 #            ( e_0 d_1 e_1  0  )
 #            (  0  e_1 d_2 e_2 )
 #            ( e_3  0  e_2 d_3 )
 #
-# == {}[link:index.html"name="14] Balancing
-# The process of balancing a matrix applies similarity transformations to 
-# make the rows and columns have comparable norms. This is useful, 
-# for example, to reduce roundoff errors in the solution of eigenvalue problems. 
-# Balancing a matrix <tt>A</tt> consists of replacing <tt>A</tt> with a similar matrix 
-# where <tt>D</tt> is a diagonal matrix whose entries are powers of the floating 
-# point radix. 
+# == Balancing
+# The process of balancing a matrix applies similarity transformations to
+# make the rows and columns have comparable norms. This is useful,
+# for example, to reduce roundoff errors in the solution of eigenvalue problems.
+# Balancing a matrix <tt>A</tt> consists of replacing <tt>A</tt> with a similar matrix
+# where <tt>D</tt> is a diagonal matrix whose entries are powers of the floating
+# point radix.
 #
 # ---
 # * GSL::Linalg::balance(A)
 # * GSL::Linalg::balance(A, D)
 #
-#   Calculates the balanced counterpart of <tt>A</tt> and the diagonal elements 
+#   Calculates the balanced counterpart of <tt>A</tt> and the diagonal elements
 #   of the similarity transformation. The result is returned as <tt>(A', D)</tt>.
 #
 # ---
 # * GSL::Linalg::balance!(A)
 # * GSL::Linalg::balance!(A, D)
 #
-#   Replaces the matrix <tt>A</tt> with its balanced counterpart and 
-#   stores the diagonal elements of the similarity transformation into 
-#   the vector <tt>D</tt>. 
+#   Replaces the matrix <tt>A</tt> with its balanced counterpart and
+#   stores the diagonal elements of the similarity transformation into
+#   the vector <tt>D</tt>.
 #
 #
-# == {}[link:index.html"name="15] NArray
+# == NArray
 # The following Linalg methods can handle NArray objects:
 # * GSL::Linalg::
 #   * LU::
@@ -658,7 +658,7 @@
 #     * LU.invert(lu, perm)
 #   * QR::
 #     * QR.decomp(m)
-#     * QR.solve(qr, tau, b)	
+#     * QR.solve(qr, tau, b)
 #     * QR.svx(qr, tau, bx)
 #   * SV::
 #     * SV.decomp(m)
@@ -672,10 +672,10 @@
 #     * HH.solve(m, b)
 #     * HH.svx(m, bx)
 #
-# {prev}[link:rdoc/blas_rdoc.html]
-# {next}[link:rdoc/eigen_rdoc.html]
+# {prev}[link:blas_rdoc.html]
+# {next}[link:eigen_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #