rb-gsl 1.16.0.5 → 1.16.0.6

data/rdoc/ndlinear.rdoc

@@ -1,250 +0,0 @@
-#
-# = 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
-# {Patrick Alken's page}[http://ucsu.colorado.edu/~alken/gsl/].
-#
-# Contents:
-# 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.
-#
-#
-# == 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
-#   <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
-#   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
-#   by the basis function. These parameters are supplied in the <tt>params</tt>
-#   argument to this method.
-#
-#   Ex)
-#
-#      N_DIM = 3
-#      N_SUM_R = 10
-#      N_SUM_THETA = 11
-#      N_SUM_PHI = 9
-#
-#      basis_r = Proc.new { |r, y, params|
-#        params.eval(r, y)
-#      }
-#
-#      basis_theta = Proc.new { |theta, y, params|
-#        for i in 0...N_SUM_THETA do
-#          y[i] = GSL::Sf::legendre_Pl(i, Math::cos(theta));
-#        end
-#      }
-#
-#      basis_phi = Proc.new { |phi, y, params|
-#        for i in 0...N_SUM_PHI do
-#          if i%2 == 0
-#            y[i] = Math::cos(i*0.5*phi)
-#          else
-#            y[i] = Math::sin((i+1.0)*0.5*phi)
-#          end
-#        end
-#      }
-#
-#      N = [N_SUM_R, N_SUM_THETA, N_SUM_PHI]
-#      u = [basis_r, basis_theta, basis_phi]
-#
-#      bspline = GSL::BSpline.alloc(4, N_SUM_R - 2)
-#
-#      ndlinear = GSL::MultiFit::Ndlinear.alloc(N_DIM, N, u, bspline)
-#
-# ---
-# * GSL::MultiFit::Ndlinear.design(vars, X, w)
-# * GSL::MultiFit::Ndlinear.design(vars, w)
-# * GSL::MultiFit::Ndlinear::Workspace#design(vars, X)
-# * 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.
-#
-# ---
-# * 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
-#   its error [<tt>y, yerr</tt>] are returned as an array.
-#
-# ---
-# * GSL::MultiFit::Ndlinear.calc(x, c, w)
-# * GSL::MultiFit::Ndlinear::Workspace#calc(x, c)
-#
-#   This method is similar to <tt>GSL::MultiFit::Ndlinear.est</tt>, but does
-#   not compute the model error. It computes the model value at the data point
-#   <tt>x</tt>  using the coefficient vector <tt>c</tt> and returns the model
-#   value.
-#
-# == 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")
-#
-#  N_DIM = 3
-#  N_SUM_R = 10
-#  N_SUM_THETA = 10
-#  N_SUM_PHI = 9
-#  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)
-#     tt = GSL::Sf::legendre_sphPlm(l, m, Math::cos(theta))
-#     pp = Math::cos(m*phi)
-#     rr*tt*pp
-#  end
-#
-#  basis_r = Proc.new { |r, y, params|
-#    params.eval(r, y)
-#  }
-#
-#  basis_theta = Proc.new { |theta, y, params|
-#    for i in 0...N_SUM_THETA do
-#      y[i] = GSL::Sf::legendre_Pl(i, Math::cos(theta));
-#    end
-#  }
-#
-#  basis_phi = Proc.new { |phi, y, params|
-#    for i in 0...N_SUM_PHI do
-#      if i%2 == 0
-#        y[i] = Math::cos(i*0.5*phi)
-#      else
-#        y[i] = Math::sin((i+1.0)*0.5*phi)
-#      end
-#    end
-#  }
-#
-#
-#  GSL::Rng::env_setup()
-#
-#  k = 5
-#  l = 4
-#  m = 2
-#
-#  NDATA = 3000
-#
-#  N = [N_SUM_R, N_SUM_THETA, N_SUM_PHI]
-#  u = [basis_r, basis_theta, basis_phi]
-#
-#  rng = GSL::Rng.alloc()
-#
-#  bspline = GSL::BSpline.alloc(4, N_SUM_R - 2)
-#  bspline.knots_uniform(0.0, R_MAX)
-#
-#  ndlinear = GSL::MultiFit::Ndlinear.alloc(N_DIM, N, u, bspline)
-#  multifit = GSL::MultiFit.alloc(NDATA, ndlinear.n_coeffs)
-#  vars = GSL::Matrix.alloc(NDATA, N_DIM)
-#  data = GSL::Vector.alloc(NDATA)
-#
-#
-#  for i in 0...NDATA do
-#    r = rng.uniform()*R_MAX
-#    theta = rng.uniform()*Math::PI
-#    phi = rng.uniform()*2*Math::PI
-#    psi = psi_real_exact(k, l, m, r, theta, phi)
-#    dpsi = rng.gaussian(0.05*psi)
-#
-#    vars[i][0] = r
-#    vars[i][1] = theta
-#    vars[i][2] = phi
-#
-#    data[i] = psi + dpsi
-#  end
-#
-#  X = GSL::MultiFit::Ndlinear::design(vars, ndlinear)
-#
-#  coeffs, cov, chisq, = GSL::MultiFit::linear(X, data, multifit)
-#
-#  rsq = 1.0 - chisq/data.tss
-#  STDERR.printf("chisq = %e, Rsq = %f\n", chisq, rsq)
-#
-#  eps_rms = 0.0
-#  volume = 0.0
-#  dr = 0.05;
-#  dtheta = 5.0 * Math::PI / 180.0
-#  dphi = 5.0 * Math::PI / 180.0
-#  x = GSL::Vector.alloc(N_DIM)
-#
-#  r = 0.01
-#  while r < R_MAX do
-#    theta = 0.0
-#    while theta < Math::PI do
-#      phi = 0.0
-#      while phi < 2*Math::PI do
-#        dV = r*r*Math::sin(theta)*r*dtheta*dphi
-#        x[0] = r
-#        x[1] = theta
-#        x[2] = phi
-#
-#        psi_model, err = GSL::MultiFit::Ndlinear.calc(x, coeffs, ndlinear)
-#        psi = psi_real_exact(k, l, m, r, theta, phi)
-#        err = psi_model - psi
-#        eps_rms += err * err * dV;
-#        volume += dV;
-#
-#        if phi == 0.0
-#          printf("%e %e %e %e\n", r, theta, psi, psi_model)
-#        end
-#
-#        phi += dphi
-#      end
-#      theta += dtheta
-#    end
-#    printf("\n");
-#    r += dr
-#  end
-#
-#  eps_rms /= volume
-#  eps_rms = Math::sqrt(eps_rms)
-#  STDERR.printf("rms error over all parameter space = %e\n", eps_rms)
-#
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#

data/rdoc/nonlinearfit.rdoc

@@ -1,348 +0,0 @@
-#
-# = 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.
-#
-# Contents:
-# 1. {Overview}[link:rdoc/nonlinearfit_rdoc.html#label-Overview]
-# 1. {Initializing the Solver}[link:rdoc/nonlinearfit_rdoc.html#label-Initializing+the+Solver]
-#    1. {GSL::MultiFit::FdfSolver class}[link:rdoc/nonlinearfit_rdoc.html#label-FdfSolver+class]
-# 1. {Providing the function to be minimized}[link:rdoc/nonlinearfit_rdoc.html#label-Providing+the+function+to+be+minimized]
-#    1. {GSL::MultiFit::Function_fdf class}[link:rdoc/nonlinearfit_rdoc.html#label-Function_fdf+class]
-# 1. {Iteration}[link:rdoc/nonlinearfit_rdoc.html#label-Iteration]
-# 1. {Search Stopping Parameters}[link:rdoc/nonlinearfit_rdoc.html#label-Search+Stopping+Parameters]
-# 1. {Computing the covariance matrix of best fit parameters}[link:rdoc/nonlinearfit_rdoc.html#label-Computing+the+covariance+matrix+of+best+fit+parameters]
-# 1. {Higher level interfaces}[link:rdoc/nonlinearfit_rdoc.html#label-Higher+level+interfaces]
-# 1. {Examples}[link:rdoc/nonlinearfit_rdoc.html#label-Examples]
-#    1. {Fitting to user-defined functions}[link:rdoc/nonlinearfit_rdoc.html#label-Fitting+to+user-defined+functions]
-#    1. {Fitting to built-in functions}[link:rdoc/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
-#   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>,
-#   * <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
-#   solver for 100 data points and 3 parameters,
-#
-#       solver = MultiFit::FdfSolver.alloc(MultiFit::LMDER, 100, 3)
-#
-# ---
-# * GSL::MultiFit::FdfSolver#set(f, x)
-#
-#   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.
-#
-# ---
-# * GSL::MultiFit::FdfSolver#name
-#
-#   This returns the name of the solver <tt>self</tt> as a String.
-#
-#
-# ---
-# * GSL::MultiFit::FdfSolver#x
-# * GSL::MultiFit::FdfSolver#dx
-# * GSL::MultiFit::FdfSolver#f
-# * GSL::MultiFit::FdfSolver#J
-# * GSL::MultiFit::FdfSolver#jacobian
-# * GSL::MultiFit::FdfSolver#jac
-#
-#   Access to the members (see <tt>gsl_multifit_nlin.h</tt>)
-#
-# == 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).
-#
-# ---
-# * GSL::MultiFit::Function_fdf#set_procs(f, df, p)
-# * GSL::MultiFit::Function_fdf#set_procs(f, df, fdf, p)
-#
-#   This initialize of reinitialize the function <tt>self</tt> with <tt>p</tt> parameters
-#   by two or three Proc objects <tt>f, df</tt> and <tt>fdf</tt>.
-#
-# ---
-# * GSL::MultiFit::Function_fdf#set_data(t, y)
-# * 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>.
-#
-# == 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
-#   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
-#   <tt>self</tt>, as a <tt>GSL::Vector</tt> object.
-#
-#
-# == 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.
-# * An error has occurred.
-# The handling of these conditions is under user control. The method below allows
-# the user to test the current estimate of the best-fit parameters.
-#
-# ---
-# * 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
-#   condition is achieved,
-#     |dx_i| < epsabs + epsrel |x_i|
-#   for each component of <tt>x</tt> and returns <tt>GSL::CONTINUE</tt> otherwise.
-#
-# ---
-# * 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.
-#   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
-#   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
-#   Jacobian matrix and the function values, using the formula g = J^T f.
-#
-# ---
-# * GSL::MultiFit.test_delta(dx, x, epsabs, epsrel)
-# * GSL::MultiFit.test_gradient(g, epsabs)
-# * GSL::MultiFit.gradient(jac, f, g)
-# * GSL::MultiFit.covar(jac, epsrel)
-# * GSL::MultiFit.covar(jac, epsrel, covar)
-#
-#   Singleton methods of the <tt>GSL::MultiFit</tt> module.
-#
-#
-# == 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
-#   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
-#   <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.
-#   Any columns of R which satisfy
-#     |R_{kk}| <= epsrel |R_{11}|
-#   are considered linearly-dependent and are excluded from the covariance matrix
-#   (the corresponding rows and columns of the covariance matrix are set to zero).
-#
-# == 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
-#   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
-#   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>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>y = y0 + A exp(-b x)</tt>, <tt>coef = [y0, A, b]</tt>
-#   * <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>y = y0 + A sin(f x + phi)</tt>, <tt>coef = [y0, A, f, phi]</tt>
-#   * <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>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>y = y0 + m/(1 + exp((x0-x)/r))</tt>, <tt>coef = [y0, m, x0, r]</tt>
-#   * <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>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#label-Higer+level+interface] for linear and polynomical fittings.
-#
-# == 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 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
-# 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.
-#
-#
-#   require("gsl")
-#   include GSL::MultiFit
-#
-#   # x: Vector, list of the parameters to determine
-#   # t, y, sigma: Vectors, observational data
-#   # f: Vector, function to minimize
-#   procf = Proc.new { |x, t, y, sigma, f|
-#     a = x[0]
-#     lambda = x[1]
-#     b = x[2]
-#     n = t.size
-#     for i in 0...n do
-#       yi = a*Math::exp(-lambda*t[i]) + b
-#       f[i] = (yi - y[i])/sigma[i]
-#     end
-#   }
-#
-#   # jac: Matrix, Jacobian
-#   procdf = Proc.new { |x, t, y, sigma, jac|
-#     a = x[0]
-#     lambda = x[1]
-#     n = t.size
-#     for i in 0...n do
-#       ti = t[i]
-#       si = sigma[i]
-#       ei = Math::exp(-lambda*ti)
-#       jac.set(i, 0, ei/si)
-#       jac.set(i, 1, -ti*a*ei/si)
-#       jac.set(i, 2, 1.0/si)
-#     end
-#   }
-#
-#   f = GSL::MultiFit::Function_fdf.alloc(procf, procdf, 2)
-#
-#   # Create data
-#   r = GSL::Rng.alloc()
-#   t = GSL::Vector.alloc(n)
-#   y = GSL::Vector.alloc(n)
-#   sigma = Vector.alloc(n)
-#   for i in 0...n do
-#     t[i] = i
-#     y[i] = 1.0 + 5*Math::exp(-0.1*t[i]) + r.gaussian(0.1)
-#     sigma[i] = 0.1
-#   end
-#
-#   f.set_data(t, y, sigma)
-#   x = GSL::Vector.alloc(1.0, 0.0, 0.0)    # initial guess
-#
-#   solver = GSL::FdfSolver.alloc(FdfSolver::LMSDER, n, np)
-#
-#   solver.set(f, x)
-#
-#   iter = 0
-#   solver.print_state(iter)
-#   begin
-#     iter += 1
-#     status = solver.iterate
-#     solver.print_state(iter)
-#     status = solver.test_delta(1e-4, 1e-4)
-#   end while status == GSL::CONTINUE and iter < 500
-#
-#   covar = solver.covar(0.0)
-#   position = solver.position
-#   chi2 = pow_2(solver.f.dnrm2)
-#   dof = n - np
-#   printf("A      = %.5f +/- %.5f\n", position[0], Math::sqrt(chi2/dof*covar[0][0]))
-#   printf("lambda = %.5f +/- %.5f\n", position[1], Math::sqrt(chi2/dof*covar[1][1]))
-#   printf("b      = %.5f +/- %.5f\n", position[2], Math::sqrt(chi2/dof*covar[2][2]))
-#
-#
-# === Fitting to built-in functions
-#   #!/usr/bin/env ruby
-#   require("gsl")
-#   include MultiFit
-#
-#   N = 100
-#
-#   y0 = 1.0
-#   A = 2.0
-#   x0 = 3.0
-#   w = 0.5
-#
-#   r = Rng.alloc
-#   x = Vector.linspace(0.01, 10, N)
-#   sig = 1
-#   # Lognormal function with noise
-#   y =  y0 + A*Sf::exp(-pow_2(Sf::log(x/x0)/w)) + 0.1*Ran::gaussian(r, sig, N)
-#
-#   guess = [0, 3, 2, 1]
-#   coef, err, chi2, dof = MultiFit::FdfSolver.fit(x, y, "lognormal", guess)
-#   y0 = coef[0]
-#   amp = coef[1]
-#   x0 = coef[2]
-#   w = coef[3]
-#
-#   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]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#
-#