gsl 1.15.3 → 1.16.0.6

data/rdoc/multiroot.rdoc

@@ -1,71 +1,71 @@
 #
 # = Multidimensional Root-Finding
-# This chapter describes functions for multidimensional root-finding 
-# (solving nonlinear systems with n equations in n unknowns). 
-# The library provides low level components for a variety of iterative solvers 
-# and convergence tests. These can be combined by the user to achieve the 
-# desired solution, with full access to the intermediate steps of the iteration. 
-# Each class of methods uses the same framework, so that you can switch between 
-# solvers at runtime without needing to recompile your program. Each instance of 
-# a solver keeps track of its own state, allowing the solvers to be used in 
+# This chapter describes functions for multidimensional root-finding
+# (solving nonlinear systems with n equations in n unknowns).
+# The library provides low level components for a variety of iterative solvers
+# and convergence tests. These can be combined by the user to achieve the
+# desired solution, with full access to the intermediate steps of the iteration.
+# Each class of methods uses the same framework, so that you can switch between
+# solvers at runtime without needing to recompile your program. Each instance of
+# a solver keeps track of its own state, allowing the solvers to be used in
 # multi-threaded programs.
 #
-# 1. {Overview}[link:files/rdoc/multiroot_rdoc.html#1]
-# 1. {Initializing the Solver}[link:files/rdoc/multiroot_rdoc.html#2]
-# 1. {Providing the function to solve}[link:files/rdoc/multiroot_rdoc.html#3]
-# 1. {Iteration}[link:files/rdoc/multiroot_rdoc.html#4]
-# 1. {Search Stopping Parameters}[link:files/rdoc/multiroot_rdoc.html#5]
-# 1. {Higher Level Interface}[link:files/rdoc/multiroot_rdoc.html#6]
-# 1. {Examples}[link:files/rdoc/multiroot_rdoc.html#7]
-#    1. {FSolver}[link:files/rdoc/multiroot_rdoc.html#7.1]
-#    1. {FdfSolver}[link:files/rdoc/multiroot_rdoc.html#7.2]
-#
-#
-# == {}[link:index.html"name="1] Overview
-# The problem of multidimensional root finding requires the simultaneous 
-# solution of n equations, f_i, in n variables, x_i, In general there are no 
-# bracketing methods available for n dimensional systems, and no way of knowing 
-# whether any solutions exist. All algorithms proceed from an initial guess 
-# using a variant of the Newton iteration, where x, f are vector quantities and 
-# J is the Jacobian matrix J_{ij} = d f_i / d x_j. Additional strategies can be 
-# used to enlarge the region of convergence. These include requiring a decrease 
-# in the norm |f| on each step proposed by Newton's method, or taking 
-# steepest-descent steps in the direction of the negative gradient of |f|. 
-#
-# Several root-finding algorithms are available within a single framework. 
-# The user provides a high-level driver for the algorithms, and the library 
-# provides the individual functions necessary for each of the steps. There are 
-# three main phases of the iteration. The steps are, 
+# 1. {Overview}[link:rdoc/multiroot_rdoc.html#label-Overview]
+# 1. {Initializing the Solver}[link:rdoc/multiroot_rdoc.html#label-Initializing+the+Solver]
+# 1. {Providing the function to solve}[link:rdoc/multiroot_rdoc.html#label-Providing+the+function+to+solve]
+# 1. {Iteration}[link:rdoc/multiroot_rdoc.html#label-Iteration]
+# 1. {Search Stopping Parameters}[link:rdoc/multiroot_rdoc.html#label-Search+Stopping+Parameters]
+# 1. {Higher Level Interface}[link:rdoc/multiroot_rdoc.html#label-Higher+Level+Interface]
+# 1. {Examples}[link:rdoc/multiroot_rdoc.html#label-Example]
+#    1. {FSolver}[link:rdoc/multiroot_rdoc.html#label-FSolver]
+#    1. {FdfSolver}[link:rdoc/multiroot_rdoc.html#label-FdfSolver]
+#
+#
+# == Overview
+# The problem of multidimensional root finding requires the simultaneous
+# solution of n equations, f_i, in n variables, x_i, In general there are no
+# bracketing methods available for n dimensional systems, and no way of knowing
+# whether any solutions exist. All algorithms proceed from an initial guess
+# using a variant of the Newton iteration, where x, f are vector quantities and
+# J is the Jacobian matrix J_{ij} = d f_i / d x_j. Additional strategies can be
+# used to enlarge the region of convergence. These include requiring a decrease
+# in the norm |f| on each step proposed by Newton's method, or taking
+# steepest-descent steps in the direction of the negative gradient of |f|.
+#
+# Several root-finding algorithms are available within a single framework.
+# The user provides a high-level driver for the algorithms, and the library
+# provides the individual functions necessary for each of the steps. There are
+# three main phases of the iteration. The steps are,
 #
 # * initialize solver state, <tt>s</tt>, for algorithm <tt>T</tt>
 # * update <tt>s</tt> using the iteration <tt>T</tt>
-# * test <tt>s</tt> for convergence, and repeat iteration if necessary 
+# * test <tt>s</tt> for convergence, and repeat iteration if necessary
 #
-# The evaluation of the Jacobian matrix can be problematic, either because 
-# programming the derivatives is intractable or because computation of the n^2 
-# terms of the matrix becomes too expensive. For these reasons the algorithms 
-# provided by the library are divided into two classes according to whether 
-# the derivatives are available or not. 
+# The evaluation of the Jacobian matrix can be problematic, either because
+# programming the derivatives is intractable or because computation of the n^2
+# terms of the matrix becomes too expensive. For these reasons the algorithms
+# provided by the library are divided into two classes according to whether
+# the derivatives are available or not.
 #
-# The state for solvers with an analytic Jacobian matrix is held in a 
-# <tt>GSL::MultiRoot::FdfSolver</tt> object. The updating procedure requires both 
-# the function and its derivatives to be supplied by the user. 
+# The state for solvers with an analytic Jacobian matrix is held in a
+# <tt>GSL::MultiRoot::FdfSolver</tt> object. The updating procedure requires both
+# the function and its derivatives to be supplied by the user.
 #
-# The state for solvers which do not use an analytic Jacobian matrix is held in 
-# a <tt>GSL::MultiRoot::FSolver</tt> object. The updating procedure uses only 
-# function evaluations (not derivatives). The algorithms estimate the matrix J 
-# or J^{-1} by approximate methods. 
+# The state for solvers which do not use an analytic Jacobian matrix is held in
+# a <tt>GSL::MultiRoot::FSolver</tt> object. The updating procedure uses only
+# function evaluations (not derivatives). The algorithms estimate the matrix J
+# or J^{-1} by approximate methods.
 #
 #
-# == {}[link:index.html"name="2] Initializing the Solver
-# Two types of solvers are available. The solver itself depends only on the 
+# == Initializing the Solver
+# Two types of solvers are available. The solver itself depends only on the
 # dimension of the problem and the algorithm and can be reused for different problems.
 # The <tt>FdfSolver</tt> requires derivatives of the function to solve.
 #
 # ---
 # * GSL::MultiRoot::FSolver.alloc(T, n)
 #
-#   This creates an instance of the <tt>FSolver</tt> class of type <tt>T</tt> 
+#   This creates an instance of the <tt>FSolver</tt> class of type <tt>T</tt>
 #   for a system of <tt>n</tt> dimensions. The type is given by a constant or a string,
 #   * GSL::MultiRoot:FSolver::HYBRIDS, or "hybrids"
 #   * GSL::MultiRoot:FSolver::HYBRID, or "hybrid"
@@ -75,7 +75,7 @@
 # ---
 # * GSL::MultiRoot::FdfSolver.alloc(T, n)
 #
-#   This creates an instance of the <tt>FdfSolver</tt> class of type <tt>T</tt> 
+#   This creates an instance of the <tt>FdfSolver</tt> class of type <tt>T</tt>
 #   for a system of <tt>n</tt> dimensions. The type is given by a constant,
 #   * GSL::MultiRoot:FdfSolver::HYBRIDSJ, or "hybridsj"
 #   * GSL::MultiRoot:FdfSolver::HYBRIDJ, or "hybridj",
@@ -85,16 +85,16 @@
 # ---
 # * GSL::MultiRoot::FSolver#set(func, x)
 #
-#   This method sets, or resets, an existing solver <tt>self</tt> 
+#   This method sets, or resets, an existing solver <tt>self</tt>
 #   to use the function <tt>func</tt> and the initial guess <tt>x</tt>.
-#   Here <tt>x</tt> is a <tt>Vector</tt>, and <tt>func</tt> 
+#   Here <tt>x</tt> is a <tt>Vector</tt>, and <tt>func</tt>
 #   is a <tt>MultiRoot:Function</tt> object.
 # ---
 # * GSL::MultiRoot::FdfSolver#set(func_fdf, x)
 #
-#   This method sets, or resets, an existing solver <tt>self</tt> 
+#   This method sets, or resets, an existing solver <tt>self</tt>
 #   to use the function <tt>func_fdf</tt> and the initial guess <tt>x</tt>.
-#   Here <tt>x</tt> is a <tt>Vector</tt>, and <tt>func_fdf</tt> 
+#   Here <tt>x</tt> is a <tt>Vector</tt>, and <tt>func_fdf</tt>
 #   is a <tt>MultiRoot:Function_fdf</tt> object.
 #
 # ---
@@ -102,7 +102,7 @@
 # * GSL::MultiRoot::FdfSolver#name
 #
 #
-# == {}[link:index.html"name="3] Providing the function to solve
+# == Providing the function to solve
 # ---
 # * GSL::MultiRoot:Function.alloc(proc, dim, params)
 #
@@ -128,7 +128,7 @@
 # * GSL::MultiRoot:Function_fdf.alloc(proc, dim, params)
 #
 #   See the example below:
-#   
+#
 #     procf = Proc.new { |x, params, f|
 #       a = params[0]; b = params[1]
 #       x0 = x[0]; x1 = x[1]
@@ -151,19 +151,19 @@
 #     x = [-10.0, -5.0]
 #     fdfsolver.set(func_fdf, x)
 #
-# == {}[link:index.html"name="4] Iteration
+# == Iteration
 # ---
 # * GSL::MultiRoot::FSolver#interate
 # * GSL::MultiRoot::FdfSolver#interate
 #
-#   These methods perform a single iteration of the solver <tt>self</tt>. 
-#   If the iteration encounters an unexpected problem then an error code will 
+#   These methods perform a single iteration of the solver <tt>self</tt>.
+#   If the iteration encounters an unexpected problem then an error code will
 #   be returned,
-#   * GSL_EBADFUNC: the iteration encountered a singular point where the function 
+#   * GSL_EBADFUNC: the iteration encountered a singular point where the function
 #     or its derivative evaluated to Inf or NaN.
-#   * GSL_ENOPROG: the iteration is not making any progress, preventing the 
+#   * GSL_ENOPROG: the iteration is not making any progress, preventing the
 #     algorithm from continuing.
-#   The solver maintains a current best estimate of the root at all times. 
+#   The solver maintains a current best estimate of the root at all times.
 #   This information can be accessed with the following auxiliary methods.
 #
 # ---
@@ -176,7 +176,7 @@
 # * GSL::MultiRoot::FSolver#f
 # * GSL::MultiRoot::FdfSolver#f
 #
-#   These methds return the function value <tt>f(x)</tt> (Vector) at the current estimate 
+#   These methds return the function value <tt>f(x)</tt> (Vector) at the current estimate
 #   of the root for the solver <tt>self</tt>.
 #
 # ---
@@ -185,14 +185,14 @@
 #
 #   These method return the last step <tt>dx</tt> (Vector) taken by the solver <tt>self</tt>.
 #
-# == {}[link:index.html"name="5] Search Stopping Parameters
+# == Search Stopping Parameters
 # ---
 # * GSL::MultiRoot::FSolver#test_delta(epsabs, epsrel)
 # * GSL::MultiRoot::FdfSolver#test_delta(epsabs, epsrel)
 #
-#   This method tests for the convergence of the sequence by comparing the last step 
-#   <tt>dx</tt> with the absolute error <tt>epsabs</tt> and relative error <tt>epsrel</tt> 
-#   to the current position <tt>x</tt>. 
+#   This method tests for the convergence of the sequence by comparing the last step
+#   <tt>dx</tt> with the absolute error <tt>epsabs</tt> and relative error <tt>epsrel</tt>
+#   to the current position <tt>x</tt>.
 #   The test returns <tt>GSL::SUCCESS</tt> if the following condition is achieved,
 #     |dx_i| < epsabs + epsrel |x_i|
 #   for each component of <tt>x</tt> and returns <tt>GSL::CONTINUE</tt> otherwise.
@@ -201,15 +201,15 @@
 # * GSL::MultiRoot::FSolver#test_residual(epsabs)
 # * GSL::MultiRoot::FdfSolver#test_residual(epsabs)
 #
-#   This method tests the residual value <tt>f</tt> against the absolute error 
-#   bound <tt>epsabs</tt>. The test returns <tt>GSL::SUCCESS</tt> if the following 
+#   This method tests the residual value <tt>f</tt> against the absolute error
+#   bound <tt>epsabs</tt>. The test returns <tt>GSL::SUCCESS</tt> if the following
 #   condition is achieved,
 #      sum_i |f_i| < epsabs
-#   and returns <tt>GSL::CONTINUE</tt> otherwise. This criterion is suitable for 
-#   situations where the precise location of the root, <tt>x</tt>, is unimportant 
+#   and returns <tt>GSL::CONTINUE</tt> otherwise. This criterion is suitable for
+#   situations where the precise location of the root, <tt>x</tt>, is unimportant
 #   provided a value can be found where the residual is small enough.
 #
-# == {}[link:index.html"name="6] Higher Level Interface
+# == Higher Level Interface
 # ---
 # * GSL::MultiRoot::Function#solve(x0, max_iter = 1000, eps = 1e-7, type = "hybrids")
 # * GSL::MultiRoot::FSolver#solve(max_iter = 1000, eps = 1e-7)
@@ -217,9 +217,9 @@
 #
 # See sample script <tt>examples/multiroot/fsolver3.rb</tt>.
 #
-# == {}[link:index.html"name="7] Example
+# == Example
 #
-# === {}[link:index.html"name="7.1] FSolver
+# === FSolver
 #
 #      proc = Proc.new { |x, params, f|
 #        a = params[0];  b = params[1]
@@ -246,7 +246,7 @@
 #        status = fsolver.test_residual(1e-7)
 #      end while status == GSL::CONTINUE and iter < 1000
 #
-# === {}[link:index.html"name="7.2] FdfSolver
+# === FdfSolver
 #      n = 2
 #
 #      procf = Proc.new { |x, params, f|
@@ -284,10 +284,10 @@
 #        status = fdfsolver.test_residual(1e-7)
 #      end while status == GSL::CONTINUE and iter < 1000
 #
-# {prev}[link:files/rdoc/min_rdoc.html]
-# {next}[link:files/rdoc/multimin_rdoc.html]
+# {prev}[link:rdoc/min_rdoc.html]
+# {next}[link:rdoc/multimin_rdoc.html]
 #
-# {Reference index}[link:files/rdoc/ref_rdoc.html]
-# {top}[link:files/rdoc/index_rdoc.html]
+# {Reference index}[link:rdoc/ref_rdoc.html]
+# {top}[link:index.html]
 #
 #

data/rdoc/narray.rdoc

@@ -1,11 +1,11 @@
 #
 # = NArray compatibilities
-# === {}[link:index.html"name="0.1] Contents:
-# 1. {Data type conversions}[link:files/rdoc/narray_rdoc.html#1]
-# 1. {Methods which accepts NArray}[link:files/rdoc/narray_rdoc.html#2]
+# === Contents:
+# 1. {Data type conversions}[link:rdoc/narray_rdoc.html#label-Data+type+conversions]
+# 1. {Methods which accepts NArray}[link:rdoc/narray_rdoc.html#label-Methods+which+accepts+NArray]
 #
-# == {}[link:index.html"name="1] Data type conversions
-# === {}[link:index.html"name="1.1] GSL to NArray
+# == Data type conversions
+# === GSL to NArray
 #
 # ---
 # * GSL::Vector#to_na
@@ -34,7 +34,7 @@
 #     => GSL::Vector::Int
 #     [ 0 1 2 3 4 5 ]
 #     >> na = v.to_nvector_ref
-#     => NVector(ref).int(6): 
+#     => NVector(ref).int(6):
 #     [ 0, 1, 2, 3, 4, 5 ]
 #     >> na[3] = 999
 #     => 999
@@ -42,7 +42,7 @@
 #     => GSL::Vector::Int
 #     [ 0 1 2 999 4 5 ]
 #
-# === {}[link:index.html"name="1.2] NArray to GSL
+# === NArray to GSL
 # ---
 # * NArray#to_gv
 # * NArray#to_gm
@@ -56,12 +56,12 @@
 # * NArray#to_gv_view
 # * NArray#to_gm_view
 #
-#   Create <tt>GSL::Vector::View</tt> or <tt>GSL::Matrix::View</tt> objects from NArray. 
+#   Create <tt>GSL::Vector::View</tt> or <tt>GSL::Matrix::View</tt> objects from NArray.
 #   The memory block of the NArray objects are shared with the View objects.
 #
 #   Example:
 #     >> na = NArray[0, 1, 2, 3, 4, 5]
-#     => NArray.int(6): 
+#     => NArray.int(6):
 #     [ 0, 1, 2, 3, 4, 5 ]
 #     >> b = na.to_gv_int_view
 #     => GSL::Vector::Int::View
@@ -69,11 +69,11 @@
 #     >> b[2] = -99
 #     => -99
 #     >> na
-#     => NArray.int(6): 
+#     => NArray.int(6):
 #     [ 0, 1, -99, 3, 4, 5 ]
 #
-# == {}[link:index.html"name="2] Methods which accepts NArray
-# === {}[link:index.html"name="2.1] <tt>GSL</tt> module
+# == Methods which accepts NArray
+# === <tt>GSL</tt> module
 # ---
 # * GSL::graph()
 # * GSL::log1p(x)
@@ -87,11 +87,11 @@
 # * GSL::pow_2(x), ..., GSL::pow_9(x)
 #
 #
-# === {}[link:index.html"name="2.2] <tt>GSL::Sf</tt> module
+# === <tt>Sf</tt> module
 # ---
-# * {Any}[link:files/rdoc/sf_rdoc.html]
+# * {Any}[link:rdoc/sf_rdoc.html]
 #
-# === {}[link:index.html"name="2.3] <tt>GSL::Linalg</tt> module
+# === <tt>Linalg</tt> module
 # ---
 # * GSL::Linalg::LU.decomp(na)
 # * GSL::Linalg::LU.solve(lu, b)
@@ -100,7 +100,7 @@
 # * GSL::Linalg::LU.lndet(lu)
 # * GSL::Linalg::LU.invert(lu, perm)
 # * GSL::Linalg::QR.decomp(m)
-# * GSL::Linalg::QR.solve(qr, tau, b)	
+# * GSL::Linalg::QR.solve(qr, tau, b)
 # * GSL::Linalg::QR.svx(qr, tau, bx)
 # * GSL::Linalg::SV.decomp(m)
 # * GSL::Linalg::SV.solve(u, v, s, b)
@@ -112,17 +112,17 @@
 # * GSL::Linalg::HH.svx(m, bx)
 #
 #
-# === {}[link:index.html"name="2.4] <tt>GSL::Eigen</tt> module
+# === <tt>Eigen</tt> module
 # ---
 # * GSL::Eigen::symm(na)
 # * GSL::Eigen::symmv(na)
 #
 #
-# === {}[link:index.html"name="2.5] <tt>GSL::FFT</tt> module
+# === <tt>FFT</tt> module
 # ---
-# * {Many}[link:files/rdoc/FFT_rdoc.html]
+# * {Many}[link:rdoc/fft_rdoc.html]
 #
-# === {}[link:index.html"name="2.6] <tt>GSL::Function</tt> class
+# === <tt>Function</tt> class
 # ---
 # * GSL::Function#eval
 # * GSL::Function#deriv_central(x, h)
@@ -133,15 +133,15 @@
 # * GSL::Function#diff_backward(x, h)
 #
 #
-# === {}[link:index.html"name="2.7] <tt>GSL::Ran</tt> and <tt>GSL::Cdf</tt> module
+# === <tt>Ran</tt> and <tt>Cdf</tt> module
 # ---
-# * {Many}[link:files/rdoc/randist_rdoc.html]
+# * {Many}[link:rdoc/randist_rdoc.html]
 #
-# === {}[link:index.html"name="2.8] <tt>GSL::Stats</tt> module
+# === <tt>Stats</tt> module
 # ---
-# * {Any}[link:files/rdoc/stats_rdoc.html]
+# * {Any}[link:rdoc/stats_rdoc.html]
 #
-# === {}[link:index.html"name="2.9] <tt>GSL::Interp</tt> and <tt>GSL::Spline</tt> class
+# === <tt>Interp</tt> and <tt>Spline</tt> class
 # ---
 # * GSL::Interp#init
 # * GSL::Interp#eval
@@ -149,7 +149,7 @@
 # * GSL::Spline#eval
 #
 #
-# === {}[link:index.html"name="2.10] <tt>GSL::Deriv</tt> and <tt>GSL::Diff</tt> module
+# === <tt>Deriv</tt> and <tt>Diff</tt> module
 # ---
 # * GSL::Deriv.central(f, x, h)
 # * GSL::Deriv.forward(f, x, h)
@@ -159,19 +159,19 @@
 # * GSL::Diff.backward(f, x, h)
 #
 #
-# === {}[link:index.html"name="2.11] <tt>GSL::Cheb</tt> class
+# === <tt>Cheb</tt> class
 # ---
 # * GSL::Cheb#eval(x)
 # * GSL::Cheb#eval_n(n, x)
 #
 #
-# === {}[link:index.html"name="2.12] <tt>GSL::Wavelet</tt> class
+# === <tt>Wavelet</tt> class
 # ---
-# * {Many}[link:files/rdoc/wavelet_rdoc.html]
+# * {Many}[link:rdoc/wavelet_rdoc.html]
 #
-# {prev}[link:files/rdoc/tensor_rdoc.html]
+# {prev}[link:rdoc/tensor_rdoc.html]
 #
-# {Reference index}[link:files/rdoc/ref_rdoc.html]
-# {top}[link:files/rdoc/index_rdoc.html]
+# {Reference index}[link:rdoc/ref_rdoc.html]
+# {top}[link:index.html]
 #
 #

data/rdoc/ndlinear.rdoc

@@ -1,56 +1,56 @@
 #
-# = NDLINAR: multi-linear, multi-parameter least squares fitting 
+# = NDLINAR: multi-linear, multi-parameter least squares fitting
 #
 # The multi-dimension fitting library NDLINEAR is not included in GSL,
 # but is provided as an extension library. This is available at the
-# {Patric Alken's page}[http://ucsu.colorado.edu/~alken/gsl/"target="_top].
+# {Patrick Alken's page}[http://ucsu.colorado.edu/~alken/gsl/].
 #
 # Contents:
-# 1. {Introduction}[link:files/rdoc/ndlinear_rdoc.html#1]
-# 1. {Class and methods}[link:files/rdoc/ndlinear_rdoc.html#2]
-# 1. {Examples}[link:files/rdoc/ndlinear_rdoc.html#3]
-#
-# == {}[link:index.html"name="1] Introduction
-# The NDLINEAR extension provides support for general linear least squares 
-# fitting to data which is a function of more than one variable (multi-linear or 
-# multi-dimensional least squares fitting). This model has the form where 
-# <tt>x</tt> is a vector of independent variables, a_i are the fit coefficients, 
-# and F_i are the basis functions of the fit. This GSL extension computes the 
-# design matrix X_{ij = F_j(x_i) in the special case that the basis functions 
-# separate: Here the superscript value j indicates the basis function 
-# corresponding to the independent variable x_j. The subscripts (i_1, i_2, i_3, 
+# 1. {Introduction}[link:rdoc/ndlinear_rdoc.html#label-Introduction]
+# 1. {Class and methods}[link:rdoc/ndlinear_rdoc.html#label-Class+and+Methods]
+# 1. {Examples}[link:rdoc/ndlinear_rdoc.html#label-Examples]
+#
+# == Introduction
+# The NDLINEAR extension provides support for general linear least squares
+# fitting to data which is a function of more than one variable (multi-linear or
+# multi-dimensional least squares fitting). This model has the form where
+# <tt>x</tt> is a vector of independent variables, a_i are the fit coefficients,
+# and F_i are the basis functions of the fit. This GSL extension computes the
+# design matrix X_{ij = F_j(x_i) in the special case that the basis functions
+# separate: Here the superscript value j indicates the basis function
+# corresponding to the independent variable x_j. The subscripts (i_1, i_2, i_3,
 # ...) refer to which basis function to use from the complete set. These
-# subscripts are related to the index i in a complex way, which is the main 
-# problem this extension addresses. The model then becomes where n is the 
-# dimension of the fit and N_i is the number of basis functions for the variable 
-# x_i. Computationally, it is easier to supply the individual basis functions 
-# u^{(j) than the total basis functions F_i(x). However the design matrix X is 
-# easiest to construct given F_i(x). Therefore the routines below allow the user 
-# to specify the individual basis functions u^{(j) and then automatically 
-# construct the design matrix X. 
+# subscripts are related to the index i in a complex way, which is the main
+# problem this extension addresses. The model then becomes where n is the
+# dimension of the fit and N_i is the number of basis functions for the variable
+# x_i. Computationally, it is easier to supply the individual basis functions
+# u^{(j) than the total basis functions F_i(x). However the design matrix X is
+# easiest to construct given F_i(x). Therefore the routines below allow the user
+# to specify the individual basis functions u^{(j) and then automatically
+# construct the design matrix X.
 #
 #
-# == {}[link:index.html"name="2] Class and Methods
+# == Class and Methods
 # ---
 # * GSL::MultiFit::Ndlinear.alloc(n_dim, N, u, params)
 # * GSL::MultiFit::Ndlinear::Workspace.alloc(n_dim, N, u, params)
 #
-#   Creates a workspace for solving multi-parameter, multi-dimensional linear 
-#   least squares problems. <tt>n_dim</tt> specifies the dimension of the fit 
-#   (the number of independent variables in the model). The array <tt>N</tt> of 
-#   length <tt>n_dim</tt> specifies the number of terms in each sum, so that 
+#   Creates a workspace for solving multi-parameter, multi-dimensional linear
+#   least squares problems. <tt>n_dim</tt> specifies the dimension of the fit
+#   (the number of independent variables in the model). The array <tt>N</tt> of
+#   length <tt>n_dim</tt> specifies the number of terms in each sum, so that
 #   <tt>N[i]</tt>
-#   specifies the number of terms in the sum of the i-th independent variable. 
-#   The array of <tt>Proc</tt> objects <tt>u</tt> of length <tt>n_dim</tt> specifies 
-#   the basis functions for each independent fit variable, so that <tt>u[i]</tt> 
-#   is a procedure to calculate the basis function for the i-th 
+#   specifies the number of terms in the sum of the i-th independent variable.
+#   The array of <tt>Proc</tt> objects <tt>u</tt> of length <tt>n_dim</tt> specifies
+#   the basis functions for each independent fit variable, so that <tt>u[i]</tt>
+#   is a procedure to calculate the basis function for the i-th
 #   independent variable.
-#   Each of the procedures <tt>u</tt> takes three block parameters: a point 
-#   <tt>x</tt> at which to evaluate the basis function, an array y of length 
-#   <tt>N[i]</tt> which is filled on output with the basis function values at 
-#   <tt>x</tt> for all i, and a params argument which contains parameters needed 
+#   Each of the procedures <tt>u</tt> takes three block parameters: a point
+#   <tt>x</tt> at which to evaluate the basis function, an array y of length
+#   <tt>N[i]</tt> which is filled on output with the basis function values at
+#   <tt>x</tt> for all i, and a params argument which contains parameters needed
 #   by the basis function. These parameters are supplied in the <tt>params</tt>
-#   argument to this method. 
+#   argument to this method.
 #
 #   Ex)
 #
@@ -93,18 +93,18 @@
 # * GSL::MultiFit::Ndlinear::Workspace#design(vars)
 #
 #   Construct the least squares design matrix <tt>X</tt> from the input <tt>vars</tt>
-#   and the previously specified basis functions. vars is a ndata-by-n_dim 
-#   matrix where the ith row specifies the n_dim independent variables for the 
-#   ith observation. 
+#   and the previously specified basis functions. vars is a ndata-by-n_dim
+#   matrix where the ith row specifies the n_dim independent variables for the
+#   ith observation.
 #
 # ---
 # * GSL::MultiFit::Ndlinear.est(x, c, cov, w)
 # * GSL::MultiFit::Ndlinear::Workspace#est(x, c, cov)
 #
-#   After the least squares problem is solved via <tt>GSL::MultiFit::linear</tt>, 
-#   this method can be used to evaluate the model at the data point <tt>x</tt>. 
-#   The coefficient vector <tt>c</tt> and covariance matrix <tt>cov</tt> are 
-#   outputs from <tt>GSL::MultiFit::linear</tt>. The model output value and 
+#   After the least squares problem is solved via <tt>GSL::MultiFit::linear</tt>,
+#   this method can be used to evaluate the model at the data point <tt>x</tt>.
+#   The coefficient vector <tt>c</tt> and covariance matrix <tt>cov</tt> are
+#   outputs from <tt>GSL::MultiFit::linear</tt>. The model output value and
 #   its error [<tt>y, yerr</tt>] are returned as an array.
 #
 # ---
@@ -116,12 +116,12 @@
 #   <tt>x</tt>  using the coefficient vector <tt>c</tt> and returns the model
 #   value.
 #
-# == {}[link:index.html"name="3] Examples
-# This example program generates data from the 3D isotropic harmonic oscillator 
-# wavefunction (real part) and then fits a model to the data using B-splines in 
-# the r coordinate, Legendre polynomials in theta, and sines/cosines in phi. 
-# The exact form of the solution is (neglecting the normalization constant for 
-# simplicity) The example program models psi by default. 
+# == Examples
+# This example program generates data from the 3D isotropic harmonic oscillator
+# wavefunction (real part) and then fits a model to the data using B-splines in
+# the r coordinate, Legendre polynomials in theta, and sines/cosines in phi.
+# The exact form of the solution is (neglecting the normalization constant for
+# simplicity) The example program models psi by default.
 #
 #  #!/usr/bin/env ruby
 #  require("gsl")
@@ -133,7 +133,7 @@
 #  R_MAX = 3.0
 #
 #  def psi_real_exact(k, l, m, r, theta, phi)
-#     rr = GSL::pow(r, l)*Math::exp(-r*r)*GSL::Sf::laguerre_n(k, l + 0.5, 2 * r * r)	 
+#     rr = GSL::pow(r, l)*Math::exp(-r*r)*GSL::Sf::laguerre_n(k, l + 0.5, 2 * r * r)
 #     tt = GSL::Sf::legendre_sphPlm(l, m, Math::cos(theta))
 #     pp = Math::cos(m*phi)
 #     rr*tt*pp
@@ -191,7 +191,7 @@
 #
 #    vars[i][0] = r
 #    vars[i][1] = theta
-#    vars[i][2] = phi		
+#    vars[i][2] = phi
 #
 #    data[i] = psi + dpsi
 #  end
@@ -244,7 +244,7 @@
 #  STDERR.printf("rms error over all parameter space = %e\n", eps_rms)
 #
 #
-# {Reference index}[link:files/rdoc/ref_rdoc.html]
-# {top}[link:files/rdoc/index_rdoc.html]
+# {Reference index}[link:rdoc/ref_rdoc.html]
+# {top}[link:index.html]
 #
 #