rb-gsl 1.16.0.2 → 1.16.0.3.rc1

data/rdoc/nonlinearfit.rdoc

@@ -1,60 +1,60 @@
 #
 # = Nonlinear Least-Squares Fitting
-# This chapter describes functions for multidimensional nonlinear least-squares 
-# fitting. 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. 
+# This chapter describes functions for multidimensional nonlinear least-squares
+# fitting. 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.
 #
 # Contents:
-# 1. {Overview}[link:rdoc/nonlinearfit_rdoc.html#1]
-# 1. {Initializing the Solver}[link:rdoc/nonlinearfit_rdoc.html#2]
-#    1. {GSL::MultiFit::FdfSolver class}[link:rdoc/nonlinearfit_rdoc.html#2.1]
-# 1. {Providing the function to be minimized}[link:rdoc/nonlinearfit_rdoc.html#3]
-#    1. {GSL::MultiFit::Function_fdf class}[link:rdoc/nonlinearfit_rdoc.html#3.1]
-# 1. {Iteration}[link:rdoc/nonlinearfit_rdoc.html#4]
-# 1. {Search Stopping Parameters}[link:rdoc/nonlinearfit_rdoc.html#5]
-# 1. {Computing the covariance matrix of best fit parameters}[link:rdoc/nonlinearfit_rdoc.html#6]
-# 1. {Higher level interfaces}[link:rdoc/nonlinearfit_rdoc.html#7]
-# 1. {Examples}[link:rdoc/nonlinearfit_rdoc.html#8]
-#    1. {Fitting to user-defined functions}[link:rdoc/nonlinearfit_rdoc.html#8.1]
-#    1. {Fitting to built-in functions}[link:rdoc/nonlinearfit_rdoc.html#8.2]
-#
-# == {}[link:index.html"name="1] Overview
-# The problem of multidimensional nonlinear least-squares fitting requires the 
-# minimization of the squared residuals of n functions, f_i, in p parameters, 
-# x_i, All algorithms proceed from an initial guess using the linearization, 
-# where x is the initial point, p is the proposed step and J is the Jacobian 
-# matrix J_{ij} = d f_i / d x_j. Additional strategies are used to enlarge the 
-# region of convergence. These include requiring a decrease in the norm ||F|| 
-# on each step or using a trust region to avoid steps which fall outside the 
-# linear regime. 
-#
-# To perform a weighted least-squares fit of a nonlinear model Y(x,t) to data 
-# (t_i, y_i) with independent gaussian errors \sigma_i, use function components 
-# of the following form, Note that the model parameters are denoted by x in this 
-# chapter since the non-linear least-squares algorithms are described 
-# geometrically (i.e. finding the minimum of a surface). The independent 
-# variable of any data to be fitted is denoted by t. 
-#
-# With the definition above the Jacobian is 
-# J_{ij} =(1 / \sigma_i) d Y_i / d x_j, where Y_i = Y(x,t_i). 
-#
-# == {}[link:index.html"name="2] Initializing the Solver 
-#
-# === {}[link:index.html"name="2.1] GSL::MultiFit::FdfSolver class
+# 1. {Overview}[link:nonlinearfit_rdoc.html#label-Overview]
+# 1. {Initializing the Solver}[link:nonlinearfit_rdoc.html#label-Initializing+the+Solver]
+#    1. {GSL::MultiFit::FdfSolver class}[link:nonlinearfit_rdoc.html#label-FdfSolver+class]
+# 1. {Providing the function to be minimized}[link:nonlinearfit_rdoc.html#label-Providing+the+function+to+be+minimized]
+#    1. {GSL::MultiFit::Function_fdf class}[link:nonlinearfit_rdoc.html#label-Function_fdf+class]
+# 1. {Iteration}[link:nonlinearfit_rdoc.html#label-Iteration]
+# 1. {Search Stopping Parameters}[link:nonlinearfit_rdoc.html#label-Search+Stopping+Parameters]
+# 1. {Computing the covariance matrix of best fit parameters}[link:nonlinearfit_rdoc.html#label-Computing+the+covariance+matrix+of+best+fit+parameters]
+# 1. {Higher level interfaces}[link:nonlinearfit_rdoc.html#label-Higher+level+interfaces]
+# 1. {Examples}[link:nonlinearfit_rdoc.html#label-Examples]
+#    1. {Fitting to user-defined functions}[link:nonlinearfit_rdoc.html#label-Fitting+to+user-defined+functions]
+#    1. {Fitting to built-in functions}[link:nonlinearfit_rdoc.html#label-Fitting+to+built-in+functions]
+#
+# == Overview
+# The problem of multidimensional nonlinear least-squares fitting requires the
+# minimization of the squared residuals of n functions, f_i, in p parameters,
+# x_i, All algorithms proceed from an initial guess using the linearization,
+# where x is the initial point, p is the proposed step and J is the Jacobian
+# matrix J_{ij} = d f_i / d x_j. Additional strategies are used to enlarge the
+# region of convergence. These include requiring a decrease in the norm ||F||
+# on each step or using a trust region to avoid steps which fall outside the
+# linear regime.
+#
+# To perform a weighted least-squares fit of a nonlinear model Y(x,t) to data
+# (t_i, y_i) with independent gaussian errors \sigma_i, use function components
+# of the following form, Note that the model parameters are denoted by x in this
+# chapter since the non-linear least-squares algorithms are described
+# geometrically (i.e. finding the minimum of a surface). The independent
+# variable of any data to be fitted is denoted by t.
+#
+# With the definition above the Jacobian is
+# J_{ij} =(1 / \sigma_i) d Y_i / d x_j, where Y_i = Y(x,t_i).
+#
+# == Initializing the Solver
+#
+# === FdfSolver class
 # ---
 # * GSL::MultiFit::FdfSolver.alloc(T, n, p)
 #
-#   This creates an instance of the <tt>GSL::MultiFit::FdfSolver</tt> class of 
+#   This creates an instance of the <tt>GSL::MultiFit::FdfSolver</tt> class of
 #   type <tt>T</tt> for <tt>n</tt> observations and <tt>p</tt> parameters. The type <tt>T</tt>
-#   is given by a <tt>Fixnum</tt> constant or a <tt>String</tt>, 
+#   is given by a <tt>Fixnum</tt> constant or a <tt>String</tt>,
 #   * <tt>GSL::MultiFit::LMSDER</tt> or <tt>"lmsder"</tt>
 #   * <tt>GSL::MultiFit::LMDER</tt> or <tt>"lmder"</tt>
-#   For example, the following code creates an instance of a Levenberg-Marquardt 
+#   For example, the following code creates an instance of a Levenberg-Marquardt
 #   solver for 100 data points and 3 parameters,
 #
 #       solver = MultiFit::FdfSolver.alloc(MultiFit::LMDER, 100, 3)
@@ -62,10 +62,10 @@
 # ---
 # * GSL::MultiFit::FdfSolver#set(f, x)
 #
-#   This method initializes, or reinitializes, an existing solver <tt>self</tt> 
+#   This method initializes, or reinitializes, an existing solver <tt>self</tt>
 #   to use the function <tt>f</tt> and the initial guess <tt>x</tt>. The function <tt>f</tt>
 #   is an instance of the <tt>GSL::MultiFit::Function_fdf</tt> class (see below). The
-#   initial guess of the parameters <tt>x</tt> is given by a {GSL::Vector}[link:rdoc/vector_rdoc.html] object.
+#   initial guess of the parameters <tt>x</tt> is given by a {GSL::Vector}[link:vector_rdoc.html] object.
 #
 # ---
 # * GSL::MultiFit::FdfSolver#name
@@ -83,16 +83,16 @@
 #
 #   Access to the members (see <tt>gsl_multifit_nlin.h</tt>)
 #
-# == {}[link:index.html"name="3] Providing the function to be minimized
-# === {}[link:index.html"name="3.1] GSL::MultiFit::Function_fdf class
+# == Providing the function to be minimized
+# === Function_fdf class
 # ---
 # * GSL::MultiFit::Function_fdf.alloc()
 # * GSL::MultiFit::Function_fdf.alloc(f, df, p)
 # * GSL::MultiFit::Function_fdf.alloc(f, df, fdf, p)
 #
 #   Constructor for the <tt>Function_fdf</tt> class, to a
-#   function with <tt>p</tt> parameters, The first two or three arguments are Ruby Proc objects 
-#   to evaluate the function to minimize and its derivative (Jacobian). 
+#   function with <tt>p</tt> parameters, The first two or three arguments are Ruby Proc objects
+#   to evaluate the function to minimize and its derivative (Jacobian).
 #
 # ---
 # * GSL::MultiFit::Function_fdf#set_procs(f, df, p)
@@ -106,24 +106,24 @@
 # * GSL::MultiFit::Function_fdf#set_data(t, y, sigma)
 #
 #   This sets the data <tt>t, y, sigma</tt> of length <tt>n</tt>, to the function <tt>self</tt>.
-#       
-# == {}[link:index.html"name="4] Iteration
+#
+# == Iteration
 # ---
 # * GSL::MultiFit::FdfSolver#iterate
 #
-#   THis performs a single iteration of the solver <tt>self</tt>. If the iteration 
-#   encounters an unexpected problem then an error code will be returned. 
-#   The solver maintains a current estimate of the best-fit parameters at all 
+#   THis performs a single iteration of the solver <tt>self</tt>. If the iteration
+#   encounters an unexpected problem then an error code will be returned.
+#   The solver maintains a current estimate of the best-fit parameters at all
 #   times. This information can be accessed with the method <tt>position</tt>.
 #
 # ---
 # * GSL::MultiFit::FdfSolver#position
 #
-#   This returns the current position (i.e. best-fit parameters) of the solver 
+#   This returns the current position (i.e. best-fit parameters) of the solver
 #   <tt>self</tt>, as a <tt>GSL::Vector</tt> object.
 #
 #
-# == {}[link:index.html"name="5] Search Stopping Parameters
+# == Search Stopping Parameters
 # A minimization procedure should stop when one of the following conditions is true:
 # * A minimum has been found to within the user-specified precision.
 # * A user-specified maximum number of iterations has been reached.
@@ -134,9 +134,9 @@
 # ---
 # * GSL::MultiFit::FdfSolver#test_delta(epsabs, epsrel)
 #
-#   This method tests for the convergence of the sequence by comparing the last 
-#   step with the absolute error <tt>epsabs</tt> and relative error (<tt>epsrel</tt> 
-#   to the current position. The test returns <tt>GSL::SUCCESS</tt> if the following 
+#   This method tests for the convergence of the sequence by comparing the last
+#   step with the absolute error <tt>epsabs</tt> and relative error (<tt>epsrel</tt>
+#   to the current position. 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.
@@ -145,19 +145,19 @@
 # * GSL::MultiFit::FdfSolver#test_gradient(g, epsabs)
 # * GSL::MultiFit::FdfSolver#test_gradient(epsabs)
 #
-#   This function tests the residual gradient <tt>g</tt> against the absolute error 
-#   bound <tt>epsabs</tt>. If <tt>g</tt> is not given, it is calculated internally. 
-#   Mathematically, the gradient should be exactly zero at the minimum. 
+#   This function tests the residual gradient <tt>g</tt> against the absolute error
+#   bound <tt>epsabs</tt>. If <tt>g</tt> is not given, it is calculated internally.
+#   Mathematically, the gradient should be exactly zero at the minimum.
 #   The test returns <tt>GSL::SUCCESS</tt> if the following condition is achieved,
 #     \sum_i |g_i| < epsabs
-#   and returns <tt>GSL::CONTINUE</tt> otherwise. This criterion is suitable for 
-#   situations where the precise location of the minimum, x, is unimportant provided 
+#   and returns <tt>GSL::CONTINUE</tt> otherwise. This criterion is suitable for
+#   situations where the precise location of the minimum, x, is unimportant provided
 #   a value can be found where the gradient is small enough.
 #
 # ---
 # * GSL::MultiFit::FdfSolver#gradient
 #
-#   This method returns the gradient g of \Phi(x) = (1/2) ||F(x)||^2 from the 
+#   This method returns the gradient g of \Phi(x) = (1/2) ||F(x)||^2 from the
 #   Jacobian matrix and the function values, using the formula g = J^T f.
 #
 # ---
@@ -170,71 +170,71 @@
 #   Singleton methods of the <tt>GSL::MultiFit</tt> module.
 #
 #
-# == {}[link:index.html"name="6] Computing the covariance matrix of best fit parameters
+# == Computing the covariance matrix of best fit parameters
 # ---
 # * GSL::MultiFit.covar(J, epsrel)
 # * GSL::MultiFit.covar(J, epsrel, covar)
 #
-#   This method uses the Jacobian matrix <tt>J</tt> to compute the covariance 
+#   This method uses the Jacobian matrix <tt>J</tt> to compute the covariance
 #   matrix of the best-fit parameters. If an existing matrix <tt>covar</tt> is given,
-#   it is overwritten, and if not, this method returns a new matrix. 
-#   The parameter <tt>epsrel</tt> is used to remove linear-dependent columns when 
+#   it is overwritten, and if not, this method returns a new matrix.
+#   The parameter <tt>epsrel</tt> is used to remove linear-dependent columns when
 #   <tt>J</tt> is rank deficient.
 #
 #   The covariance matrix is given by,
 #      covar = (J^T J)^{-1}
-#   and is computed by QR decomposition of <tt>J</tt> with column-pivoting. 
+#   and is computed by QR decomposition of <tt>J</tt> with column-pivoting.
 #   Any columns of R which satisfy
 #     |R_{kk}| <= epsrel |R_{11}|
-#   are considered linearly-dependent and are excluded from the covariance matrix 
+#   are considered linearly-dependent and are excluded from the covariance matrix
 #   (the corresponding rows and columns of the covariance matrix are set to zero).
 #
-# == {}[link:index.html"name="7] Higher level interfaces
+# == Higher level interfaces
 # ---
 # * GSL::MultiFit::FdfSolver.fit(x, y, type[, guess])
 # * GSL::MultiFit::FdfSolver.fit(x, w, y, type[, guess])
 #
 #   This method uses <tt>FdfSolver</tt> with the LMSDER algorithm to fit the data
-#   <tt>[x, y]</tt> to a function of type <tt>type</tt>. The returned value is 
+#   <tt>[x, y]</tt> to a function of type <tt>type</tt>. The returned value is
 #   an array of 4 elements, <tt>[coef, err, chisq, dof]</tt>,
 #   where <tt>coef</tt> is an array of the fitting coefficients, <tt>err</tt> contains
-#   errors in estimating <tt>coef</tt>, <tt>chisq</tt> is the 
-#   chi-squared, and <tt>dof</tt> is the degree-of-freedom in the fitting 
+#   errors in estimating <tt>coef</tt>, <tt>chisq</tt> is the
+#   chi-squared, and <tt>dof</tt> is the degree-of-freedom in the fitting
 #   which equals to (data length - number of fitting coefficients). The optional
 #   argument <tt>guess</tt> is an array of initial guess of the coefficients.
 #   The fitting type <tt>type</tt> is given by a <tt>String</tt> as follows.
-#   * <tt>"gaussian"</tt>: Gaussian fit, 
+#   * <tt>"gaussian"</tt>: Gaussian fit,
 #     <tt>y = y0 + A exp(-(x-x0)^2/2/var)</tt>, <tt>coef = [y0, A, x0, var]</tt>
 #   * <tt>"gaussian_2peaks"</tt>: 2-peak Gaussian fit,
 #     <tt>y = y0 + A1 exp(-(x-x1)^2/2/var1) + A2 exp(-(x-x2)^2/2/var2)</tt>, <tt>coef = [y0, A1, x1, var1, A2, x2, var2]</tt>
-#   * <tt>"exp"</tt>: Exponential fit, 
+#   * <tt>"exp"</tt>: Exponential fit,
 #     <tt>y = y0 + A exp(-b x)</tt>, <tt>coef = [y0, A, b]</tt>
-#   * <tt>"dblexp"</tt>: Double exponential fit, 
+#   * <tt>"dblexp"</tt>: Double exponential fit,
 #     <tt>y = y0 + A1 exp(-b1 x) + A2 exp(-b2 x)</tt>, <tt>coef = [y0, A1, b1, A2, b2]</tt>
-#   * <tt>"sin"</tt>: Sinusoidal fit, 
+#   * <tt>"sin"</tt>: Sinusoidal fit,
 #     <tt>y = y0 + A sin(f x + phi)</tt>, <tt>coef = [y0, A, f, phi]</tt>
-#   * <tt>"lor"</tt>: Lorentzian peak fit, 
+#   * <tt>"lor"</tt>: Lorentzian peak fit,
 #     <tt>y = y0 + A/((x-x0)^2 + B)</tt>, <tt>coef = [y0, A, x0, B]</tt>
-#   * <tt>"hill"</tt>: Hill's equation fit, 
+#   * <tt>"hill"</tt>: Hill's equation fit,
 #     <tt>y = y0 + (m - y0)/(1 + (xhalf/x)^r)</tt>, <tt>coef = [y0, n, xhalf, r]</tt>
-#   * <tt>"sigmoid"</tt>: Sigmoid (Fermi-Dirac) function fit, 
+#   * <tt>"sigmoid"</tt>: Sigmoid (Fermi-Dirac) function fit,
 #     <tt>y = y0 + m/(1 + exp((x0-x)/r))</tt>, <tt>coef = [y0, m, x0, r]</tt>
-#   * <tt>"power"</tt>: Power-law fit, 
+#   * <tt>"power"</tt>: Power-law fit,
 #     <tt>y = y0 + A x^r</tt>, <tt>coef = [y0, A, r]</tt>
-#   * <tt>"lognormal"</tt>: Lognormal peak fit, 
+#   * <tt>"lognormal"</tt>: Lognormal peak fit,
 #     <tt>y = y0 + A exp[ -(log(x/x0)/width)^2 ]</tt>, <tt>coef = [y0, A, x0, width]</tt>
 #
-#   See {Linear fitting}[link:rdoc/fit_rdoc.html#2.3] for linear and polynomical fittings.
+#   See {Linear fitting}[link:fit_rdoc.html#label-Higer+level+interface] for linear and polynomical fittings.
 #
-# == {}[link:index.html"name="8] Examples
-# === {}[link:index.html"name="8.1] Fitting to user-defined functions
+# == Examples
+# === Fitting to user-defined functions
 #
-# The following example program fits a weighted exponential model with background 
-# to experimental data, Y = A exp(-lambda t) + b. The first part of the program sets 
-# up the functions <tt>procf</tt> and <tt>procdf</tt> to calculate the model and its Jacobian. 
+# The following example program fits a weighted exponential model with background
+# to experimental data, Y = A exp(-lambda t) + b. The first part of the program sets
+# up the functions <tt>procf</tt> and <tt>procdf</tt> to calculate the model and its Jacobian.
 # The appropriate fitting function is given by,
 #   f_i = ((A exp(-lambda t_i) + b) - y_i)/sigma_i
-# where we have chosen t_i = i. The Jacobian matrix <tt>jac</tt> is the derivative of 
+# where we have chosen t_i = i. The Jacobian matrix <tt>jac</tt> is the derivative of
 # these functions with respect to the three parameters (A, lambda, b). It is given by,
 #   J_{ij} = d f_i / d x_j
 # where x_0 = A, x_1 = lambda and x_2 = b.
@@ -310,7 +310,7 @@
 #   printf("b      = %.5f +/- %.5f\n", position[2], Math::sqrt(chi2/dof*covar[2][2]))
 #
 #
-# === {}[link:index.html"name="8.2] Fitting to built-in functions
+# === Fitting to built-in functions
 #   #!/usr/bin/env ruby
 #   require("gsl")
 #   include MultiFit
@@ -338,10 +338,10 @@
 #   graph(x, y, y0+amp*Sf::exp(-pow_2(Sf::log(x/x0)/w)))
 #
 #
-# {prev}[link:rdoc/fit_rdoc.html]
-# {next}[link:rdoc/bspline_rdoc.html]
+# {prev}[link:fit_rdoc.html]
+# {next}[link:bspline_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #

data/rdoc/ntuple.rdoc

@@ -1,28 +1,28 @@
 #
 # = N-tuples
-# This chapter describes functions for creating and manipulating ntuples, 
-# sets of values associated with events. The ntuples are stored in files. 
-# Their values can be extracted in any combination and booked in a histogram using 
+# This chapter describes functions for creating and manipulating ntuples,
+# sets of values associated with events. The ntuples are stored in files.
+# Their values can be extracted in any combination and booked in a histogram using
 # a selection function.
 #
-# The values to be stored are held in a {GSL::Vector}[link:rdoc/vector_rdoc.html] or 
-# a {GSL::Matrix}[link:rdoc/matrix_rdoc.html] object,
-# and an ntuple is created associating this object with a file. 
-# The values are then written to the file (normally inside a loop) using 
+# The values to be stored are held in a {GSL::Vector}[link:vector_rdoc.html] or
+# a {GSL::Matrix}[link:matrix_rdoc.html] object,
+# and an ntuple is created associating this object with a file.
+# The values are then written to the file (normally inside a loop) using
 # the ntuple functions described below.
 #
-# A histogram can be created from ntuple data by providing a selection function 
-# and a value function. The selection function specifies whether an event should 
-# be included in the subset to be analyzed or not. The value function computes 
+# A histogram can be created from ntuple data by providing a selection function
+# and a value function. The selection function specifies whether an event should
+# be included in the subset to be analyzed or not. The value function computes
 # the entry to be added to the histogram for each event.
 #
-# == {}[link:index.html"name="1] The <tt>GSL::Ntuple</tt> class
+# == The <tt>Ntuple</tt> class
 # ---
 # * GSL::Ntuple.create(filename, v)
 # * GSL::Ntuple.alloc(filename, v)
 #
-#   These create a new write-only ntuple file <tt>filename</tt> for ntuples. 
-# Any existing file with the same name is truncated to zero length and overwritten. 
+#   These create a new write-only ntuple file <tt>filename</tt> for ntuples.
+# Any existing file with the same name is truncated to zero length and overwritten.
 # A preexisting <tt>Vector</tt> object <tt>v</tt> for the current ntuple data must be supplied:
 # this is used to copy ntuples in and out of the file.
 #
@@ -32,7 +32,7 @@
 #   This opens an existing ntuple file <tt>filename</tt> for reading. A preexisting
 # <tt>Vector</tt> object <tt>v</tt> for the current ntuple data must be supplied.
 #
-# == {}[link:index.html"name="2] Writing and reading ntuples
+# == Writing and reading ntuples
 # ---
 # * GSL::Ntuple#write
 # * GSL::Ntuple#bookdata
@@ -44,11 +44,11 @@
 #
 #   This method reads the current row of the ntuple file.
 #
-# == {}[link:index.html"name="3] Histogramming ntuple values
-# Once an ntuple has been created its contents can be histogrammed in various ways using 
-# the function gsl_ntuple_project. Two user-defined functions must be provided, a function 
-# to select events and a function to compute scalar values. The selection function and the 
-# value function both accept the ntuple row as a first argument and other parameters as a 
+# == Histogramming ntuple values
+# Once an ntuple has been created its contents can be histogrammed in various ways using
+# the function gsl_ntuple_project. Two user-defined functions must be provided, a function
+# to select events and a function to compute scalar values. The selection function and the
+# value function both accept the ntuple row as a first argument and other parameters as a
 # second argument.
 #
 # ---
@@ -58,10 +58,10 @@
 # * GSL::Ntuple::ValueFn.alloc(proc)
 #
 #   Constructors for selection functions and value functions.
-#   The selection function shoud return a non-zero value for each ntuple row that 
+#   The selection function shoud return a non-zero value for each ntuple row that
 #   is to be included in the histogram. The value function should return the value to
 #   be added to the histogram for the ntuple row.
-#   
+#
 # ---
 # * GSL::Ntuple::SelectFn#set_params(params)
 # * GSL::Ntuple::ValueFn#set_params(params)
@@ -71,18 +71,18 @@
 # ---
 # * GSL::Ntuple.project(h, n, valfn, selfn)
 #
-#   These methods updates the histogram <tt>h</tt> from the ntuple <tt>n</tt> using 
-#   the functions <tt>valfn</tt> and <tt>selfn</tt>. For each ntuple row where the selection 
-#   function <tt>selen</tt> is non-zero the corresponding value of that row is computed 
-#   using the function value_func<tt>valfn</tt> and added to the histogram <tt>h</tt>. 
-#   Those ntuple rows where <tt>selfn</tt> returns zero are ignored. New entries are added 
-#   to the histogram, so subsequent calls can be used to accumulate further data in the 
+#   These methods updates the histogram <tt>h</tt> from the ntuple <tt>n</tt> using
+#   the functions <tt>valfn</tt> and <tt>selfn</tt>. For each ntuple row where the selection
+#   function <tt>selen</tt> is non-zero the corresponding value of that row is computed
+#   using the function value_func<tt>valfn</tt> and added to the histogram <tt>h</tt>.
+#   Those ntuple rows where <tt>selfn</tt> returns zero are ignored. New entries are added
+#   to the histogram, so subsequent calls can be used to accumulate further data in the
 #   same histogram.
 #
-# {prev}[link:rdoc/hist2d_rdoc.html]
-# {next}[link:rdoc/monte_rdoc.html]
+# {prev}[link:hist2d_rdoc.html]
+# {next}[link:monte_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #

data/rdoc/odeiv.rdoc

@@ -1,24 +1,24 @@
 #
 # = Ordinary Differential Equations
-# This chapter describes functions for solving ordinary differential equation 
-# (ODE) initial value problems. The library provides a variety of low-level 
-# methods, such as Runge-Kutta and Bulirsch-Stoer routines, and higher-level 
-# components for adaptive step-size control. The components can be combined 
-# by the user to achieve the desired solution, with full access to any 
-# intermediate steps. 
+# This chapter describes functions for solving ordinary differential equation
+# (ODE) initial value problems. The library provides a variety of low-level
+# methods, such as Runge-Kutta and Bulirsch-Stoer routines, and higher-level
+# components for adaptive step-size control. The components can be combined
+# by the user to achieve the desired solution, with full access to any
+# intermediate steps.
 #
 #
 # Contents:
-# 1. {Classes for ODE solver}[link:rdoc/odeiv_rdoc.html#1]
-# 1. {Class Descriptions}[link:rdoc/odeiv_rdoc.html#2]
-#    1. {GSL::Odeiv::System : Defining the ODE System}[link:rdoc/odeiv_rdoc.html#2.1]
-#    1. {GSL::Odeiv::Step : Stepping Algorithms}[link:rdoc/odeiv_rdoc.html#2.2]
-#    1. {GSL::Odeiv::Control : Adaptive Step-size Control}[link:rdoc/odeiv_rdoc.html#2.3]
-#    1. {GSL::Odeiv::Evolve : Evolution}[link:rdoc/odeiv_rdoc.html#2.4]
-#    1. {GSL::Odeiv::Solver : Higher level interface}[link:rdoc/odeiv_rdoc.html#2.5]
-# 1. {Examples}[link:rdoc/odeiv_rdoc.html#3]
+# 1. {Classes for ODE solver}[link:odeiv_rdoc.html#label-Classes+for+ODE+solver]
+# 1. {Class Descriptions}[link:odeiv_rdoc.html#label-Class+Descriptions]
+#    1. {GSL::Odeiv::System : Defining the ODE System}[link:odeiv_rdoc.html#label-System]
+#    1. {GSL::Odeiv::Step : Stepping Algorithms}[link:odeiv_rdoc.html#label-Step]
+#    1. {GSL::Odeiv::Control : Adaptive Step-size Control}[link:odeiv_rdoc.html#label-Control]
+#    1. {GSL::Odeiv::Evolve : Evolution}[link:odeiv_rdoc.html#label-Evolve]
+#    1. {GSL::Odeiv::Solver : Higher level interface}[link:odeiv_rdoc.html#label-Solver]
+# 1. {Examples}[link:odeiv_rdoc.html#label-Example]
 #
-# == {}[link:index.html"name="1] Classes for ODE solver
+# == Classes for ODE solver
 #
 # ---
 # * GSL::Odeiv::System
@@ -33,20 +33,20 @@
 #
 #   Another higher-level interface to ODE system classes.
 #
-# == {}[link:index.html"name="2] Class Descriptions
+# == Class Descriptions
 #
-# === {}[link:index.html"name="2.1] GSL::Odeiv::System
+# === System
 # ---
 # * GSL::Odeiv::System.alloc(func, jac, dim)
 # * GSL::Odeiv::System.alloc(func, dim)
 #
 #   Constructor. This defines a general ODE system with the dimension <tt>dim</tt>.
-#   
+#
 #       # t: variable (scalar)
 #       # y: vector
 #       # dydt: vector
 #       # params: scalar or an array
-#  
+#
 #       func = Proc.new { |t, y, dydt, params|
 #         mu = params
 #         dydt[0] = y[1]
@@ -66,12 +66,12 @@
 #         dfdy.set(1, 1, -mu*(y[0]*y[0] - 1.0))
 #         dfdt[0] = 0.0
 #         dfdt[1] = 0.0
-#       }     
+#       }
 #
 #      sys = GSL:Odeiv::System.alloc(func, jac, dim)   # for "BSIMP" algorithm
 #
-#   Note that some of the simpler solver algorithms do not make use of the 
-#   Jacobian matrix, so it is not always strictly necessary to provide it. 
+#   Note that some of the simpler solver algorithms do not make use of the
+#   Jacobian matrix, so it is not always strictly necessary to provide it.
 #   Thus the constructor is as
 #      sys = GSL:Odeiv::System.alloc(func, nil, dim)   # for others, replaced by nil
 #      sys = GSL:Odeiv::System.alloc(func, dim)        # or omit
@@ -99,14 +99,14 @@
 # * GSL::Odeiv::System#dim
 #
 #
-# === {}[link:index.html"name="2.2] GSL::Odeiv::Step
+# === Step
 # The lowest level components are the stepping functions which advance a solution from time <tt>t</tt> to <tt>t+h</tt> for a fixed step-size <tt>h</tt> and estimate the resulting local error.
 #
 # ---
 # * GSL::Odeiv::Step.alloc(T, dim)
 #
-#   Constructor for a stepping function of an algorithm type <tt>T</tt> for a system of 
-#   dimension <tt>dim</tt>. The algorithms are specified by one of the constants under the 
+#   Constructor for a stepping function of an algorithm type <tt>T</tt> for a system of
+#   dimension <tt>dim</tt>. The algorithms are specified by one of the constants under the
 #   <tt>GSL::Odeiv::Step</tt> class, as
 #
 #   1. <tt>GSL::Odeiv::Step::RK2</tt>, Embedded 2nd order Runge-Kutta with 3rd order error estimate.
@@ -121,7 +121,7 @@
 #   1. <tt>GSL::Odeiv::Step::GEAR2</tt>, M=2 implicit Gear method
 #   1. <tt>GSL::Odeiv::Step::RK2SIMP</tt> (GSL-1.6)
 #
-#   * Ex: 
+#   * Ex:
 #       step = Odeiv::Step.alloc(Odeiv::Step::RKF45, 2)
 #
 #   The algorithm types can also be given by a String, same as the C struct name,
@@ -138,14 +138,14 @@
 #   1. "<tt>gear2</tt>" or "<tt>gsl_odeiv_step_gear2</tt>"
 #   1. "<tt>rk2simp</tt>" or "<tt>gsl_odeiv_step_rk2simp</tt>" (GSL-1.6)
 #
-#   * Ex: 
+#   * Ex:
 #       step = Odeiv::Step.alloc("bsimp", 4)
 #       step2 = Odeiv::Step.alloc("gsl_odeiv_step_rkck", 3)
 #
 # ---
 # * GSL::Odeiv::Step#reset
 #
-#   This method resets the stepper. It should be used whenever the next use 
+#   This method resets the stepper. It should be used whenever the next use
 #   of s will not be a continuation of a previous step.
 #
 # ---
@@ -163,7 +163,7 @@
 # ---
 # * GSL::Odeiv::Step#order
 #
-#   Returns the order of the stepper on the previous step. 
+#   Returns the order of the stepper on the previous step.
 #   This order can vary if the stepper itself is adaptive.
 #
 # ---
@@ -171,86 +171,86 @@
 # * GSL::Odeiv::Step#apply(t, h, y, yerr, dydt_in, sys)
 # * GSL::Odeiv::Step#apply(t, h, y, yerr, sys)
 #
-#   This method applies the stepper to the system of equations defined by 
-#   <tt>dydt</tt>, using the step size <tt>h</tt> to advance the system from time 
-#   <tt>t</tt> and state <tt>y</tt> to time <tt>t+h</tt>. The new state of the system 
-#   is stored in <tt>y</tt> on output, with an estimate of the absolute error in 
-#   each component stored in <tt>yerr</tt>. If the argument <tt>dydt_in</tt> is not 
-#   <tt>nil</tt> it should be a {GSL::Vector}[link:rdoc/vector_rdoc.html] object 
-#   containing the derivatives for the system at time <tt>t</tt> on input. 
-#   This is optional as the derivatives will be computed internally if they 
-#   are not provided, but allows the reuse of existing derivative information. 
-#   On output the new derivatives of the system at time <tt>t+h</tt> will be 
+#   This method applies the stepper to the system of equations defined by
+#   <tt>dydt</tt>, using the step size <tt>h</tt> to advance the system from time
+#   <tt>t</tt> and state <tt>y</tt> to time <tt>t+h</tt>. The new state of the system
+#   is stored in <tt>y</tt> on output, with an estimate of the absolute error in
+#   each component stored in <tt>yerr</tt>. If the argument <tt>dydt_in</tt> is not
+#   <tt>nil</tt> it should be a {GSL::Vector}[link:vector_rdoc.html] object
+#   containing the derivatives for the system at time <tt>t</tt> on input.
+#   This is optional as the derivatives will be computed internally if they
+#   are not provided, but allows the reuse of existing derivative information.
+#   On output the new derivatives of the system at time <tt>t+h</tt> will be
 #   stored in <tt>dydt_out</tt> if it is not nil.
 #
-# === {}[link:index.html"name="2.3] GSL::Odeiv::Control
+# === Control
 # ---
 # * GSL::Odeiv::Control.standard_new(epsabs, epsrel, a_y, a_dydt)
 # * GSL::Odeiv::Control.alloc(epsabs, epsrel, a_y, a_dydt)
 #
-#   The standard control object is a four parameter heuristic based on 
-#   absolute and relative errors <tt>epsabs</tt> and <tt>epsrel</tt>, and 
-#   scaling factors <tt>a_y</tt> and <tt>a_dydt</tt> for the system state 
+#   The standard control object is a four parameter heuristic based on
+#   absolute and relative errors <tt>epsabs</tt> and <tt>epsrel</tt>, and
+#   scaling factors <tt>a_y</tt> and <tt>a_dydt</tt> for the system state
 #   <tt>y(t)</tt> and derivatives <tt>y'(t)</tt> respectively.
 #
 # ---
 # * GSL::Odeiv::Control.y_new(epsabs, epsrel)
 #
-#   This method creates a new control object which will keep the local error 
-#   on each step within an absolute error of <tt>epsabs</tt> and relative error 
-#   of <tt>epsrel</tt> with respect to the solution <tt>y_i(t)</tt>. 
-#   This is equivalent to the standard control object with <tt>a_y=1</tt> 
+#   This method creates a new control object which will keep the local error
+#   on each step within an absolute error of <tt>epsabs</tt> and relative error
+#   of <tt>epsrel</tt> with respect to the solution <tt>y_i(t)</tt>.
+#   This is equivalent to the standard control object with <tt>a_y=1</tt>
 #   and <tt>a_dydt=0</tt>.
 #
 # ---
 # * GSL::Odeiv::Control.yp_new(epsabs, epsrel)
 #
-#   This method creates a new control object which will keep the local 
-#   error on each step within an absolute error of <tt>epsabs</tt> and 
-#   relative error of <tt>epsrel</tt> with respect to the derivatives of the 
-#   solution <tt>y'_i(t)</tt>. 
-#   This is equivalent to the standard control object with <tt>a_y=0</tt> 
+#   This method creates a new control object which will keep the local
+#   error on each step within an absolute error of <tt>epsabs</tt> and
+#   relative error of <tt>epsrel</tt> with respect to the derivatives of the
+#   solution <tt>y'_i(t)</tt>.
+#   This is equivalent to the standard control object with <tt>a_y=0</tt>
 #   and <tt>a_dydt=1</tt>.
 #
 # ---
 # * GSL::Odeiv::Control.alloc(epsabs, epsrel, a_y, a_dydt, vscale, dim)
 #
-#   This creates a new control object which uses the same algorithm as 
-#   <tt>GSL::Odeiv::Control.standard_new</tt> but with an absolute error which 
+#   This creates a new control object which uses the same algorithm as
+#   <tt>GSL::Odeiv::Control.standard_new</tt> but with an absolute error which
 #   is scaled for each component by the <tt>GSL::Vector</tt> object <tt>vscale</tt>.
 #
 # ---
 # * GSL::Odeiv::Control#init(epsabs, epsrel, a_y, a_dydt)
 #
-#   This method initializes the controler with the parameters <tt>epsabs</tt> 
-#   (absolute error),  <tt>epsrel</tt> (relative error), <tt>a_y</tt> 
+#   This method initializes the controler with the parameters <tt>epsabs</tt>
+#   (absolute error),  <tt>epsrel</tt> (relative error), <tt>a_y</tt>
 #   (scaling factor for y) and <tt>a_dydt</tt> (scaling factor for derivatives).
 #
 # ---
 # * GSL::Odeiv::Control#name
 # * GSL::Odeiv::Control#hadjust(step, y0, yerr, dydt, h)
 #
-#   This method adjusts the step-size <tt>h</tt> using the control function 
-#   object, and the current values of <tt>y</tt>,  <tt>yerr</tt> and <tt>dydt</tt>. 
-#   The stepping function <tt>step</tt> is also needed to determine the order 
+#   This method adjusts the step-size <tt>h</tt> using the control function
+#   object, and the current values of <tt>y</tt>,  <tt>yerr</tt> and <tt>dydt</tt>.
+#   The stepping function <tt>step</tt> is also needed to determine the order
 #   of the method. On output, an array of two elements [<tt>hadj, status</tt>]
-#   is returned: If the error in the y-values  <tt>yerr</tt> is found to be 
-#   too large then the step-size <tt>h</tt> is reduced and the method returns 
-#   [<tt>hadj, status</tt>=<tt>GSL::ODEIV::HADJ_DEC</tt>]. 
-#   If the error is sufficiently small then 
-#   <tt>h</tt> may be increased and [<tt>hadj, status</tt>=<tt>GSL::ODEIV::HADJ_INC</tt>] 
-#   is returned. 
-#   The method returns [<tt>hadj, status</tt>=<tt>GSL::ODEIV::HADJ_NIL</tt>] if the step-size is 
-#   unchanged. The goal of the method is to estimate the largest step-size 
-#   which satisfies the user-specified accuracy requirements for the current 
+#   is returned: If the error in the y-values  <tt>yerr</tt> is found to be
+#   too large then the step-size <tt>h</tt> is reduced and the method returns
+#   [<tt>hadj, status</tt>=<tt>GSL::ODEIV::HADJ_DEC</tt>].
+#   If the error is sufficiently small then
+#   <tt>h</tt> may be increased and [<tt>hadj, status</tt>=<tt>GSL::ODEIV::HADJ_INC</tt>]
+#   is returned.
+#   The method returns [<tt>hadj, status</tt>=<tt>GSL::ODEIV::HADJ_NIL</tt>] if the step-size is
+#   unchanged. The goal of the method is to estimate the largest step-size
+#   which satisfies the user-specified accuracy requirements for the current
 #   point.
 #
-# === {}[link:index.html"name="2.4] GSL::Odeiv::Evolve
-# The higher level of the system is the <tt>GSL::Evolve</tt> class which combines the 
-# results of a stepper and controler to reliably advance the solution forward 
-# over an interval <tt>(t_0, t_1)</tt>. If the controler signals that the step-size 
-# should be decreased the <tt>GSL::Evolve</tt> object backs out of the current step and 
-# tries the proposed smaller step-size. This process is continued until an 
+# === Evolve
+# The higher level of the system is the <tt>GSL::Evolve</tt> class which combines the
+# results of a stepper and controler to reliably advance the solution forward
+# over an interval <tt>(t_0, t_1)</tt>. If the controler signals that the step-size
+# should be decreased the <tt>GSL::Evolve</tt> object backs out of the current step and
+# tries the proposed smaller step-size. This process is continued until an
 # acceptable step-size is found.
 #
 # ---
@@ -261,28 +261,28 @@
 # ---
 # * GSL::Odeiv::Evolve#reset
 #
-#   This method resets the GSL::Evolve object. It should be used whenever 
+#   This method resets the GSL::Evolve object. It should be used whenever
 #   the next use of e will not be a continuation of a previous step.
 #
 # ---
 # * GSL::Odeiv::Evolve#apply(evolve, control, step, sys, t, t1, h, y)
 #
-#   This method advances the system <tt>sys</tt> from time <tt>t</tt> and position 
-#   <tt>y</tt> using the stepping function <tt>step</tt>. The initial step-size is 
-#   taken as <tt>h</tt>. The maximum time <tt>t1</tt> is guaranteed not to be exceeded by 
+#   This method advances the system <tt>sys</tt> from time <tt>t</tt> and position
+#   <tt>y</tt> using the stepping function <tt>step</tt>. The initial step-size is
+#   taken as <tt>h</tt>. The maximum time <tt>t1</tt> is guaranteed not to be exceeded by
 #   the time-step. On output, an array of three elements is returned,
-#   [<tt>tnext, hnext, status</tt>], where <tt>tnext</tt> is the time advanced, 
+#   [<tt>tnext, hnext, status</tt>], where <tt>tnext</tt> is the time advanced,
 #   <tt>hnext</tt> is the step-size
 #   for the next step, and <tt>status</tt> is an error code retunred by <tt>gsl_odeiv_evolve_apply()</tt> function.
-#   On the final time-step the value of <tt>tnext</tt> will be set to 
+#   On the final time-step the value of <tt>tnext</tt> will be set to
 #   <tt>t1</tt> exactly.
 #
 # ---
 # * GSL::Odeiv::Evolve#count
 #
 #
-# === {}[link:index.html"name="2.5] GSL::Odeiv::Solver
-# This is the highest level interface to solve ODE system, 
+# === Solver
+# This is the highest level interface to solve ODE system,
 # which contains System, Step, Control, and Evolve classes.
 #
 # ---
@@ -329,10 +329,10 @@
 #
 #   This method advances the system from time <tt>t</tt> and position <tt>y</tt> (<tt>GSL::Vector</tt> object) using the stepping function. On output, the new time and position are returned as an array [<tt>tnext, hnext, status</tt>], i.e. <tt>t, y</tt> themselves are not modified by this method. The maximum time <tt>t1</tt> is guaranteed not to be exceeded by the time-step. On the final time-step the value of <tt>tnext</tt> will be set to <tt>t1</tt> exactly.
 #
-# == {}[link:index.html"name="3] Example
+# == Example
 #
 # The following program solves the second-order nonlinear Van der Pol oscillator equation,
-# as found in the GSL manual, x"(t) + \mu x'(t) (x(t)^2 - 1) + x(t) = 0, 
+# as found in the GSL manual, x"(t) + \mu x'(t) (x(t)^2 - 1) + x(t) = 0,
 #
 # This can be converted into a first order system suitable for use with the routines described in this chapter by introducing a separate variable for the velocity, y = x'(t),
 #
@@ -369,10 +369,10 @@
 #       end
 #
 #
-# {prev}[link:rdoc/siman_rdoc.html]
-# {next}[link:rdoc/interp_rdoc.html]
+# {prev}[link:siman_rdoc.html]
+# {next}[link:interp_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #