rb-gsl 1.16.0.2 → 1.16.0.3.rc1

data/rdoc/hist2d.rdoc

@@ -1,7 +1,7 @@
 #
 # = GSL::Histogram2d class
 #
-# == {}[link:index.html"name="1] Class methods
+# == Class methods
 # ---
 # * GSL::Histogram2d.alloc(nx, ny)
 # * GSL::Histogram2d.alloc(xrange, yrange)
@@ -13,13 +13,13 @@
 #   1. With sizes
 #         >> h2 = GSL::Histogram2d.alloc(2, 3)  # size 6
 #         >> h2.xrange
-#         => GSL::Histogram::Range: 
+#         => GSL::Histogram::Range:
 #         [ 0.000e+00 1.000e+00 2.000e+00 ]
 #         >> h2.yrange
-#         => GSL::Histogram::Range: 
+#         => GSL::Histogram::Range:
 #         [ 0.000e+00 1.000e+00 2.000e+00 3.000e+00 ]
 #         >> h2.bin
-#         => GSL::Histogram::Bin: 
+#         => GSL::Histogram::Bin:
 #         [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 0.000e+00 ]
 #         >> h2.xrange.class.superclass
 #         => GSL::Vector::View::ReadOnly
@@ -29,22 +29,22 @@
 #   1. With ranges
 #          >> h2 = Histogram2d.alloc([3, 6, 7], [2, 3, 8])
 #          >> h2.xrange
-#          => GSL::Histogram::Range: 
+#          => GSL::Histogram::Range:
 #          [ 3.000e+00 6.000e+00 7.000e+00 ]
 #          >> h2.yrange
-#          => GSL::Histogram::Range: 
+#          => GSL::Histogram::Range:
 #          [ 2.000e+00 3.000e+00 8.000e+00 ]
 #          >> h2.bin
-#          => GSL::Histogram::Bin: 
+#          => GSL::Histogram::Bin:
 #          [ 0.000e+00 0.000e+00 0.000e+00 0.000e+00 ]
 #
 #   1. With sizes and ranges
 #          >> h2 = Histogram2d.alloc(4, [0, 4], 3, [1, 5])
 #          >> h2.xrange
-#          => GSL::Histogram::Range: 
+#          => GSL::Histogram::Range:
 #          [ 0.000e+00 1.000e+00 2.000e+00 3.000e+00 4.000e+00 ]
 #          >> h2.yrange
-#          => GSL::Histogram::Range: 
+#          => GSL::Histogram::Range:
 #          [ 1.000e+00 2.333e+00 3.667e+00 5.000e+00 ]
 #
 # ---
@@ -52,25 +52,25 @@
 # * GSL::Histogram2d.equal_bins_p(h1, h2)
 #
 #
-# == {}[link:index.html"name="2] Methods
+# == Methods
 # ---
 # * GSL::Histogram2d#set_ranges(vx, vy)
 #
-#   This sets the ranges of the existing histogram using 
-#   two {GSL::Vector}[link:rdoc/vector_rdoc.html] objects or arrays.
+#   This sets the ranges of the existing histogram using
+#   two {GSL::Vector}[link:vector_rdoc.html] objects or arrays.
 # ---
 # * GSL::Histogram2d#set_ranges_uniform(xmin, xmax, ymin, ymax)
 # * GSL::Histogram2d#set_ranges_uniform([xmin, xmax], [ymin, ymax])
 #
-#   This sets the ranges of the existing histogram <tt>self</tt> to cover 
-#   the ranges <tt>xmin</tt> to <tt>xmax</tt> and <tt>ymin</tt> to <tt>ymax</tt> uniformly. 
+#   This sets the ranges of the existing histogram <tt>self</tt> to cover
+#   the ranges <tt>xmin</tt> to <tt>xmax</tt> and <tt>ymin</tt> to <tt>ymax</tt> uniformly.
 #   The values of the histogram bins are reset to zero.
 #
 # ---
 # * GSL::Histogram2d#clone
 # * GSL::Histogram2d#duplicate
 #
-#   Returns a newly created histogram which is an exact copy of the 
+#   Returns a newly created histogram which is an exact copy of the
 #   histogram <tt>self</tt>.
 #
 # ---
@@ -78,10 +78,10 @@
 # * GSL::Histogram2d#accumulate(x, y, weight = 1)
 # * GSL::Histogram2d#fill(x, y, weight = 1)
 #
-#   These method update the histogram <tt>self</tt> by adding <tt>weight</tt> 
+#   These method update the histogram <tt>self</tt> by adding <tt>weight</tt>
 #   to the bin whose <tt>x</tt> and <tt>y</tt> ranges contain the coordinates (x,y).
-#   If (x,y) lies outside the limits of the histogram then none of the 
-#   bins are modified. 
+#   If (x,y) lies outside the limits of the histogram then none of the
+#   bins are modified.
 #
 # ---
 # * GSL::Histogram2d#increment2(x, y, weight = 1)
@@ -97,16 +97,16 @@
 # * GSL::Histogram2d#get([i, j])
 # * GSL::Histogram2d#[i, j]
 #
-#   Return the contents of the <tt>(i,j)</tt>-th bin of the histogram <tt>self</tt>. 
+#   Return the contents of the <tt>(i,j)</tt>-th bin of the histogram <tt>self</tt>.
 #
 # ---
 # * GSL::Histogram2d#get_xrange(i)
 # * GSL::Histogram2d#get_yrange(j)
 #
-#   These methods find the upper and lower range limits of the <tt>i</tt>-th 
+#   These methods find the upper and lower range limits of the <tt>i</tt>-th
 #   and <tt>j</tt>-th bins in the x and y directions of the histogram <tt>self</tt>.
 #
-#   Ex: 
+#   Ex:
 #      >> h2 = Histogram2d.alloc(2, [0, 2], 3, [1, 4])
 #      >> h2.get_xrange(1)
 #      => [1.0, 2.0]
@@ -127,7 +127,7 @@
 # * GSL::Histogram2d#nx
 # * GSL::Histogram2d#ny
 #
-#   These methodss return the maximum upper and minimum lower range limits 
+#   These methodss return the maximum upper and minimum lower range limits
 #   and the number of bins for the x and y directions of the histogram <tt>self</tt>.
 #
 # ---
@@ -138,7 +138,7 @@
 # ---
 # * GSL::Histogram2d#find(x, y)
 #
-#   Finds the indices i and j to the to the bin which covers the 
+#   Finds the indices i and j to the to the bin which covers the
 #   coordinates (<tt>x,y</tt>).
 #
 # ---
@@ -149,7 +149,7 @@
 # ---
 # * GSL::Histogram2d#max_bin
 #
-#   Returns the indices (i,j) of the bin containing the maximum value in 
+#   Returns the indices (i,j) of the bin containing the maximum value in
 #   the histogram <tt>self</tt>.
 #
 # ---
@@ -165,36 +165,36 @@
 # ---
 # * GSL::Histogram2d#xmean
 #
-#   Returns the mean of the histogrammed x variable, where the histogram 
-#   is regarded as a probability distribution. 
+#   Returns the mean of the histogrammed x variable, where the histogram
+#   is regarded as a probability distribution.
 #   Negative bin values are ignored for the purposes of this calculation.
 #
 # ---
 # * GSL::Histogram2d#xsigma
 #
-#   Returns the standard deviation of the histogrammed x variable, 
-#   where the histogram is regarded as a probability distribution. 
+#   Returns the standard deviation of the histogrammed x variable,
+#   where the histogram is regarded as a probability distribution.
 #   Negative bin values are ignored for the purposes of this calculation.
 #
 # ---
 # * GSL::Histogram2d#ymean
 #
-#   Returns the mean of the histogrammed y variable, where the histogram 
-#   is regarded as a probability distribution. Negative bin values are 
+#   Returns the mean of the histogrammed y variable, where the histogram
+#   is regarded as a probability distribution. Negative bin values are
 #   ignored for the purposes of this calculation.
 #
 # ---
 # * GSL::Histogram2d#ysigma
 #
-#   Returns the standard deviation of the histogrammed y variable, 
-#   where the histogram is regarded as a probability distribution. 
+#   Returns the standard deviation of the histogrammed y variable,
+#   where the histogram is regarded as a probability distribution.
 #   Negative bin values are ignored for the purposes of this calculation.
 #
 # ---
 # * GSL::Histogram2d#cov
 #
-#   Returns the covariance of the histogrammed x and y variables, 
-#   where the histogram is regarded as a probability distribution. 
+#   Returns the covariance of the histogrammed x and y variables,
+#   where the histogram is regarded as a probability distribution.
 #   Negative bin values are ignored for the purposes of this calculation.
 #
 # ---
@@ -222,16 +222,16 @@
 # ---
 # * GSL::Histogram2d#xproject(jstart = 0, jend = ny-1)
 #
-#   Creates a <tt>GSL::Histogram</tt> object by projecting the 2D histogram 
+#   Creates a <tt>GSL::Histogram</tt> object by projecting the 2D histogram
 #   <tt>self</tt> onto the x-axis over the y-range from <tt>jstart</tt> to <tt>jend</tt>.
 #
 # ---
 # * GSL::Histogram2d#yproject(istart = 0, iend = nx-1)
 #
-#   Creates a <tt>GSL::Histogram</tt> object by projecting the 2D histogram 
+#   Creates a <tt>GSL::Histogram</tt> object by projecting the 2D histogram
 #   <tt>self</tt> onto the y-axis over the x-range from <tt>istart</tt> to <tt>iend</tt>.
 #
-# == {}[link:index.html"name="3] GSL::Histogram2d::Pdf class
+# == Pdf class
 # ---
 # * GSL::Histogram2d::Pdf.alloc(nx, ny)
 #
@@ -246,7 +246,7 @@
 # * GSL::Histogram2d::Pdf#sample(r1, r2)
 #
 #
-# == {}[link:index.html"name="4] Example
+# == Example
 #   #!/usr/bin/env ruby
 #   require("gsl")
 #
@@ -271,9 +271,9 @@
 #   GSL::graph(hx, hy, "-T X -C -g 3")
 #
 #
-# {prev}[link:rdoc/hist_rdoc.html]
-# {next}[link:rdoc/hist3d_rdoc.html]
+# {prev}[link:hist_rdoc.html]
+# {next}[link:hist3d_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #

data/rdoc/hist3d.rdoc

@@ -1,7 +1,7 @@
 #
 # = GSL::Histogram3d class
 #
-# == {}[link:index.html"name="1] Class methods
+# == Class methods
 # ---
 # * GSL::Histogram3d.alloc(nx, ny, nz)
 # * GSL::Histogram3d.alloc(xrange, yrange, zrange)
@@ -16,7 +16,7 @@
 # * GSL::Histogram3d.equal_bins_?p(h1, h2)
 #
 #
-# == {}[link:index.html"name="2] Methods
+# == Methods
 # ---
 # * GSL::Histogram3d#set_ranges(xrange, yrange, zrange)
 # * GSL::Histogram3d#set_ranges_uniform(xmin, xmax, ymin, ymax, zmin, zmax)
@@ -89,24 +89,24 @@
 # ---
 # * GSL::Histogram3d#xyproject(kstart = 0, kend = nz-1)
 #
-#   Creates a <tt>GSL::Histogram2d</tt> object by projecting the 3D histogram 
+#   Creates a <tt>GSL::Histogram2d</tt> object by projecting the 3D histogram
 #   <tt>self</tt> onto the xy-plane over the z-range from <tt>kstart</tt> to <tt>kend</tt>.
 #
 # ---
 # * GSL::Histogram3d#xzproject(jstart = 0, jend = ny-1)
 #
-#   Creates a <tt>GSL::Histogram2d</tt> object by projecting the 3D histogram 
+#   Creates a <tt>GSL::Histogram2d</tt> object by projecting the 3D histogram
 #   <tt>self</tt> onto the xz-plane over the y-range from <tt>jstart</tt> to <tt>jend</tt>.
 #
 # ---
 # * GSL::Histogram3d#yzproject(istart = 0, iend = nx-1)
 #
-#   Creates a <tt>GSL::Histogram2d</tt> object by projecting the 3D histogram 
+#   Creates a <tt>GSL::Histogram2d</tt> object by projecting the 3D histogram
 #   <tt>self</tt> onto the yz-plane over the x-range from <tt>istart</tt> to <tt>iend</tt>.
 #
-# {prev}[link:rdoc/hist2d_rdoc.html]
-# {next}[link:rdoc/ntuple_rdoc.html]
+# {prev}[link:hist2d_rdoc.html]
+# {next}[link:ntuple_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #

data/rdoc/index.rdoc

@@ -1,13 +1,13 @@
 #
-# = {Ruby/GSL}[link:doc/rdoc/index_rdoc.html"target="_parent]
+# = {Ruby/GSL}[link:index.html]
 #
 # Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License.
 #
-# == {}[link:index.html"name="1] Description
-# {Ruby/GSL}[http://rubyforge.org/projects/rb-gsl/"target="_top] is a ruby interface to the {GNU Scientific Library}[http://www.gnu.org/software/gsl/"target="_top] (GSL), for numerical computing with {Ruby}[http://www.ruby-lang.org/en/"target="_top]. 
+# == Description
+# {Ruby/GSL}[https://blackwinter.github.com/rb-gsl] is a ruby interface to the {GNU Scientific Library}[https://gnu.org/software/gsl/] (GSL), for numerical computing with {Ruby}[http://www.ruby-lang.org/en/].
 #
-# == {}[link:index.html"name="3] Installation
-# === {}[link:index.html"name="3.1] Using the gem command
+# == Installation
+# === Using the gem command
 # Ruby/GSL may now be installed as a Ruby Gem by simply running
 #
 #   gem install rb-gsl
@@ -16,38 +16,35 @@
 # can be installed.
 #
 # * It is recommended to install the
-#   {GNU plotutils}[http://www.gnu.org/software/plotutils/plotutils.html"target="_top]
+#   {GNU plotutils}[https://gnu.org/software/plotutils/plotutils.html]
 #   package.  Some of the example scripts in the 'examples/' directory use the
 #   <tt>graph</tt> utility included in the package to plot the results.
 #   Windows-cygwin binaries of <tt>GNU plotutils</tt> and related packages are
-#   available from {here}[http://rustam.uwp.edu/support"target="_top].
+#   available from {here}[http://gnuwin32.sourceforge.net/packages/plotutils.htm].
 #
-# == {}[link:index.html"name="4] Screenshot
+# == Reference
 #
-# Ruby/GSL can be seen in action in these {screenshots}[link:doc/rdoc/screenshot_rdoc.html].
-#
-# == {}[link:index.html"name="5] Reference
-#
-# The {Ruby/GSL reference manual}[link:doc/rdoc/ref_rdoc.html] follows and borrows
+# The {Ruby/GSL reference manual}[link:ref_rdoc.html] follows and borrows
 # large parts of the GSL reference manual.
 #
-# == {}[link:index.html"name="6] Examples
+# == Examples
 # See scripts in <tt>examples/</tt> and <tt>tests/</tt> directories.
 #
-# == {}[link:index.html"name="7] Related Projects
-# * {ruby-gsl:}[http://ruby-gsl.sourceforge.net/"target="_top]
-#   Another Ruby biding, developed by Arno Erpenbeck.
+# == Related Projects
+# * {ruby-gsl:}[http://ruby-gsl.sourceforge.net/]
+#   Another Ruby binding, developed by Arno Erpenbeck.
 #
-# == {}[link:index.html"name="8] Licence
+# == Licence
 # Ruby/GSL is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License.
 # This library is distributed in the hope that it will be useful, but
 # WITHOUT ANY WARRANTY.
 #
-# == {}[link:index.html"name="9] Bug Report
+# == Bug Report
 # If you encounter bugs in Ruby/GSL, please e-mail to me, or
-# submit reports from {RubyForge page}[http://rubyforge.org/projects/rb-gsl/"target="_top].
+# submit reports on {GitHub}[https://github.com/blackwinter/rb-gsl/issues].
 #
-# == {}[link:index.html"name="10] Author
+# == Authors
 # Yoshiki Tsunesada:: July, 2004
 # David MacMahon:: November, 2010
+# Jens Wille:: November, 2013

data/rdoc/integration.rdoc

@@ -1,46 +1,46 @@
 #
 # = Numerical Integration
 # Contents:
-# 1. {Introduction}[link:rdoc/integration_rdoc.html#1]
-# 1. {QNG non-adaptive Gauss-Kronrod integration}[link:rdoc/integration_rdoc.html#2]
-# 1. {QAG adaptive integration}[link:rdoc/integration_rdoc.html#3]
-#    1. {GSL::Integration::Workspace class}[link:rdoc/integration_rdoc.html#3.1]
-#    1. {Methods}[link:rdoc/integration_rdoc.html#3.2]
-# 1. {QAGS adaptive integration with singularities}[link:rdoc/integration_rdoc.html#4]
-# 1. {QAGP adaptive integration with known singular points}[link:rdoc/integration_rdoc.html#5]
-# 1. {QAGI adaptive integration on infinite intervals}[link:rdoc/integration_rdoc.html#6]
-# 1. {QAWC adaptive integration for Cauchy principal values}[link:rdoc/integration_rdoc.html#7]
-# 1. {QAWS adaptive integration for singular functions}[link:rdoc/integration_rdoc.html#8]
-# 1. {QAWO adaptive integration for oscillatory functions}[link:rdoc/integration_rdoc.html#9]
-# 1. {QAWF adaptive integration for Fourier integrals}[link:rdoc/integration_rdoc.html#10]
-#
-# == {}[link:index.html"name="1] Introduction
-# This section describes how to compute numerical integration of a function 
-# in one dimension. In Ruby/GSL, all the GSL routines for numerical integration 
-# is provided as methods of {GSL::Function}[link:rdoc/function_rdoc.html] objects.
-# For example, a <tt>GSL::Function</tt> object which represents the sine function 
+# 1. {Introduction}[link:integration_rdoc.html#label-Introduction]
+# 1. {QNG non-adaptive Gauss-Kronrod integration}[link:integration_rdoc.html#label-QNG+non-adaptive+Gauss-Kronrod+integration]
+# 1. {QAG adaptive integration}[link:integration_rdoc.html#label-QAG+adaptive+integration]
+#    1. {GSL::Integration::Workspace class}[link:integration_rdoc.html#label-Workspace+class]
+#    1. {Methods}[link:integration_rdoc.html#label-Methods]
+# 1. {QAGS adaptive integration with singularities}[link:integration_rdoc.html#label-QAGS+adaptive+integration+with+singularities]
+# 1. {QAGP adaptive integration with known singular points}[link:integration_rdoc.html#label-QAGP+adaptive+integration+with+known+singular+points]
+# 1. {QAGI adaptive integration on infinite intervals}[link:integration_rdoc.html#label-QAGI+adaptive+integration+on+infinite+intervals]
+# 1. {QAWC adaptive integration for Cauchy principal values}[link:integration_rdoc.html#label-QAWC+adaptive+integration+for+Cauchy+principal+values]
+# 1. {QAWS adaptive integration for singular functions}[link:integration_rdoc.html#label-QAWS+adaptive+integration+for+singular+functions]
+# 1. {QAWO adaptive integration for oscillatory functions}[link:integration_rdoc.html#label-QAWO+adaptive+integration+for+oscillatory+functions]
+# 1. {QAWF adaptive integration for Fourier integrals}[link:integration_rdoc.html#label-QAWF+adaptive+integration+for+Fourier+integrals]
+#
+# == Introduction
+# This section describes how to compute numerical integration of a function
+# in one dimension. In Ruby/GSL, all the GSL routines for numerical integration
+# is provided as methods of {GSL::Function}[link:function_rdoc.html] objects.
+# For example, a <tt>GSL::Function</tt> object which represents the sine function
 # <tt>sin(x)</tt> can be expressed as
 #   f = GSL::Function.alloc { |x| sin(x) }
-# To compute numerical integration of <tt>sin(x)</tt> over the range <tt>(a, b)</tt>, 
+# To compute numerical integration of <tt>sin(x)</tt> over the range <tt>(a, b)</tt>,
 # one can use the methods <tt>integrate_xxx</tt> or simply <tt>xxx</tt>, as
 # * <tt>f.integrate_xxx([a, b])</tt>, or <tt>f.xxx([a, b])</tt>
 # * <tt>f.integrate_xxx(a, b)</tt>, or <tt>f.xxx(a, b)</tt>
 #
-# == {}[link:index.html"name="2] QNG non-adaptive Gauss-Kronrod integration
+# == QNG non-adaptive Gauss-Kronrod integration
 # ---
 # * GSL::Function#integration_qng([a, b], [epsabs = 0.0, epsrel = 1e-10])
 # * GSL::Function#qng(...)
 # * GSL::Integration::qng(...)
 #
-#   These methods apply the Gauss-Kronrod integration rules in succession until 
-#   an estimate of the integral of the reciever function (a <tt>GSL::Function</tt> 
-#   object) over <tt>(a,b)</tt> is achieved within the desired absolute and relative 
+#   These methods apply the Gauss-Kronrod integration rules in succession until
+#   an estimate of the integral of the reciever function (a <tt>GSL::Function</tt>
+#   object) over <tt>(a,b)</tt> is achieved within the desired absolute and relative
 #   error limits, <tt>epsabs</tt> and <tt>epsrel</tt> (these are optional, the default
 #   values are 0,0 and 1e-10 respectively). These methods return an array of
-#   four elements <tt>[result, err, neval, status]</tt>, those are the final 
-#   approximation 
-#   of the integration, an estimate of the absolute error, the number of function 
-#   evaluation, and the status which is returned by the GSL 
+#   four elements <tt>[result, err, neval, status]</tt>, those are the final
+#   approximation
+#   of the integration, an estimate of the absolute error, the number of function
+#   evaluation, and the status which is returned by the GSL
 #   <tt>integration_qng()</tt> function.
 #
 #   * Ex: Integrate sin(x) over <tt>x = 0 -- 2</tt> with accuracies <tt>epsabs = 0, epsrel = 1.0e-7</tt>.
@@ -53,20 +53,20 @@
 #
 #   For all the methods described in this section, the arguments <tt>[epsabs, epsrel]</tt> are optional, and the default values are <tt>[epsabs = 0.0, epsrel = 1e-10]</tt>.
 #
-# == {}[link:index.html"name="3] QAG adaptive integration
-# The QAG algorithm is a simple adaptive integration procedure. 
-# The integration region is divided into subintervals, and on each iteration 
-# the subinterval with the largest estimated error is bisected. 
+# == QAG adaptive integration
+# The QAG algorithm is a simple adaptive integration procedure.
+# The integration region is divided into subintervals, and on each iteration
+# the subinterval with the largest estimated error is bisected.
 # This reduces the overall error rapidly, as the subintervals become concentrated
-# around local difficulties in the integrand. These subintervals are managed by 
-# a GSL::Integration::Workspace object, which handles the memory for the 
+# around local difficulties in the integrand. These subintervals are managed by
+# a GSL::Integration::Workspace object, which handles the memory for the
 # subinterval ranges, results and error estimates.
 #
-# === {}[link:index.html"name="3.1] GSL::Integration::Workspace class
+# === Workspace class
 # ---
 # * GSL::Integration::Workspace.alloc(n = 1000)
 #
-#   This creates a workspace sufficient to hold n double precision intervals, 
+#   This creates a workspace sufficient to hold n double precision intervals,
 #   their integration results and error estimates.
 #
 # ---
@@ -74,11 +74,11 @@
 # * GSL::Integration::Workspace#size
 #
 #
-# ==== {}[link:index.html"name="3.1.1] Algorithms which require the workspace
+# ==== Algorithms which require the workspace
 # The algorithms described below require <tt>gsl_integration_workspace</tt> struct
-# in C. In Ruby/GSL, the corresponding methods require 
+# in C. In Ruby/GSL, the corresponding methods require
 # a <tt>GSL::Integration::Workspace</tt> object in their arguments. But it is also
-# possible to use these methods without workspace arguments: if it 
+# possible to use these methods without workspace arguments: if it
 # is not given, a workspace is created/destroyed internally. Thus
 # method calls are as
 #
@@ -89,10 +89,10 @@
 #           w = GSL::Integration::Workspace.alloc(limit)
 #           p f.qag([a, b], w)
 #
-# Explicit uses of a <tt>Workspace</tt> object reduce C function calls for memory 
-# allocations of workspace objects. 
+# Explicit uses of a <tt>Workspace</tt> object reduce C function calls for memory
+# allocations of workspace objects.
 #
-# === {}[link:index.html"name="3.2] Methods
+# === Methods
 # ---
 # * GSL::Function#integration_qag([a, b], key = GSL::Integration::GAUSS61)
 # * GSL::Function#integration_qag([a, b], key, w)
@@ -102,15 +102,15 @@
 # * GSL::Function#qag(...)
 # * GSL::Integration::qag(...)
 #
-#   These methods apply an integration rule adaptively until an estimate of the 
-#   integral of the reciever function over <tt>(a,b)</tt> is achieved within the 
+#   These methods apply an integration rule adaptively until an estimate of the
+#   integral of the reciever function over <tt>(a,b)</tt> is achieved within the
 #   desired absolute and relative error limits, <tt>epsabs</tt> and <tt>epsrel</tt>.
 #   One can give a <tt>GSL::Integration::Workspace</tt> object <tt>w</tt> with the
 #   last argument (option: if not given, the workspace is internally allocated and
-#   freed). The method returns an array with four elements 
-#   <tt>[result, err, neval, status]</tt>. 
-#   The integration rule is determined by the value of key, which should be 
-#   chosen from the following symbolic names, 
+#   freed). The method returns an array with four elements
+#   <tt>[result, err, neval, status]</tt>.
+#   The integration rule is determined by the value of key, which should be
+#   chosen from the following symbolic names,
 #
 #      GSL::Integration::GAUSS15  (key = 1)
 #      GSL::Integration::GAUSS21  (key = 2)
@@ -119,18 +119,18 @@
 #      GSL::Integration::GAUSS51  (key = 5)
 #      GSL::Integration::GAUSS61  (key = 6)
 #
-#   corresponding to the 15, 21, 31, 41, 51 and 61 point Gauss-Kronrod rules. The 
-#   higher-order rules give better accuracy for smooth functions, 
-#   while lower-order rules save time when the function contains local 
-#   difficulties, such as discontinuities. 
-#
-# == {}[link:index.html"name="4] QAGS adaptive integration with singularities
-# The presence of an integrable singularity in the integration region causes 
-# an adaptive routine to concentrate new subintervals around the singularity. 
-# As the subintervals decrease in size the successive approximations to the 
-# integral converge in a limiting fashion. This approach to the limit can be 
-# accelerated using an extrapolation procedure. 
-# The QAGS algorithm combines adaptive bisection with the Wynn epsilon-algorithm 
+#   corresponding to the 15, 21, 31, 41, 51 and 61 point Gauss-Kronrod rules. The
+#   higher-order rules give better accuracy for smooth functions,
+#   while lower-order rules save time when the function contains local
+#   difficulties, such as discontinuities.
+#
+# == QAGS adaptive integration with singularities
+# The presence of an integrable singularity in the integration region causes
+# an adaptive routine to concentrate new subintervals around the singularity.
+# As the subintervals decrease in size the successive approximations to the
+# integral converge in a limiting fashion. This approach to the limit can be
+# accelerated using an extrapolation procedure.
+# The QAGS algorithm combines adaptive bisection with the Wynn epsilon-algorithm
 # to speed up the integration of many types of integrable singularities.
 #
 # ---
@@ -140,12 +140,12 @@
 # * GSL::Function#qags(...)
 # * GSL::Integration::qags(...)
 #
-#   These methods apply the Gauss-Kronrod 21-point integration rule 
-#   adaptively until an estimate of the integral over <tt>(a,b)</tt> is 
-#   achieved within the desired absolute and relative error limits, 
-#   <tt>epsabs</tt> and <tt>epsrel</tt>. The results are extrapolated using the 
-#   epsilon-algorithm, which accelerates the convergence of the integral 
-#   in the presence of discontinuities and integrable singularities. 
+#   These methods apply the Gauss-Kronrod 21-point integration rule
+#   adaptively until an estimate of the integral over <tt>(a,b)</tt> is
+#   achieved within the desired absolute and relative error limits,
+#   <tt>epsabs</tt> and <tt>epsrel</tt>. The results are extrapolated using the
+#   epsilon-algorithm, which accelerates the convergence of the integral
+#   in the presence of discontinuities and integrable singularities.
 #   The maximum number of subintervals is given by <tt>limit</tt>.
 #
 #   * ex:
@@ -155,22 +155,22 @@
 #       }
 #
 #       # create the function, with the parameter alpha = 1.0
-#       f = GSL::Function.alloc(proc, 1.0) 
+#       f = GSL::Function.alloc(proc, 1.0)
 #
 #       p f.integration_qags(0, 1)
 #
-# == {}[link:index.html"name="5] QAGP adaptive integration with known singular points
+# == QAGP adaptive integration with known singular points
 # ---
 # * GSL::Function#integration_qagp(pts, [epsabs = 0.0, epsrel = 1e-10], limit = 1000, w)
 # * GSL::Function#qagp(...)
 # * GSL::Integration::qagp(...)
 #
-#   These methods apply the adaptive integration algorithm QAGS taking 
-#   account of the user-supplied locations of singular points. The array 
-#   <tt>pts</tt> (a Ruby array or a GSL::Vector object) should contain the 
+#   These methods apply the adaptive integration algorithm QAGS taking
+#   account of the user-supplied locations of singular points. The array
+#   <tt>pts</tt> (a Ruby array or a GSL::Vector object) should contain the
 #   endpoints of the integration ranges defined by the integration region a
-#   nd locations of the singularities. For example, to integrate over the 
-#   region <tt>(a,b)</tt> with break-points at x_1, x_2, x_3 
+#   nd locations of the singularities. For example, to integrate over the
+#   region <tt>(a,b)</tt> with break-points at x_1, x_2, x_3
 #   (where a < x_1 < x_2 < x_3 < b) the following <tt>pts</tt> array should be used
 #
 #         pts[0] = a
@@ -191,18 +191,18 @@
 #      p f454.qagp(pts, 0.0, 1e-3)  # <---- [52.7408061167272, 0.000175570384826074, 20, 0]
 #                                   # Expect: 61 log(2) + (77/4) log(7) - 27 = 52.7408061167272
 #
-# == {}[link:index.html"name="6] QAGI adaptive integration on infinite intervals
+# == QAGI adaptive integration on infinite intervals
 # ---
 # * GSL::Function#integration_qagi([epsabs = 0.0, epsrel = 1e-10], limit = 1000, w)
 # * GSL::Function#qagi(...)
 # * GSL::Integration::qagi(...)
 #
-#   These methods compute the integral of the function over the infinite 
+#   These methods compute the integral of the function over the infinite
 #   interval (-infty,+infty). The integral is mapped onto the interval
-#   (0,1] using the transformation x = (1-t)/t. It is then integrated using 
-#   the QAGS algorithm. The normal 21-point Gauss-Kronrod rule of QAGS is 
-#   replaced by a 15-point rule, because the transformation can generate an 
-#   integrable singularity at the origin. In this case a lower-order rule is 
+#   (0,1] using the transformation x = (1-t)/t. It is then integrated using
+#   the QAGS algorithm. The normal 21-point Gauss-Kronrod rule of QAGS is
+#   replaced by a 15-point rule, because the transformation can generate an
+#   integrable singularity at the origin. In this case a lower-order rule is
 #   more efficient.
 #
 #   * ex
@@ -220,9 +220,9 @@
 # * GSL::Function#qagiu(...)
 # * GSL::Integration::qagiu(...)
 #
-#   These methods compute the integral of the function over the 
+#   These methods compute the integral of the function over the
 #   semi-infinite interval (a,+infty).
-#   
+#
 # ---
 # * GSL::Function#integration_qagil(b, epsabs = 0.0, epsrel = 1e-10, limit = 1000)
 # * GSL::Function#integration_qagil(b, epsabs = 0.0, epsrel = 1e-10, w)
@@ -230,22 +230,22 @@
 # * GSL::Function#qagil(...)
 # * GSL::Integration::qagil(...)
 #
-#   These methods compute the integral of the function over the 
+#   These methods compute the integral of the function over the
 #   semi-infinite interval (-infty,b).
 #
-# == {}[link:index.html"name="7] QAWC adaptive integration for Cauchy principal values
+# == QAWC adaptive integration for Cauchy principal values
 # ---
 # * GSL::Function#integration_qawc([a, b], c, [epsabs = 0.0, epsrel = 1e-10], limit. 1000)
 # * GSL::Function#qawc(...)
 # * GSL::Function#qawc(...)
 #
-#   These methods compute the Cauchy principal value of the integral over 
-#   <tt>(a,b)</tt>, with a singularity at <tt>c</tt>. The adaptive bisection algorithm 
-#   of QAG is used, with modifications to ensure that subdivisions do not occur 
-#   at the singular point <tt>x = c</tt>. When a subinterval contains the point 
-#   <tt>x = c</tt> or is close to it then a special 25-point modified 
-#   Clenshaw-Curtis rule is used to control the singularity. Further away from 
-#   the singularity the algorithm uses an ordinary 15-point Gauss-Kronrod 
+#   These methods compute the Cauchy principal value of the integral over
+#   <tt>(a,b)</tt>, with a singularity at <tt>c</tt>. The adaptive bisection algorithm
+#   of QAG is used, with modifications to ensure that subdivisions do not occur
+#   at the singular point <tt>x = c</tt>. When a subinterval contains the point
+#   <tt>x = c</tt> or is close to it then a special 25-point modified
+#   Clenshaw-Curtis rule is used to control the singularity. Further away from
+#   the singularity the algorithm uses an ordinary 15-point Gauss-Kronrod
 #   integration rule.
 #
 #   * ex:
@@ -254,10 +254,10 @@
 #
 #        p f459.qawc([-1.0, 5.0], 0, [0.0, 1e-3]) # Expect: log(125/631)/18
 #
-# == {}[link:index.html"name="8] QAWS adaptive integration for singular functions
-# The QAWS algorithm is designed for integrands with algebraic-logarithmic 
-# singularities at the end-points of an integration region. 
-# In order to work efficiently the algorithm requires a precomputed 
+# == QAWS adaptive integration for singular functions
+# The QAWS algorithm is designed for integrands with algebraic-logarithmic
+# singularities at the end-points of an integration region.
+# In order to work efficiently the algorithm requires a precomputed
 # table of Chebyshev moments.
 #
 # ---
@@ -266,8 +266,8 @@
 # * GSL::Function#qaws(...)
 # * GSL::Integration::qaws(...)
 #
-#   These methods compute the integral of the function over the interval 
-#   <tt>(a,b)</tt> with the singular weight function 
+#   These methods compute the integral of the function over the interval
+#   <tt>(a,b)</tt> with the singular weight function
 #      (x-a)^alpha (b-x)^beta log^mu (x-a) log^nu (b-x)
 #   The parameters <tt>[alpha, beta, mu, nu]</tt> is given by a Ruby array
 #   <tt>table</tt>, or by a <tt>GSL::Integration::QAWS_Table</tt> object.
@@ -292,9 +292,9 @@
 #        table = Integration::QAWS_Table.alloc(0.0, 0.0, 1, 0)
 #        p f458.qaws([0.0, 1.0], table, [0.0, 1e-10])
 #
-# == {}[link:index.html"name="9] QAWO adaptive integration for oscillatory functions
-# The QAWO algorithm is designed for integrands with an oscillatory factor, 
-# sin(omega x) or cos(omega x). In order to work efficiently the algorithm 
+# == QAWO adaptive integration for oscillatory functions
+# The QAWO algorithm is designed for integrands with an oscillatory factor,
+# sin(omega x) or cos(omega x). In order to work efficiently the algorithm
 # requires a table of Chebyshev moments.
 #
 #
@@ -303,7 +303,7 @@
 # * GSL::Function#qawo(...)
 # * GSL::Integration::qawo(...)
 #
-#   This method uses an adaptive algorithm to compute the integral over 
+#   This method uses an adaptive algorithm to compute the integral over
 #   <tt>[a,b]</tt> with the weight function sin(omega x) or cos(omega x) defined by
 #   the table <tt>table</tt>.
 #
@@ -324,7 +324,7 @@
 #         table = Integration::QAWO_Table.alloc(10.0*Math::PI, 1.0, Integration::SINE, 1000)
 #         p f456.qawo(0.0, [0.0, 1e-10], table)
 #
-# == {}[link:index.html"name="10] QAWF adaptive integration for Fourier integrals
+# == QAWF adaptive integration for Fourier integrals
 # ---
 # * GSL::Function#integration_qawf(a, epsabs = 1e-10, limit = 1000, w, wc, table)
 # * GSL::Function#integration_qawf(a, epsabs = 1e-10, limit = 1000, table)
@@ -334,14 +334,14 @@
 # * GSL::Function#qawf(...)
 # * GSL::Integration::qawf(...)
 #
-#   This method attempts to compute a Fourier integral of the function over 
+#   This method attempts to compute a Fourier integral of the function over
 #   the semi-infinite interval [a,+infty).
 #
 #       I = \int_a^{+infty} dx f(x) sin(omega x)
 #       I = \int_a^{+infty} dx f(x) cos(omega x)
 #
-#   The parameter omega is taken from the table <tt>table</tt> (the length <tt>L|</tt> 
-#   can take any value, since it is overridden by this function to a value 
+#   The parameter omega is taken from the table <tt>table</tt> (the length <tt>L|</tt>
+#   can take any value, since it is overridden by this function to a value
 #   appropriate for the fourier integration).
 #
 #   * ex:
@@ -373,15 +373,15 @@
 #        p f457.qawf(0.0, limit, w, table)       # Error
 #        p f457.qawf(0.0, limit, wc, table)      # Error
 #
-# == {}[link:index.html"name="11] Gauss-Legendre integration
+# == Gauss-Legendre integration
 # (GSL-1.14)
 # The fixed-order Gauss-Legendre integration routines are provided for fast integration of smooth functions with known polynomial order. The n-point Gauss-Legendre rule is exact for polynomials of order 2*n-1 or less. For example, these rules are useful when integrating basis functions to form mass matrices for the Galerkin method. Unlike other numerical integration routines within the library, these routines do not accept absolute or relative error bounds.
 #
 # ---
 # * GSL::Integration::Glfixed_table.alloc(n)
 #
-#   Determines the Gauss-Legendre abscissae and weights necessary for an <tt>n</tt>-point fixed order 
-#   integration scheme. If possible, high precision precomputed coefficients are used. 
+#   Determines the Gauss-Legendre abscissae and weights necessary for an <tt>n</tt>-point fixed order
+#   integration scheme. If possible, high precision precomputed coefficients are used.
 #   If precomputed weights are not available, lower precision coefficients are computed on the fly.
 #
 # ---
@@ -389,10 +389,10 @@
 #
 #   Applies the Gauss-Legendre integration rule contained in table <tt>t</tt> and returns the result.
 #
-# {prev}[link:rdoc/wavelet_rdoc.html]
-# {next}[link:rdoc/rng_rdoc.html]
+# {prev}[link:wavelet_rdoc.html]
+# {next}[link:rng_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #