rb-gsl 1.16.0.2 → 1.16.0.3.rc1

data/rdoc/rng.rdoc

@@ -1,83 +1,83 @@
 #
 # = Random Number Generation
-# The library provides a large collection of random number generators which 
-# can be accessed through a uniform interface. Environment variables allow you 
-# to select different generators and seeds at runtime, so that you can easily 
-# switch between generators without needing to recompile your program. 
-# Each instance of a generator keeps track of its own state, allowing the 
-# generators to be used in multi-threaded programs. Additional functions are 
-# available for transforming uniform random numbers into samples from 
-# continuous or discrete probability distributions such as the Gaussian, 
-# log-normal or Poisson distributions. 
+# The library provides a large collection of random number generators which
+# can be accessed through a uniform interface. Environment variables allow you
+# to select different generators and seeds at runtime, so that you can easily
+# switch between generators without needing to recompile your program.
+# Each instance of a generator keeps track of its own state, allowing the
+# generators to be used in multi-threaded programs. Additional functions are
+# available for transforming uniform random numbers into samples from
+# continuous or discrete probability distributions such as the Gaussian,
+# log-normal or Poisson distributions.
 #
 #
 #
 # Contents:
-# 1. {General comments on random numbers}[link:rdoc/rng_rdoc.html#1]
-# 1. {The Random Number Generator Interface: GSL::Rng class}[link:rdoc/rng_rdoc.html#2]
-# 1. {Random number generator initialization}[link:rdoc/rng_rdoc.html#3]
-# 1. {Sampling from a random number generator}[link:rdoc/rng_rdoc.html#4]
-# 1. {Auxiliary random number generator functions}[link:rdoc/rng_rdoc.html#5]
-# 1. {Random number environment variables}[link:rdoc/rng_rdoc.html#6]
-#
-# == {}[link:index.html"name="1] General comments on random numbers
-# In 1988, Park and Miller wrote a paper entitled "Random number generators: 
+# 1. {General comments on random numbers}[link:rng_rdoc.html#label-General+comments+on+random+numbers]
+# 1. {The Random Number Generator Interface: GSL::Rng class}[link:rng_rdoc.html#label-The+Random+Number+Generator+Interface]
+# 1. {Random number generator initialization}[link:rng_rdoc.html#label-Random+number+generator+initialization]
+# 1. {Sampling from a random number generator}[link:rng_rdoc.html#label-Sampling+from+a+random+number+generator]
+# 1. {Auxiliary random number generator functions}[link:rng_rdoc.html#label-Auxiliary+random+number+generator+functions]
+# 1. {Random number environment variables}[link:rng_rdoc.html#label-Random+number+environment+variables]
+#
+# == General comments on random numbers
+# In 1988, Park and Miller wrote a paper entitled "Random number generators:
 # good ones are hard to find." [Commun. ACM, 31, 1192-1201]. Fortunately, some
-# excellent random number generators are available, though poor ones are still 
-# in common use. You may be happy with the system-supplied random number 
-# generator on your computer, but you should be aware that as computers get 
-# faster, requirements on random number generators increase. Nowadays, a 
-# simulation that calls a random number generator millions of times can often 
-# finish before you can make it down the hall to the coffee machine and back. 
-#
-# A very nice review of random number generators was written by Pierre L'Ecuyer, 
+# excellent random number generators are available, though poor ones are still
+# in common use. You may be happy with the system-supplied random number
+# generator on your computer, but you should be aware that as computers get
+# faster, requirements on random number generators increase. Nowadays, a
+# simulation that calls a random number generator millions of times can often
+# finish before you can make it down the hall to the coffee machine and back.
+#
+# A very nice review of random number generators was written by Pierre L'Ecuyer,
 # as Chapter 4 of the book: Handbook on Simulation, Jerry Banks, ed.
-# (Wiley, 1997). The chapter is available in postscript from L'Ecuyer's 
-# ftp site (see references). Knuth's volume on Seminumerical Algorithms 
+# (Wiley, 1997). The chapter is available in postscript from L'Ecuyer's
+# ftp site (see references). Knuth's volume on Seminumerical Algorithms
 # (originally published in 1968) devotes 170 pages to random number generators,
-# and has recently been updated in its 3rd edition (1997). It is brilliant, 
-# a classic. If you don't own it, you should stop reading right now, run to the 
-# nearest bookstore, and buy it. 
-#
-# A good random number generator will satisfy both theoretical and statistical 
-# properties. Theoretical properties are often hard to obtain (they require real 
-# math!), but one prefers a random number generator with a long period, 
-# low serial correlation, and a tendency not to "fall mainly on the planes." 
+# and has recently been updated in its 3rd edition (1997). It is brilliant,
+# a classic. If you don't own it, you should stop reading right now, run to the
+# nearest bookstore, and buy it.
+#
+# A good random number generator will satisfy both theoretical and statistical
+# properties. Theoretical properties are often hard to obtain (they require real
+# math!), but one prefers a random number generator with a long period,
+# low serial correlation, and a tendency not to "fall mainly on the planes."
 # Statistical tests are performed with numerical simulations. Generally,
-# a random number generator is used to estimate some quantity for which the 
-# theory of probability provides an exact answer. Comparison to this exact 
-# answer provides a measure of "randomness". 
-#
-# == {}[link:index.html"name="2] The Random Number Generator Interface 
-# It is important to remember that a random number generator is not a "real" 
-# function like sine or cosine. Unlike real functions, successive calls to a 
-# random number generator yield different return values. Of course that is just 
-# what you want for a random number generator, but to achieve this effect, 
-# the generator must keep track of some kind of "state" variable. Sometimes this 
-# state is just an integer (sometimes just the value of the previously generated 
-# random number), but often it is more complicated than that and may involve a 
-# whole array of numbers, possibly with some indices thrown in. To use the 
-# random number generators, you do not need to know the details of what 
-# comprises the state, and besides that varies from algorithm to algorithm. 
+# a random number generator is used to estimate some quantity for which the
+# theory of probability provides an exact answer. Comparison to this exact
+# answer provides a measure of "randomness".
+#
+# == The Random Number Generator Interface
+# It is important to remember that a random number generator is not a "real"
+# function like sine or cosine. Unlike real functions, successive calls to a
+# random number generator yield different return values. Of course that is just
+# what you want for a random number generator, but to achieve this effect,
+# the generator must keep track of some kind of "state" variable. Sometimes this
+# state is just an integer (sometimes just the value of the previously generated
+# random number), but often it is more complicated than that and may involve a
+# whole array of numbers, possibly with some indices thrown in. To use the
+# random number generators, you do not need to know the details of what
+# comprises the state, and besides that varies from algorithm to algorithm.
 #
 # The random number generator library uses <tt>GSL::Rng</tt> class for the interface.
-# == {}[link:index.html"name="3] Random number generator initialization 
+# == Random number generator initialization
 #
 # ---
 # * GSL::Rng.alloc(rng_type[, seed])
 #
-#   This method returns a GSL::Rng object of a random number generator of type 
-#   <tt>rng_type</tt> with a seed <tt>seed</tt>. These two arguments can be omitted, 
+#   This method returns a GSL::Rng object of a random number generator of type
+#   <tt>rng_type</tt> with a seed <tt>seed</tt>. These two arguments can be omitted,
 #   and the generator 'gsl_rng_mt19937' and a seed 0 are used as defaults.
-#   The GSL library provides a number of random number generator types, 
+#   The GSL library provides a number of random number generator types,
 #   and one can choose with a constant <tt>GSL::RNG_xxx</tt> or a String, as
 #
 #   * <tt>GSL::Rng::MT19937</tt> or <tt>"gsl_rng_mt19937"</tt> or <tt>"mt19937"</tt>
-#   * <tt>GSL::Rng::RANLXS0</tt>  or <tt>"gsl_rng_ranlsx0"</tt>  or <tt>"ranlxs0"</tt> 
-#   * <tt>GSL::Rng::ZUF</tt>  or <tt>"gsl_rng_zuf"</tt>  or <tt>"zuf"</tt> 
+#   * <tt>GSL::Rng::RANLXS0</tt>  or <tt>"gsl_rng_ranlsx0"</tt>  or <tt>"ranlxs0"</tt>
+#   * <tt>GSL::Rng::ZUF</tt>  or <tt>"gsl_rng_zuf"</tt>  or <tt>"zuf"</tt>
 #   * ...
 #
-#   See the {GSL reference manual}[http://www.gnu.org/software/gsl/manual/html_node/Random-number-generator-algorithms.html#Random-number-generator-algorithms"target="_top] for the complete list. 
+#   See the {GSL reference manual}[https://gnu.org/software/gsl/manual/html_node/Random-number-generator-algorithms.html#Random-number-generator-algorithms] for the complete list.
 #   The following demonstrates how to use this class,
 #
 #     require 'gsl'
@@ -90,12 +90,12 @@
 #
 #   A generator of the type <tt>gsl_rng_taus</tt> is created with seed 1,
 #   and <tt>gsl_rng_ran0</tt> with seed 2. The
-#   method <tt>get</tt> returns a random integer. 
+#   method <tt>get</tt> returns a random integer.
 #   The method <tt>uniform</tt> returns
 #   a floating number uniformly distributed in the range [0, 1).
 #
-#   If the package {rngextra}[http://www.network-theory.co.uk/download/rngextra/"target="_top] is installed, additional
-#   two generators are available, 
+#   If the package {rngextra}[http://www.network-theory.co.uk/download/rngextra/] is installed, additional
+#   two generators are available,
 #   * <tt>GSL::Rng::RNGEXTRA_RNG1</tt>, <tt>"rngextra_rng1"</tt>
 #   * <tt>GSL::Rng::RNGEXTRA_RNG2</tt>, <tt>"rngextra_rng2"</tt>
 #
@@ -120,13 +120,13 @@
 # ---
 # * GSL::Rng.types_setup()
 #
-#   Returns an array of all the available generators' names. 
+#   Returns an array of all the available generators' names.
 #
 # ---
 # * GSK::Rng.memcpy(dest, src)
 #
-#   Copies the random number generator <tt>src</tt>) into the pre-existing generator 
-#   <tt>dest</tt>, making dest into an exact copy of <tt>src</tt>. 
+#   Copies the random number generator <tt>src</tt>) into the pre-existing generator
+#   <tt>dest</tt>, making dest into an exact copy of <tt>src</tt>.
 #   The two generators must be of the same type.
 #
 # ---
@@ -134,7 +134,7 @@
 #
 #   This method initializes the random number generator with a given seed <tt>s</tt>.
 #
-# == {}[link:index.html"name="4] Sampling from a random number generator
+# == Sampling from a random number generator
 #
 # ---
 # * GSL::Rng#get
@@ -144,21 +144,21 @@
 # ---
 # * GSL::Rng#uniform
 #
-#   This method returns a double precision floating point number uniformly 
-#   distributed in the range [0,1). 
+#   This method returns a double precision floating point number uniformly
+#   distributed in the range [0,1).
 #
 # ---
 # * GSL::Rng#uniform_pos
 #
-#   This returns a positive double precision floating point number uniformly 
+#   This returns a positive double precision floating point number uniformly
 #   distributed in the range (0,1), excluding both 0.0 and 1.0.
 #
 # ---
 # * GSL::Rng#uniform_int(n)
 #
-#   This method returns a random integer from 0 to n-1 inclusive. 
+#   This method returns a random integer from 0 to n-1 inclusive.
 #
-# == {}[link:index.html"name="5] Auxiliary random number generator functions
+# == Auxiliary random number generator functions
 #
 # ---
 # * GSL::Rng#name
@@ -169,8 +169,8 @@
 # * GSL::Rng#max
 # * GSL::Rng#min
 #
-#   These method return the largest/smallest value that the method 
-#   <tt>get</tt> can return. 
+#   These method return the largest/smallest value that the method
+#   <tt>get</tt> can return.
 #
 # ---
 # * GSL::Rng#clone
@@ -178,26 +178,26 @@
 #
 #   Return a newly created generator which is an exact copy of the generator <tt>self</tt>.
 #
-# == {}[link:index.html"name="6] Random number environment variables 
-# The library allows you to choose a default generator and seed from the 
-# environment variables <tt>GSL_RNG_TYPE</tt> and <tt>GSL_RNG_SEED</tt> 
-# and the method <tt>GSL::Rng::env_setup</tt>. 
+# == Random number environment variables
+# The library allows you to choose a default generator and seed from the
+# environment variables <tt>GSL_RNG_TYPE</tt> and <tt>GSL_RNG_SEED</tt>
+# and the method <tt>GSL::Rng::env_setup</tt>.
 #
 # ---
 # * GSL::Rng.env_setup()
 #
-#   Reads the environment variables <tt>GSL_RNG_TYPE</tt> and 
-#   <tt>GSL_RNG_SEED</tt> and uses their values to set the corresponding 
+#   Reads the environment variables <tt>GSL_RNG_TYPE</tt> and
+#   <tt>GSL_RNG_SEED</tt> and uses their values to set the corresponding
 #   library variables.
 #
-#   If you don't specify a generator for <tt>GSL_RNG_TYPE</tt> 
-#   then "mt19937" is used as the default. 
-#   The initial value of the default seed is zero. 
+#   If you don't specify a generator for <tt>GSL_RNG_TYPE</tt>
+#   then "mt19937" is used as the default.
+#   The initial value of the default seed is zero.
 #
 #
-# {prev}[link:rdoc/integration_rdoc.html]
-# {next}[link:rdoc/qrng_rdoc.html]
+# {prev}[link:integration_rdoc.html]
+# {next}[link:qrng_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #

data/rdoc/roots.rdoc

@@ -1,27 +1,27 @@
 #
 # = One dimensional root-finding and the solver classes
-# One-dimensional root finding algorithms can be divided into two classes, 
-# <tt>root bracketing</tt> and <tt>root polishing</tt>. The state for bracketing solvers 
-# is held in a <tt>GSL::Root::FSolver</tt> object. The updating procedure uses only 
-# function evaluations (not derivatives). The state for root polishing solvers is 
-# held in a <tt>GSL::Root::FdfSolver</tt> object. The updates require both the function 
+# One-dimensional root finding algorithms can be divided into two classes,
+# <tt>root bracketing</tt> and <tt>root polishing</tt>. The state for bracketing solvers
+# is held in a <tt>GSL::Root::FSolver</tt> object. The updating procedure uses only
+# function evaluations (not derivatives). The state for root polishing solvers is
+# held in a <tt>GSL::Root::FdfSolver</tt> object. The updates require both the function
 # and its derivative (hence the name fdf) to be supplied by the user.
 #
 # Contents:
-# 1. {Solver classes}[link:rdoc/roots_rdoc.html#1]
-# 1. {Methods}[link:rdoc/roots_rdoc.html#2]
-#    1. {Methods to solve equations}[link:rdoc/roots_rdoc.html#2.1]
-#    1. {GSL::Function_fdf class: Providing the function to solve}[link:rdoc/roots_rdoc.html#2.2]
-#    1. {Search Stopping Parameters}[link:rdoc/roots_rdoc.html#2.3]
-# 1. {Higher-level interface}[link:rdoc/roots_rdoc.html#3]
-# 1. {Example}[link:rdoc/roots_rdoc.html#4]
+# 1. {Solver classes}[link:roots_rdoc.html#label-Solver+classes]
+# 1. {Methods}[link:roots_rdoc.html#label-Methods]
+#    1. {Methods to solve equations}[link:roots_rdoc.html#label-Methods+to+solve+equations]
+#    1. {GSL::Function_fdf class: Providing the function to solve}[link:roots_rdoc.html#label-Function_fdf+class]
+#    1. {Search Stopping Parameters}[link:roots_rdoc.html#label-Search+Stopping+Parameters]
+# 1. {Higher-level interface}[link:roots_rdoc.html#label-High-level+interface]
+# 1. {Example}[link:roots_rdoc.html#label-Example]
 #
-# == {}[link:index.html"name="1] Solver classes
+# == Solver classes
 #
 # ---
 # * GSL::Root::FSolver.alloc(T)
 #
-#   This creates a equation solver with a root bracketing algorithm of type <tt>T</tt>. 
+#   This creates a equation solver with a root bracketing algorithm of type <tt>T</tt>.
 #   The type <tt>T</tt> is given by a String or a constant,
 #   * <tt>"bisection"</tt> or <tt>GSL::Root::FSolver::BISECION</tt>
 #   * <tt>"falsepos"</tt> or <tt>GSL::Root::FSolver::FALSEPOS</tt>
@@ -37,37 +37,37 @@
 # ---
 # * GSL::Root::FdfSolver.alloc(T)
 #
-#   This creates a derivative-based solver of type <tt>T</tt>. 
+#   This creates a derivative-based solver of type <tt>T</tt>.
 #   The type <tt>T</tt> is given by a String or a constant,
 #   * <tt>"newton"</tt> or <tt>GSL::Root::FdfSolver::NEWTON</tt>
 #   * <tt>"secant"</tt> or <tt>GSL::Root::FdfSolver::SECANT</tt>
 #   * <tt>"steffenson"</tt> or <tt>GSL::Root::FdfSolver::STEFFENSON</tt>.
 #
-# == {}[link:index.html"name="2] Methods
+# == Methods
 #
 # ---
 # * GSL::Root::FSolver#set(f, xl, xu)
 #
-#   This initialize the solver <tt>self</tt> to use the function <tt>f</tt>, 
-#   and the initial search 
-#   interval <tt>xl, xu</tt>. The function to be solved <tt>f</tt> is given 
-#   an instanse of the {GSL::Function}[link:rdoc/function_rdoc.html] class.
+#   This initialize the solver <tt>self</tt> to use the function <tt>f</tt>,
+#   and the initial search
+#   interval <tt>xl, xu</tt>. The function to be solved <tt>f</tt> is given
+#   an instanse of the {GSL::Function}[link:function_rdoc.html] class.
 #
 # ---
 # * GSL::Root::FdfSolver#set(fdf, r)
 #
-#   This initializes, or reinitializes, an existing solver <tt>self</tt> 
+#   This initializes, or reinitializes, an existing solver <tt>self</tt>
 #   to use the function and derivative <tt>fdf</tt> and the initial guess <tt>r</tt>.
 #   Here <tt>fdf</tt> is a <tt>GSL::Function_fdf</tt> object (see below).
 #
 #
-# === {}[link:index.html"name="2.1] Methods to solve equations
+# === Methods to solve equations
 #
 # ---
 # * GSL::Root::FSolver#iterate
 # * GSL::Root::FdfSolver#iterate
 #
-#   This performs a single iteration of the solver. If the iteration encounters an unexpected problem then an error code will be returned ( <tt>GSL::EBADFUNC</tt> or 
+#   This performs a single iteration of the solver. If the iteration encounters an unexpected problem then an error code will be returned ( <tt>GSL::EBADFUNC</tt> or
 #   <tt>GSL::EZERODIV</tt> ).
 #
 # ---
@@ -89,9 +89,9 @@
 #
 #   Return the current bracketing interval for the solver.
 #
-# === {}[link:index.html"name="2.2] GSL::Function_fdf class: Providing the function to solve
-# The <tt>FSolver</tt> object require an instance of the 
-# {GSL::Function}[link:rdoc/function_rdoc.html] class, which is already introduced elsewhere.
+# === Function_fdf class
+# The <tt>FSolver</tt> object require an instance of the
+# {GSL::Function}[link:function_rdoc.html] class, which is already introduced elsewhere.
 # The <tt>FdfSolver</tt> which uses the root-polishing algorithm requires not only
 # the function to solve, but also
 # procedures to calculate the derivatives. This is
@@ -103,7 +103,7 @@
 # * GSL::Function_fdf.alloc(f, df, fdf)
 #
 #   Constructors. Here <tt>f, df</tt> are Ruby <tt>Proc</tt> objects which return a single value.
-#   The option <tt>fdf</tt> must return an array which contain the values of the function 
+#   The option <tt>fdf</tt> must return an array which contain the values of the function
 #   and its derivative.
 #
 # ---
@@ -112,16 +112,16 @@
 #
 #   This initializes or reinitializes the <tt>Function_fdf</tt> object <tt>self</tt> by
 #   two or three <tt>Proc</tt> objects <tt>f, df</tt> and <tt>fdf</tt>.
-#   
+#
 #   * ex: A quadratic equation a*x*x + b*x + c = 0:
 #
 #       # Returns a value of the function
-#       f = Proc.new { |x, params| 
+#       f = Proc.new { |x, params|
 #         a = params[0]; b = params[1]; c = params[2]
 #         (a*x + b)*x + c
 #       }
 #       # Calculate the derivative
-#       df = Proc.new { |x, params| 
+#       df = Proc.new { |x, params|
 #         a = params[0]; b = params[1]
 #         2*a*x + b
 #       }
@@ -140,24 +140,24 @@
 #   This sets or resets the constant parameters in the function.
 #
 #   * Ex: x*x - 5 == 0
-#       
+#
 #       function_fdf.set_params([1, 0, -5])
 #
-# === {}[link:index.html"name="2.3] Search Stopping Parameters
+# === Search Stopping Parameters
 #
 # ---
 # * GSL::Root::test_interval(xl, xu, epsrel, epsabs)
 #
-#   This function tests for the convergence of the interval 
-#   <tt>[xl, xu]</tt> with absolute error <tt>epsabs</tt> and relative error <tt>epsrel</tt>. 
+#   This function tests for the convergence of the interval
+#   <tt>[xl, xu]</tt> with absolute error <tt>epsabs</tt> and relative error <tt>epsrel</tt>.
 #   The test returns <tt>GSL::SUCCESS</tt> if the following condition is achieved,
-#     |a - b| < epsabs + epsrel min(|a|,|b|) 
-#   when the interval x = [a,b] does not include the origin. If the interval includes 
-#   the origin then min(|a|,|b|) is replaced by zero (which is the minimum value of 
-#   |x| over the interval). This ensures that the relative error is accurately 
+#     |a - b| < epsabs + epsrel min(|a|,|b|)
+#   when the interval x = [a,b] does not include the origin. If the interval includes
+#   the origin then min(|a|,|b|) is replaced by zero (which is the minimum value of
+#   |x| over the interval). This ensures that the relative error is accurately
 #   estimated for roots close to the origin.
 #
-#   This condition on the interval also implies that any estimate of the root r in 
+#   This condition on the interval also implies that any estimate of the root r in
 #   the interval satisfies the same condition with respect to the true root r0,
 #
 #     |r - r0| < epsabs + epsrel r0
@@ -167,8 +167,8 @@
 # ---
 # * GSL::Root::test_delta(x1, x0, epsrel, epsabs)
 #
-#   This function tests for the convergence of the sequence ..., <tt>x0, x1</tt> with 
-#   absolute error <tt>epsabs</tt> and relative error <tt>epsrel</tt>. 
+#   This function tests for the convergence of the sequence ..., <tt>x0, x1</tt> with
+#   absolute error <tt>epsabs</tt> and relative error <tt>epsrel</tt>.
 #   The test returns <tt>GSL::SUCCESS</tt> if the following condition is achieved,
 #     |x_1 - x_0| < epsabs + epsrel |x_1|
 #   and returns <tt>GSL::CONTINUE</tt> otherwise.
@@ -176,15 +176,15 @@
 # ---
 # * GSL::Root::test_residual(f, epsabs)
 #
-#   This function 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 
+#   This function 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,
 #     |f| < epsabs
-#   and returns <tt>GSL::CONTINUE</tt> otherwise. This criterion is suitable for 
-#   situations where the precise location of the root, x, is unimportant provided a 
+#   and returns <tt>GSL::CONTINUE</tt> otherwise. This criterion is suitable for
+#   situations where the precise location of the root, x, is unimportant provided a
 #   value can be found where the residual, |f(x)|, is small enough.
 #
-# == {}[link:index.html"name="3] High-level interface
+# == High-level interface
 # ---
 # * GSL::Root:FSolver.solve(func, [xl, xu], [epsabs = 0, epsrel = 1e-6])
 #
@@ -211,8 +211,8 @@
 #       f = Function.alloc { |x| x*x - 5 }
 #       f.fsolve([0, 5])             <----- 2.23606797749979
 #
-# == {}[link:index.html"name="4] Example
-# This example is equivalent to the one found in the GSL manual, 
+# == Example
+# This example is equivalent to the one found in the GSL manual,
 # using the Brent's algorithm to solve the equation x^2 - 5 = 0.
 #
 #   #!/usr/bin/env ruby
@@ -232,7 +232,7 @@
 #   func.set_params([1, 0, -5])
 #
 #   printf("%5s [%9s, %9s] %9s %10s %9s\n",
-#           "iter", "lower", "upper", "root", 
+#           "iter", "lower", "upper", "root",
 #           "err", "err(est)")
 #
 #   solver.set(func, 0.0, 5.0)              # initialize the solver
@@ -252,18 +252,18 @@
 #     i += 1
 #   end while status != GSL::SUCCESS
 #
-# The following is an another version, using the <tt>FdfSolver</tt> with the Newton-Raphson 
+# The following is an another version, using the <tt>FdfSolver</tt> with the Newton-Raphson
 # algorithm.
 #
 #      #!/usr/bin/env ruby
 #      require "gsl"
 #
-#      f = Proc.new { |x, params| 
+#      f = Proc.new { |x, params|
 #        a = params[0]; b = params[1]; c = params[2]
 #        (a*x + b)*x + c
 #      }
 #
-#      df = Proc.new { |x, params| 
+#      df = Proc.new { |x, params|
 #        a = params[0]; b = params[1]
 #        2.0*a*x + b
 #      }
@@ -288,7 +288,7 @@
 #        x = solver.root
 #
 #        status = Root::test_delta(x, x0, 0, 1e-3)
-#        
+#
 #        if status == GSL::SUCCESS
 #          printf("Converged:\n")
 #        end
@@ -296,10 +296,10 @@
 #        printf("%5d %10.7f %+10.7f %10.7f\n", iter, x, x - expected, x - x0)
 #      end while status != GSL::SUCCESS
 #
-# {prev}[link:rdoc/dht_rdoc.html]
-# {next}[link:rdoc/min_rdoc.html]
+# {prev}[link:dht_rdoc.html]
+# {next}[link:min_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #