RubyGems - rb-gsl - Versions diffs - 1.16.0.2 → 1.16.0.3.rc1 - Mend

rb-gsl 1.16.0.2 → 1.16.0.3.rc1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (64) hide show

data/rdoc/sf.rdoc CHANGED Viewed

@@ -1,51 +1,51 @@
 #
 # = Special Functions
 #
-# === {}[link:index.html"name="0.1] Contents:
-# 1. {Usage:}[link:rdoc/sf_rdoc.html#1]
-# 1. {GSL::Sf::Result class}[link:rdoc/sf_rdoc.html#2]
-# 1. {Modes}[link:rdoc/sf_rdoc.html#3]
-# 1. {Airy functions}[link:rdoc/sf_rdoc.html#4]
-# 1. {Bessel functins}[link:rdoc/sf_rdoc.html#5]
-# 1. {Clausen functins}[link:rdoc/sf_rdoc.html#6]
-# 1. {Coulomb functins}[link:rdoc/sf_rdoc.html#7]
-# 1. {Coupling coefficients}[link:rdoc/sf_rdoc.html#8]
-# 1. {Dawson coefficients}[link:rdoc/sf_rdoc.html#9]
-# 1. {Debye coefficients}[link:rdoc/sf_rdoc.html#10]
-# 1. {Dilogarithm}[link:rdoc/sf_rdoc.html#11]
-# 1. {Elementary operations}[link:rdoc/sf_rdoc.html#12]
-# 1. {Elliptic integrals}[link:rdoc/sf_rdoc.html#13]
-# 1. {Elliptic functions}[link:rdoc/sf_rdoc.html#14]
-# 1. {Error functions}[link:rdoc/sf_rdoc.html#15]
-# 1. {Exponential functions}[link:rdoc/sf_rdoc.html#16]
-# 1. {Exponential integrals}[link:rdoc/sf_rdoc.html#17]
-# 1. {Fermi-Dirac function}[link:rdoc/sf_rdoc.html#18]
-# 1. {Gamma function}[link:rdoc/sf_rdoc.html#19]
-# 1. {Gegenbauer functions}[link:rdoc/sf_rdoc.html#20]
-# 1. {Hypergeometric functions}[link:rdoc/sf_rdoc.html#21]
-# 1. {Laguerre functions}[link:rdoc/sf_rdoc.html#22]
-# 1. {Lambert W functions}[link:rdoc/sf_rdoc.html#23]
-# 1. {Legendre functions and spherical harmonics}[link:rdoc/sf_rdoc.html#24]
-# 1. {Logarithm and related functions}[link:rdoc/sf_rdoc.html#25]
-# 1. {Mathieu functions}[link:rdoc/sf_rdoc.html#26]
-# 1. {Power function}[link:rdoc/sf_rdoc.html#27]
-# 1. {Psi (digamma) function}[link:rdoc/sf_rdoc.html#28]
-# 1. {Synchrotron functions}[link:rdoc/sf_rdoc.html#29]
-# 1. {Transport functions}[link:rdoc/sf_rdoc.html#30]
-# 1. {Trigonometric functions}[link:rdoc/sf_rdoc.html#31]
-# 1. {Zeta functions}[link:rdoc/sf_rdoc.html#32]
-#
-# == {}[link:index.html"name="1] Usage
+# === Contents:
+# 1. {Usage:}[link:sf_rdoc.html#label-Usage]
+# 1. {GSL::Sf::Result class}[link:sf_rdoc.html#label-Result+class]
+# 1. {Modes}[link:sf_rdoc.html#label-Modes]
+# 1. {Airy functions}[link:sf_rdoc.html#label-Airy+Functions+and+Derivatives]
+# 1. {Bessel functins}[link:sf_rdoc.html#label-Bessel+Functions]
+# 1. {Clausen functins}[link:sf_rdoc.html#label-Clausen+Functions]
+# 1. {Coulomb functins}[link:sf_rdoc.html#label-Coulomb+Functions]
+# 1. {Coupling coefficients}[link:sf_rdoc.html#label-Coupling+Coefficients]
+# 1. {Dawson coefficients}[link:sf_rdoc.html#label-Dawson+Function]
+# 1. {Debye coefficients}[link:sf_rdoc.html#label-Debye+Functions]
+# 1. {Dilogarithm}[link:sf_rdoc.html#label-Dilogarithm]
+# 1. {Elementary operations}[link:sf_rdoc.html#label-Elementary+Operations]
+# 1. {Elliptic integrals}[link:sf_rdoc.html#label-Elliptic+Integrals]
+# 1. {Elliptic functions}[link:sf_rdoc.html#label-Elliptic+Functions+%28Jacobi%29]
+# 1. {Error functions}[link:sf_rdoc.html#label-Error+Functions]
+# 1. {Exponential functions}[link:sf_rdoc.html#label-Exponential+Functions]
+# 1. {Exponential integrals}[link:sf_rdoc.html#label-Exponential+Integrals]
+# 1. {Fermi-Dirac function}[link:sf_rdoc.html#label-Fermi-Dirac+Functions]
+# 1. {Gamma function}[link:sf_rdoc.html#label-Gamma+Function]
+# 1. {Gegenbauer functions}[link:sf_rdoc.html#label-Gegenbauer+Functions]
+# 1. {Hypergeometric functions}[link:sf_rdoc.html#label-Hypergeometric+Functions]
+# 1. {Laguerre functions}[link:sf_rdoc.html#label-Laguerre+Functions]
+# 1. {Lambert W functions}[link:sf_rdoc.html#label-Lambert+W+Functions]
+# 1. {Legendre functions and spherical harmonics}[link:sf_rdoc.html#label-Legendre+Functions+and+Spherical+Harmonics]
+# 1. {Logarithm and related functions}[link:sf_rdoc.html#label-Logarithm+and+Related+Functions]
+# 1. {Mathieu functions}[link:sf_rdoc.html#label-Mathieu+functions]
+# 1. {Power function}[link:sf_rdoc.html#label-Power+Functions]
+# 1. {Psi (digamma) function}[link:sf_rdoc.html#label-Psi+%28Digamma%29+Function]
+# 1. {Synchrotron functions}[link:sf_rdoc.html#label-Synchrotron+Functions]
+# 1. {Transport functions}[link:sf_rdoc.html#label-Transport+Functions]
+# 1. {Trigonometric functions}[link:sf_rdoc.html#label-Trigonometric+Functions]
+# 1. {Zeta functions}[link:sf_rdoc.html#label-Zeta+Functions]
+#
+# == Usage
 # Ruby/GSL provides all the (documented) GSL special functions as module functions
-# under the <tt>GSL::Sf</tt> module.
+# under the <tt>GSL::Sf</tt> module.
 # The prefix <tt>gsl_sf_</tt> in C functions is replaced by the module
 # identifier <tt>GSL::Sf::</tt>. For example, the regular Bessel function of 0-th order
-# is evaluated as
+# is evaluated as
 #   y = GSL::Sf::bessel_J0(x)
 # or
 #   include GSL::Sf
 #   y = bessel_J0(x)
-# where the argument <tt>x</tt> can be a <tt>Numeric</tt>, <tt>GSL::Vector</tt>,
+# where the argument <tt>x</tt> can be a <tt>Numeric</tt>, <tt>GSL::Vector</tt>,
 # <tt>GSL::Matrix</tt>, or an <tt>NArray</tt> object.
 #
 # Example:
@@ -63,26 +63,26 @@
 #   [ 7.652e-01 2.239e-01 -2.601e-01 -3.971e-01 ]
 #   >> x = Matrix[1..4, 2, 2]
 #   => GSL::Matrix
-#   [  1.000e+00  2.000e+00
+#   [  1.000e+00  2.000e+00
 #      3.000e+00  4.000e+00 ]
 #   >> Sf::bessel_J0(x)
 #   => GSL::Matrix
-#   [  7.652e-01  2.239e-01
+#   [  7.652e-01  2.239e-01
 #     -2.601e-01 -3.971e-01 ]
 #   >> x = NArray[1.0, 2, 3, 4]
-#   => NArray.float(4):
+#   => NArray.float(4):
 #   [ 1.0, 2.0, 3.0, 4.0 ]
 #   >> Sf::bessel_J0(x)
-#   => NArray.float(4):
+#   => NArray.float(4):
 #   [ 0.765198, 0.223891, -0.260052, -0.39715 ]
 #
-# == {}[link:index.html"name="2] <tt>GSL::Sf::Result</tt> Class
+# == <tt>Result</tt> class
 # The Ruby methods as wrappers of GSL functions with the suffix "<tt>_e</tt>" return
 # <tt>GSL::Sf::Result</tt> objects which contain the function values as well as
 # error information.
 #
-# === <tt>GSL::Sf::Result</tt> instance methods
-#
+# === <tt>Result</tt> instance methods
+#
 # ---
 # * GSL::Sf::Result#val
 #   Returns the value.
@@ -96,12 +96,12 @@
 # * GSL::Sf::Result_e10#err
 #   Returns the error.
 #
-# == {}[link:index.html"name="3] Modes
-# The goal of the library is to achieve double precision accuracy wherever possible.
-# However the cost of evaluating some special functions to double precision can
-# be significant, particularly where very high order terms are required.
-# In these cases a <tt>mode</tt> argument allows the accuracy of the function
-# to be reduced in order to improve performance.
+# == Modes
+# The goal of the library is to achieve double precision accuracy wherever possible.
+# However the cost of evaluating some special functions to double precision can
+# be significant, particularly where very high order terms are required.
+# In these cases a <tt>mode</tt> argument allows the accuracy of the function
+# to be reduced in order to improve performance.
 # The following precision levels are available for the mode argument,
 # given by Fixnum constants under the <tt>GSL</tt> module,
 # * <tt>GSL::PREC_DOUBLE</tt>
@@ -113,7 +113,7 @@
 #
 # The approximate mode provides the fastest evaluation at the lowest accuracy.
 #
-# == {}[link:index.html"name="4] Airy Functions and Derivatives
+# == Airy Functions and Derivatives
 # ---
 # * GSL::Sf::airy_Ai(x, mode = GSL::PREC_DOUBLE)
 #
@@ -125,24 +125,24 @@
 # ---
 # * GSL::Sf::airy_Ai_scaled(x, mode = GSL::PREC_DOUBLE)
 #
-#   Computes a scaled version of the Airy function S_A(x) Ai(x).
+#   Computes a scaled version of the Airy function S_A(x) Ai(x).
 #   For x>0 the scaling factor S_A(x) is exp(+(2/3) x^(3/2)), and is 1 for x<0.
 # ---
 # * GSL::Sf::airy_Bi_scaled(x, mode = GSL::PREC_DOUBLE)
 #
-#   Computes a scaled version of the Airy function S_B(x) Bi(x).
+#   Computes a scaled version of the Airy function S_B(x) Bi(x).
 #   For x>0 the scaling factor S_B(x) is exp(-(2/3) x^(3/2)), and is 1 for x<0.
 #
-# === {}[link:index.html"name="4.1] Derivatives of Airy Functions
+# === Derivatives of Airy Functions
 # ---
 # * GSL::Sf::airy_Ai_deriv(x, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the Airy function derivative Ai'(x) with an accuracy
+#   Computes the Airy function derivative Ai'(x) with an accuracy
 #   specified by <tt>mode</tt>.
 # ---
 # * GSL::Sf::airy_Bi_deriv(x, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the Airy function derivative Bi'(x) with an accuracy
+#   Computes the Airy function derivative Bi'(x) with an accuracy
 #   specified by <tt>mode</tt>.
 # ---
 # * GSL::Sf::airy_Ai_deriv_scaled(x, mode = GSL::PREC_DOUBLE)
@@ -153,7 +153,7 @@
 #
 #   Computes the derivative of the scaled Airy function S_B(x) Bi(x).
 #
-# === {}[link:index.html"name="4.2] Zeros of Airy Functions
+# === Zeros of Airy Functions
 # ---
 # * GSL::Sf::airy_zero_Ai(s)
 #
@@ -163,21 +163,21 @@
 #
 #   Computes the location of the <tt>s</tt>-th zero of the Airy function Bi(x).
 #
-# === {}[link:index.html"name="4.3] Zeros of Derivatives of Airy Functions
+# === Zeros of Derivatives of Airy Functions
 # ---
 # * GSL::Sf::airy_zero_Ai_deriv(s)
 #
-#   Computes the location of the <tt>s</tt>-th zero of the Airy function
+#   Computes the location of the <tt>s</tt>-th zero of the Airy function
 #   derivative Ai'(x).
 # ---
 # * GSL::Sf::airy_zero_Bi_deriv(s)
 #
-#   Computes the location of the <tt>s</tt>-th zero of the Airy function
+#   Computes the location of the <tt>s</tt>-th zero of the Airy function
 #   derivative Bi'(x).
 #
 #
-# == {}[link:index.html"name="5] Bessel Functions
-# === {}[link:index.html"name="5.1] Regular Cylindrical Bessel Functions
+# == Bessel Functions
+# === Regular Cylindrical Bessel Functions
 # ---
 # * GSL::Sf::bessel_J0(x)
 #
@@ -193,12 +193,12 @@
 # ---
 # * GSL::Sf::bessel_Jn_array(nmin, nmax, x)
 #
-#   Computes the values of the regular cylindrical Bessel functions J_n(x)
-#   for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and returns the
+#   Computes the values of the regular cylindrical Bessel functions J_n(x)
+#   for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and returns the
 #   results as a <tt>GSL::Vector</tt> object.
-#   The values are computed using recurrence relations, for efficiency,
+#   The values are computed using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
-# === {}[link:index.html"name="5.2] Irregular Cylindrical Bessel Functions
+# === Irregular Cylindrical Bessel Functions
 # ---
 # * GSL::Sf::bessel_Y0(x)
 #
@@ -214,114 +214,114 @@
 # ---
 # * GSL::Sf::bessel_Yn_array(nmin, nmax, x)
 #
-#   Computes the values of the irregular cylindrical Bessel functions Y_n(x)
-#   for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and returns the
+#   Computes the values of the irregular cylindrical Bessel functions Y_n(x)
+#   for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and returns the
 #   results as a <tt>GSL::Vector</tt> object.
-#   The values are computed using recurrence relations, for efficiency,
+#   The values are computed using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
 #
-# === {}[link:index.html"name="5.3] Regular Modified Cylindrical Bessel Functions
+# === Regular Modified Cylindrical Bessel Functions
 # ---
 # * GSL::Sf::bessel_I0(x)
 #
-#   Computes the regular modified cylindrical Bessel function of zeroth order,
+#   Computes the regular modified cylindrical Bessel function of zeroth order,
 #   I_0(x).
 # ---
 # * GSL::Sf::bessel_I1(x)
 #
-#   Computes the regular modified cylindrical Bessel function of first order,
+#   Computes the regular modified cylindrical Bessel function of first order,
 #   I_1(x).
 # ---
 # * GSL::Sf::bessel_In(n, x)
 #
-#   Computes the regular modified cylindrical Bessel function of order <tt>n</tt>,
+#   Computes the regular modified cylindrical Bessel function of order <tt>n</tt>,
 #   I_n(x).
 # ---
 # * GSL::Sf::bessel_In_array(nmin, nmax, x)
 #
-#   Computes the values of the regular modified cylindrical Bessel functions
-#   I_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and returns the
-#   results as a <tt>GSL::Vector</tt> object. The start of the range <tt>nmin</tt>
-#   must be positive or zero. The values are computed using recurrence relations,
+#   Computes the values of the regular modified cylindrical Bessel functions
+#   I_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and returns the
+#   results as a <tt>GSL::Vector</tt> object. The start of the range <tt>nmin</tt>
+#   must be positive or zero. The values are computed using recurrence relations,
 #   for efficiency, and therefore may differ slightly from the exact values.
 # ---
 # * GSL::Sf::bessel_I0_scaled(x)
 #
-#   Computes the scaled regular modified cylindrical Bessel function of
+#   Computes the scaled regular modified cylindrical Bessel function of
 #   zeroth order, exp(-|x|) I_0(x).
 # ---
 # * GSL::Sf::bessel_I1_scaled(x)
 #
-#   Computes the scaled regular modified cylindrical Bessel function of first
+#   Computes the scaled regular modified cylindrical Bessel function of first
 #   order, exp(-|x|)I_1(x).
 # ---
 # * GSL::Sf::bessel_In_scaled(n, x)
 #
-#   Computes the scaled regular modified cylindrical Bessel function of order
+#   Computes the scaled regular modified cylindrical Bessel function of order
 #   <tt>n</tt>,  exp(-|x|) I_n(x).
 # ---
 # * GSL::Sf::bessel_In_scaled_array(nmin, nmax, x)
 #
-#   Computes the values of the scaled regular modified cylindrical Bessel
-#   functions exp(-|x|) I_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive,
-#   and returns the results as a <tt>GSL::Vector</tt> object. The start of the range
-#   <tt>nmin</tt>  must be positive or zero. The values are computed using
-#   recurrence relations,  for efficiency, and therefore may differ slightly
+#   Computes the values of the scaled regular modified cylindrical Bessel
+#   functions exp(-|x|) I_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive,
+#   and returns the results as a <tt>GSL::Vector</tt> object. The start of the range
+#   <tt>nmin</tt>  must be positive or zero. The values are computed using
+#   recurrence relations,  for efficiency, and therefore may differ slightly
 #   from the exact values.
 #
-# === {}[link:index.html"name="5.4] Irregular Modified Cylindrical Bessel Functions
+# === Irregular Modified Cylindrical Bessel Functions
 # ---
 # * GSL::Sf::bessel_K0(x)
 #
-#   Computes the irregular modified cylindrical Bessel function
+#   Computes the irregular modified cylindrical Bessel function
 #   of zeroth order, K_0(x), for x > 0.
 # ---
 # * GSL::Sf::bessel_K1(x)
 #
-#   Computes the irregular modified cylindrical Bessel function
+#   Computes the irregular modified cylindrical Bessel function
 #   of first order, K_1(x), for x > 0.
 # ---
 # * GSL::Sf::bessel_Kn(n, x)
 #
-#   Computes the irregular modified cylindrical Bessel function
+#   Computes the irregular modified cylindrical Bessel function
 #   of order <tt>n</tt>, K_n(x), for x > 0.
 # ---
 # * GSL::Sf::bessel_Kn_array(nmin, nmax, x)
 #
-#   Computes the values of the irregular modified cylindrical Bessel
-#   functions K_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive,
-#   and returns the results as a <tt>GSL::Vector</tt> object.
-#   The start of the range <tt>nmin</tt> must be positive or zero.
-#   The domain of the function is <tt>x>0</tt>.
-#   The values are computed using recurrence relations, for efficiency,
+#   Computes the values of the irregular modified cylindrical Bessel
+#   functions K_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive,
+#   and returns the results as a <tt>GSL::Vector</tt> object.
+#   The start of the range <tt>nmin</tt> must be positive or zero.
+#   The domain of the function is <tt>x>0</tt>.
+#   The values are computed using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
 # ---
 # * GSL::Sf::bessel_K0_scaled(x)
 #
-#   Computes the scaled irregular modified cylindrical Bessel function
+#   Computes the scaled irregular modified cylindrical Bessel function
 #   of zeroth order exp(x) K_0(x) for x>0.
 # ---
 # * GSL::Sf::bessel_K1_scaled(x)
 #
-#   Computes the scaled irregular modified cylindrical Bessel function
+#   Computes the scaled irregular modified cylindrical Bessel function
 #   of first order exp(x) K_1(x) for x>0
 # ---
 # * GSL::Sf::bessel_Kn_scaled(n, x)
 #
-#   Computes the scaled irregular modified cylindrical Bessel function
+#   Computes the scaled irregular modified cylindrical Bessel function
 #   of order <tt>n</tt>, exp(x) K_n(x), for x>0.
 # ---
 # * GSL::Sf::bessel_Kn_scaled_array(nmin, nmax, x)
 #
-#   Computes the values of the scaled irregular cylindrical Bessel functions
-#   exp(x) K_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive,
-#   and returns the results as a <tt>GSL::Vector</tt> object.
-#   The start of the range nmin must be positive or zero.
-#   The domain of the function is x>0. The values are computed
-#   using recurrence relations, for efficiency,
+#   Computes the values of the scaled irregular cylindrical Bessel functions
+#   exp(x) K_n(x) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive,
+#   and returns the results as a <tt>GSL::Vector</tt> object.
+#   The start of the range nmin must be positive or zero.
+#   The domain of the function is x>0. The values are computed
+#   using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
 #
-# === {}[link:index.html"name="5.5] Regular Spherical Bessel Functions
+# === Regular Spherical Bessel Functions
 # ---
 # * GSL::Sf::bessel_j0(x)
 #
@@ -330,71 +330,71 @@
 # ---
 # * GSL::Sf::bessel_j1(x)
 #
-#   Computes the regular spherical Bessel function of first order,
+#   Computes the regular spherical Bessel function of first order,
 #   j1(x) = (sin(x)/x - cos(x))/x.
 # ---
 # * GSL::Sf::bessel_j2(x)
 #
-#   Computes the regular spherical Bessel function of second order,
+#   Computes the regular spherical Bessel function of second order,
 #   j2(x) = ((3/x^2 - 1)sin(x) - 3cos(x)/x)/x.
 # ---
 # * GSL::Sf::bessel_jl(l, x)
 #
-#   Computes the regular spherical Bessel function of order l,
+#   Computes the regular spherical Bessel function of order l,
 #   j_l(x), for l >= 0 and x >= 0.
 # ---
 # * GSL::Sf::bessel_jl_array(lmax, x)
 #
-#   Computes the values of the regular spherical Bessel functions j_l(x)
-#   for l from 0 to <tt>lmax</tt> inclusive for lmax >= 0 and x >= 0,
-#   and returns the results as a <tt>GSL::Vector</tt> object.
-#   The values are computed using recurrence relations, for efficiency,
+#   Computes the values of the regular spherical Bessel functions j_l(x)
+#   for l from 0 to <tt>lmax</tt> inclusive for lmax >= 0 and x >= 0,
+#   and returns the results as a <tt>GSL::Vector</tt> object.
+#   The values are computed using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
 # ---
 # * GSL::Sf::bessel_jl_steed_array(lmax, x)
 #
-#   This method uses Steed's method to compute the values of the regular
-#   spherical Bessel functions j_l(x) for l from 0 to <tt>lmax</tt> inclusive
-#   for <tt>lmax</tt> >= 0 and x >= 0, and returns the results as a <tt>GSL::Vector</tt>
-#   object.  The Steed/Barnett algorithm is described in
-#   Comp. Phys. Comm. 21, 297 (1981). Steed's method is more stable than the
+#   This method uses Steed's method to compute the values of the regular
+#   spherical Bessel functions j_l(x) for l from 0 to <tt>lmax</tt> inclusive
+#   for <tt>lmax</tt> >= 0 and x >= 0, and returns the results as a <tt>GSL::Vector</tt>
+#   object.  The Steed/Barnett algorithm is described in
+#   Comp. Phys. Comm. 21, 297 (1981). Steed's method is more stable than the
 #   recurrence used in the other functions but is also slower.
 #
-# === {}[link:index.html"name="5.6] Irregular Spherical Bessel Functions
+# === Irregular Spherical Bessel Functions
 # ---
 # * GSL::Sf::bessel_y0(x)
 #
-#   Computes the irregular spherical Bessel function of zeroth order,
+#   Computes the irregular spherical Bessel function of zeroth order,
 #   y_0(x) = -cos(x)/x.
 # ---
 # * GSL::Sf::bessel_y1(x)
 #
-#   Computes the irregular spherical Bessel function of first order,
+#   Computes the irregular spherical Bessel function of first order,
 #   y_1(x) = -(cos(x)/x + sin(x))/x.
 # ---
 # * GSL::Sf::bessel_y2(x)
 #
-#   Computes the irregular spherical Bessel function of second order,
+#   Computes the irregular spherical Bessel function of second order,
 #   y_2(x) = (-3/x^3 + 1/x)cos(x) - (3/x^2)sin(x).
 # ---
 # * GSL::Sf::bessel_yl(l, x)
 #
-#   Computes the irregular spherical Bessel function of order <tt>l</tt>,
+#   Computes the irregular spherical Bessel function of order <tt>l</tt>,
 #   y_l(x), for l >= 0.
 # ---
 # * GSL::Sf::bessel_yl_array(lmax, x)
 #
-#   This method computes the values of the irregular spherical Bessel functions
-#   y_l(x) for l from 0 to <tt>lmax</tt> inclusive for <tt>lmax >= 0</tt>),
-#   and returns the results as a <tt>GSL::Vector</tt> object.
-#   The values are computed using recurrence relations, for efficiency,
+#   This method computes the values of the irregular spherical Bessel functions
+#   y_l(x) for l from 0 to <tt>lmax</tt> inclusive for <tt>lmax >= 0</tt>),
+#   and returns the results as a <tt>GSL::Vector</tt> object.
+#   The values are computed using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
 #
-# === {}[link:index.html"name="5.7] Regular Modified Spherical Bessel Functions
+# === Regular Modified Spherical Bessel Functions
 # ---
 # * GSL::Sf::bessel_i0_scaled(x)
 #
-#   Computes the scaled regular modified spherical Bessel function of zeroth
+#   Computes the scaled regular modified spherical Bessel function of zeroth
 #   order, exp(-|x|) i_0(x).
 # ---
 # * GSL::Sf::bessel_i1_scaled(x)
@@ -409,22 +409,22 @@
 # ---
 # * GSL::Sf::bessel_il_scaled(l, x)
 #
-#   Computes the scaled regular modified spherical Bessel function of
+#   Computes the scaled regular modified spherical Bessel function of
 #   order <tt>l</tt>, exp(-|x|) i_l(x).
 # ---
 # * GSL::Sf::bessel_il_scaled_array(lmax, x)
 #
-#   This routine computes the values of the scaled regular modified cylindrical
-#   Bessel functions exp(-|x|) i_l(x) for l from 0 to <tt>lmax</tt> inclusive for
-#   <tt>lmax >= 0</tt>,     and returns the results as a <tt>GSL::Vector</tt> object.
-#   The values are computed using recurrence relations, for efficiency,
+#   This routine computes the values of the scaled regular modified cylindrical
+#   Bessel functions exp(-|x|) i_l(x) for l from 0 to <tt>lmax</tt> inclusive for
+#   <tt>lmax >= 0</tt>,     and returns the results as a <tt>GSL::Vector</tt> object.
+#   The values are computed using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
 #
-# === {}[link:index.html"name="5.8] Irregular Modified Spherical Bessel Functions
+# === Irregular Modified Spherical Bessel Functions
 # ---
 # * GSL::Sf::bessel_k0_scaled(x)
 #
-#   Computes the scaled irregular modified spherical Bessel function of zeroth
+#   Computes the scaled irregular modified spherical Bessel function of zeroth
 #   order, exp(-|x|) k_0(x).
 # ---
 # * GSL::Sf::bessel_k1_scaled(x)
@@ -439,69 +439,69 @@
 # ---
 # * GSL::Sf::bessel_kl_scaled(l, x)
 #
-#   Computes the scaled irregular modified spherical Bessel function of
+#   Computes the scaled irregular modified spherical Bessel function of
 #   order <tt>l</tt>, exp(-|x|) k_l(x).
 # ---
 # * GSL::Sf::bessel_kl_scaled_array(lmax, x)
 #
-#   This routine computes the values of the scaled irregular modified cylindrical
-#   Bessel functions exp(-|x|) k_l(x) for l from 0 to <tt>lmax</tt> inclusive for
-#   <tt>lmax >= 0</tt>,     and returns the results as a <tt>GSL::Vector</tt> object.
-#   The values are computed using recurrence relations, for efficiency,
+#   This routine computes the values of the scaled irregular modified cylindrical
+#   Bessel functions exp(-|x|) k_l(x) for l from 0 to <tt>lmax</tt> inclusive for
+#   <tt>lmax >= 0</tt>,     and returns the results as a <tt>GSL::Vector</tt> object.
+#   The values are computed using recurrence relations, for efficiency,
 #   and therefore may differ slightly from the exact values.
 #
-# === {}[link:index.html"name="5.9] Regular Bessel Function - Fractional Order
+# === Regular Bessel Function - Fractional Order
 # ---
 # * GSL::Sf::bessel_Jnu(nu, x)
 #
-#   Computes the regular cylindrical Bessel function of fractional
+#   Computes the regular cylindrical Bessel function of fractional
 #   order <tt>nu</tt>, J_nu(x).
 # ---
 # * GSL::Sf::bessel_sequence_Jnu_e(nu, v)
 # * GSL::Sf::bessel_sequence_Jnu_e(nu, mode, v)
 #
-#   These compute the regular cylindrical Bessel function of fractional order nu, J_nu(x),
-#   evaluated at a series of x values. The <tt>GSL::Vector</tt> object <tt>v</tt>
-#   contains the x values. They are assumed to be strictly ordered and positive.
+#   These compute the regular cylindrical Bessel function of fractional order nu, J_nu(x),
+#   evaluated at a series of x values. The <tt>GSL::Vector</tt> object <tt>v</tt>
+#   contains the x values. They are assumed to be strictly ordered and positive.
 #   The vector is over-written with the values of J_nu(x_i).
 #
-# === {}[link:index.html"name="5.10] Irregular Bessel Functions - Fractional Order
+# === Irregular Bessel Functions - Fractional Order
 # ---
 # * GSL::Sf::bessel_Ynu(nu, x)
 #
-#   Computes the irregular cylindrical Bessel function of fractional order <tt>nu</tt>,
+#   Computes the irregular cylindrical Bessel function of fractional order <tt>nu</tt>,
 #   Y_nu(x).
 #
-# === {}[link:index.html"name="5.11] Regular Modified Bessel Functions - Fractional Order
+# === Regular Modified Bessel Functions - Fractional Order
 # ---
 # * GSL::Sf::bessel_Inu(nu, x)
 #
-#   Computes the regular modified Bessel function of fractional order <tt>nu</tt>,
+#   Computes the regular modified Bessel function of fractional order <tt>nu</tt>,
 #   I_nu(x) for x>0, nu>0.
 # ---
 # * GSL::Sf::bessel_Inu_scaled(nu, x)
 #
-#   Computes the scaled regular modified Bessel function of fractional order <tt>nu</tt>,
+#   Computes the scaled regular modified Bessel function of fractional order <tt>nu</tt>,
 #   exp(-|x|) I_nu(x) for x>0, nu>0.
 #
-# === {}[link:index.html"name="5.12] Irregular Modified Bessel Functions - Fractional Order
+# === Irregular Modified Bessel Functions - Fractional Order
 # ---
 # * GSL::Sf::bessel_Knu(nu, x)
 #
-#   Computes the irregular modified Bessel function of fractional order <tt>nu</tt>,
+#   Computes the irregular modified Bessel function of fractional order <tt>nu</tt>,
 #   K_nu(x) for x>0, nu>0.
 # ---
 # * GSL::Sf::bessel_lnKnu(nu, x)
 #
-#   Computes the logarithm of the irregular modified Bessel function of fractional
+#   Computes the logarithm of the irregular modified Bessel function of fractional
 #   order <tt>nu</tt>, ln(K_nu(x)) for x>0, nu>0
 # ---
 # * GSL::Sf::bessel_Knu_scaled(nu, x)
 #
-#   Computes the scaled irregular modified Bessel function of fractional order <tt>nu</tt>,
+#   Computes the scaled irregular modified Bessel function of fractional order <tt>nu</tt>,
 #   exp(+|x|) K_nu(x) for x>0, nu>0.
 #
-# === {}[link:index.html"name="5.13] Zeros of Regular Bessel Functions
+# === Zeros of Regular Bessel Functions
 # ---
 # * GSL::Sf::bessel_zero_J0(s)
 #
@@ -513,10 +513,10 @@
 # ---
 # * GSL::Sf::bessel_zero_Jnu(nu, s)
 #
-#   Computes the location of the <tt>s</tt>-th positive zero of the Bessel function
+#   Computes the location of the <tt>s</tt>-th positive zero of the Bessel function
 #   J_nu(x). The current implementation does not support negative values of <tt>nu</tt>.
 #
-# == {}[link:index.html"name="6] Clausen Functions
+# == Clausen Functions
 # ---
 # * GSL::Sf::clausen(x)
 #
@@ -525,55 +525,55 @@
 #   It is related to the dilogarithm by Cl_2(theta) = Im Li_2(exp(i theta)).
 #
 #
-# == {}[link:index.html"name="7] Coulomb Functions
+# == Coulomb Functions
 # ---
 # * GSL::Sf::hydrogenicR_1(Z, r)
 #
-#   Computes the lowest-order normalized hydrogenic bound state
+#   Computes the lowest-order normalized hydrogenic bound state
 #   radial wavefunction R_1 := 2Z sqrt{Z} exp(-Z r).
 # ---
 # * GSL::Sf::hydrogenicR(n, l, Z, r)
 #
 #   Computes the <tt>n</tt>-th normalized hydrogenic bound state radial wavefunction,
-#        R_n := 2 (Z^{3/2}/n^2) sqrt{(n-l-1)!/(n+l)!}exp(-Z r/n) (2Z/n)^l L^{2l+1}_{n-l-1}(2Z/n r).
-#   The normalization is chosen such that the wavefunction psi is given by
+#        R_n := 2 (Z^{3/2}/n^2) sqrt{(n-l-1)!/(n+l)!}exp(-Z r/n) (2Z/n)^l L^{2l+1}_{n-l-1}(2Z/n r).
+#   The normalization is chosen such that the wavefunction psi is given by
 #   psi(n,l,r) = R_n Y_{lm}.
 #
-# === {}[link:index.html"name="7.1] Coulomb Wave Functions
+# === Coulomb Wave Functions
 # ---
 # * GSL::Sf::coulomb_wave_FG_e(eta, x, L, k)
 #
-#   This method computes the coulomb wave functions
-#   F_L(eta,x), G_{L-k}(eta,x) and their derivatives with respect to x,
-#   F'_L(eta,x) G'_{L-k}(eta,x).
-#   The parameters are restricted to <tt>L</tt>, <tt>L-k > -1/2</tt>, <tt>x > 0</tt>
-#   and integer <tt>k</tt>. Note that <tt>L</tt> itself is not restricted to being
+#   This method computes the coulomb wave functions
+#   F_L(eta,x), G_{L-k}(eta,x) and their derivatives with respect to x,
+#   F'_L(eta,x) G'_{L-k}(eta,x).
+#   The parameters are restricted to <tt>L</tt>, <tt>L-k > -1/2</tt>, <tt>x > 0</tt>
+#   and integer <tt>k</tt>. Note that <tt>L</tt> itself is not restricted to being
 #   an integer. The results are returned as an array of 7 elements,
 #   <tt>[F, G, Fp, Gp, exp_F, exp_G, status]</tt>,
-#   as <tt>F, G</tt> for the function values, <tt>Fp, Gp</tt>
+#   as <tt>F, G</tt> for the function values, <tt>Fp, Gp</tt>
 #   for the derivative values, and <tt>exp_F, exp_G</tt> for scaling exponents
 #   in the case of overflow occurs.
 # ---
 # * GSL::Sf::coulomb_wave_F_array(Lmin, kmax, eta, x)
 #
-#   This method computes the function F_L(eta,x) for
-#   L = <tt>Lmin ... Lmin + kmax</tt> and returns the results
-#   as an array of 3 elements,
-#   <tt>[fc_array, F_exponent, status]</tt>.
+#   This method computes the function F_L(eta,x) for
+#   L = <tt>Lmin ... Lmin + kmax</tt> and returns the results
+#   as an array of 3 elements,
+#   <tt>[fc_array, F_exponent, status]</tt>.
 #   In the case of overflow, the exponent is returned in <tt>F_exponent</tt>.
 # ---
 # * GSL::Sf::coulomb_wave_FG_array(Lmin, kmax, eta, x)
 #
 #   This method computes the functions F_L(eta,x), G_L(eta,x) for L = <tt>Lmin</tt>
-#   ... <tt>Lmin + kmax</tt> and returns the results as an array of
-#   5 elements, <tt>[fc_array, gc_array, F_exponent, G_exponent, status]</tt>.
-#   In the case of overflow the exponents are stored in <tt>F_exponent</tt>
+#   ... <tt>Lmin + kmax</tt> and returns the results as an array of
+#   5 elements, <tt>[fc_array, gc_array, F_exponent, G_exponent, status]</tt>.
+#   In the case of overflow the exponents are stored in <tt>F_exponent</tt>
 #   and <tt>G_exponent</tt>.
 # ---
 # * GSL::Sf::coulomb_wave_FGp_array(Lmin, kmax, eta, x)
 #
-#   This method computes the functions F_L(eta,x), G_L(eta,x) and
-#   their derivatives F'_L(eta,x), G'_L(eta,x) for L = <tt>Lmin</tt> ...
+#   This method computes the functions F_L(eta,x), G_L(eta,x) and
+#   their derivatives F'_L(eta,x), G'_L(eta,x) for L = <tt>Lmin</tt> ...
 #   <tt>Lmin + kmax</tt> and returns the results as an array of 7 elements,
 #   <tt>[fc_array, gc_array, fcp_array, gcp_array, F_exponent, G_exponent, status]</tt>.
 #   In the case of overflow the exponents are stored in <tt>F_exponent</tt>
@@ -581,33 +581,33 @@
 # ---
 # * GSL::Sf::coulomb_wave_sphF_array(Lmin, kmax, eta, x)
 #
-#   This method computes the Coulomb wave function divided by the argument
+#   This method computes the Coulomb wave function divided by the argument
 #   F_L(eta, x)/x for L = <tt>Lmin</tt> ... <tt>Lmin + kmax</tt>,
 #   and returns the results as an array of 3 elememnts,
-#   <tt>[fc_array, F_exponent, status]</tt>.
-#   In the case of overflow the exponent is stored in <tt>F_exponent</tt>.
-#   This function reduces to spherical Bessel functions in the limit
+#   <tt>[fc_array, F_exponent, status]</tt>.
+#   In the case of overflow the exponent is stored in <tt>F_exponent</tt>.
+#   This function reduces to spherical Bessel functions in the limit
 #   <tt>eta</tt> to 0.
 #
-# === {}[link:index.html"name="7.2] Coulomb Wave Function Normalization Constant
+# === Coulomb Wave Function Normalization Constant
 # ---
 # * GSL::Sf::coulomb_CL_e(L, eta)
 #
-#   This method computes the Coulomb wave function normalization
+#   This method computes the Coulomb wave function normalization
 #   constant C_L(eta) for L > -1.
 # ---
 # * GSL::Sf::gsl_sf_coulomb_CL_array(Lmin, kmax, eta)
 #
-#   This method computes the coulomb wave function normalization constant
+#   This method computes the coulomb wave function normalization constant
 #   C_L(eta) for L = Lmin ... Lmin + kmax, Lmin > -1.
 #
-# == {}[link:index.html"name="8] Coupling Coefficients
-# The Wigner 3-j, 6-j and 9-j symbols give the coupling coefficients
-# for combined angular momentum vectors. Since the arguments of the standard
-# coupling coefficient functions are integer or half-integer, the arguments
-# of the following functions are, by convention, integers equal to twice the
-# actual spin value. For information on the 3-j coefficients
-# see Abramowitz & Stegun, Section 27.9.
+# == Coupling Coefficients
+# The Wigner 3-j, 6-j and 9-j symbols give the coupling coefficients
+# for combined angular momentum vectors. Since the arguments of the standard
+# coupling coefficient functions are integer or half-integer, the arguments
+# of the following functions are, by convention, integers equal to twice the
+# actual spin value. For information on the 3-j coefficients
+# see Abramowitz & Stegun, Section 27.9.
 #
 # ---
 # * GSL::Sf::coupling_3j(two_ja, two_jb, two_jc, two_ma, two_mb, two_mc)
@@ -615,7 +615,7 @@
 #   Computes the Wigner 3-j coefficient,
 #       ja jb jc
 #       ma mb mc
-#   where the arguments are given in half-integer units,
+#   where the arguments are given in half-integer units,
 #   <tt>ja = two_ja/2, ma = two_ma/2</tt>, etc.
 #
 # ---
@@ -624,7 +624,7 @@
 #   Computes the Wigner 6-j coefficient,
 #       ja jb jc
 #       jd je jf
-#   where the arguments are given in half-integer units,
+#   where the arguments are given in half-integer units,
 #   <tt>ja = two_ja/2, ma = two_ma/2</tt>, etc.
 #
 # ---
@@ -634,21 +634,21 @@
 #       ja jb jc
 #       jd je jf
 #       jg jh ji
-#   where the arguments are given in half-integer units,
+#   where the arguments are given in half-integer units,
 #   <tt>ja = two_ja/2, ma = two_ma/2</tt>, etc.
 #
-# == {}[link:index.html"name="9] Dawson Function
-# The Dawson integral is defined by exp(-x^2) int_0^x dt exp(t^2).
+# == Dawson Function
+# The Dawson integral is defined by exp(-x^2) int_0^x dt exp(t^2).
 # A table of Dawson's integral can be found in Abramowitz & Stegun, Table 7.5.
 # ---
 # * GSL::Sf::dawson(x)
 #
 #   This method computes the value of Dawson's integral for <tt>x</tt>.
 #
-# == {}[link:index.html"name="10] Debye Functions
-# The Debye functions are defined by the integral
-# D_n(x) = n/x^n int_0^x dt (t^n/(e^t - 1)).
-# For further information see Abramowitz & Stegun, Section 27.1.
+# == Debye Functions
+# The Debye functions are defined by the integral
+# D_n(x) = n/x^n int_0^x dt (t^n/(e^t - 1)).
+# For further information see Abramowitz & Stegun, Section 27.1.
 # ---
 # * GSL::Sf::debye_1(x)
 # * GSL::Sf::debye_2(x)
@@ -657,102 +657,102 @@
 #
 #   These methods Compute the n-th order Debye functions.
 #
-# == {}[link:index.html"name="11] Dilogarithm
-# === {}[link:index.html"name="11.1] Real Argument
+# == Dilogarithm
+# === Real Argument
 # ---
 # * GSL::Sf::dilog(x)
 #
-#   Computes the dilogarithm for a real argument. In Lewin's notation this
-#   is Li_2(x), the real part of the dilogarithm of a real <tt>x</tt>.
+#   Computes the dilogarithm for a real argument. In Lewin's notation this
+#   is Li_2(x), the real part of the dilogarithm of a real <tt>x</tt>.
 #   It is defined by the integral representation
-#   Li_2(x) = - Re int_0^x ds log(1-s) / s.
+#   Li_2(x) = - Re int_0^x ds log(1-s) / s.
 #   Note that Im(Li_2(x)) = 0 for x <= 1, and -pi log(x) for x > 1.
 #
-# === {}[link:index.html"name="11.2] Complex Argument
+# === Complex Argument
 # ---
 # * GSL::Sf::complex_dilog_e(r, theta)
 #
-#   This method computes the full complex-valued dilogarithm for
-#   the complex argument z = r exp(i theta).
+#   This method computes the full complex-valued dilogarithm for
+#   the complex argument z = r exp(i theta).
 #   The result is returned as an array of 2 elements, <tt>[re, im]</tt>,
 #   each of them is a <tt>GSL::Sf::Result</tt> object.
 #
-# == {}[link:index.html"name="12] Elementary Operations
-# The following methods allow for the propagation of errors when
-# combining quantities by multiplication.
+# == Elementary Operations
+# The following methods allow for the propagation of errors when
+# combining quantities by multiplication.
 # ---
 # * GSL::Sf::multiply_e(x, y)
 #
-#   This method multiplies <tt>x</tt> and <tt>y</tt> and returns
+#   This method multiplies <tt>x</tt> and <tt>y</tt> and returns
 #   the product as a <tt>GSL::Sf::Result</tt> object.
 # ---
 # * GSL::Sf::multiply_err_e(x, dx, y, dy)
 #
-#   This method multiplies <tt>x</tt> and <tt>y</tt> with associated absolute
-#   errors <tt>dx</tt> and <tt>dy</tt>,  and returns
+#   This method multiplies <tt>x</tt> and <tt>y</tt> with associated absolute
+#   errors <tt>dx</tt> and <tt>dy</tt>,  and returns
 #   the product as a <tt>GSL::Sf::Result</tt> object.
 #
-# == {}[link:index.html"name="13] Elliptic Integrals
-# === {}[link:index.html"name="13.1] Legendre Form of Complete Elliptic Integrals
+# == Elliptic Integrals
+# === Legendre Form of Complete Elliptic Integrals
 # ---
 # * GSL::Sf::ellint_Kcomp(k, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the complete elliptic integral K(k)
+#   Computes the complete elliptic integral K(k)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
 # ---
 # * GSL::Sf::ellint_Ecomp(k, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the complete elliptic integral E(k)
+#   Computes the complete elliptic integral E(k)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
-# === {}[link:index.html"name="13.2] Legendre Form of Incomplete Elliptic Integrals
+# === Legendre Form of Incomplete Elliptic Integrals
 # ---
 # * GSL::Sf::ellint_F(phi, k, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the incomplete elliptic integral E(phi, k)
+#   Computes the incomplete elliptic integral E(phi, k)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
 # ---
 # * GSL::Sf::ellint_P(phi, k, n, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the incomplete elliptic integral P(phi, k, n)
+#   Computes the incomplete elliptic integral P(phi, k, n)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
 # ---
 # * GSL::Sf::ellint_D(phi, k, n, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the incomplete elliptic integral D(phi, k, n)
+#   Computes the incomplete elliptic integral D(phi, k, n)
 #   which is defined through the Carlson form RD(x, y, z) by the following relation,
 #      D(phi, k, n) = RD (1-sin^2(phi), 1-k^2 sin^2(phi), 1).
-# === {}[link:index.html"name="13.3] Carlson Forms
+# === Carlson Forms
 # ---
 # * GSL::Sf::ellint_RC(x, y, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the incomplete elliptic integral RC(x, y)
+#   Computes the incomplete elliptic integral RC(x, y)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
 # ---
 # * GSL::Sf::ellint_RD(x, y, z, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the incomplete elliptic integral RD(x, y, z)
+#   Computes the incomplete elliptic integral RD(x, y, z)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
 # ---
 # * GSL::Sf::ellint_RF(x, y, z, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the incomplete elliptic integral RF(x, y, z)
+#   Computes the incomplete elliptic integral RF(x, y, z)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
 # ---
 # * GSL::Sf::ellint_RJ(x, y, z, p, mode = GSL::PREC_DOUBLE)
 #
-#   Computes the incomplete elliptic integral RJ(x, y, z, p)
+#   Computes the incomplete elliptic integral RJ(x, y, z, p)
 #   to the accuracy specified by the mode variable <tt>mode</tt>.
 #
-# == {}[link:index.html"name="14] Elliptic Functions (Jacobi)
+# == Elliptic Functions (Jacobi)
 # ---
 # * GSL::Sf::gsl_sf_elljac(u, m)
 # * GSL::Sf::gsl_sf_elljac_e(u, m)
 #
-#   These methods compute the Jacobian elliptic functions
+#   These methods compute the Jacobian elliptic functions
 #   sn(u|m), cn(u|m), dn(u|m) by descending Landen transformations,
 #   and returns the result as an array of 3 elements.
 #
-# == {}[link:index.html"name="15] Error Functions
+# == Error Functions
 # ---
 # * GSL::Sf::erf(x)
 #
@@ -765,7 +765,7 @@
 # * GSL::Sf::log_erfc(x)
 #
 #   Computes the logarithm of the complementary error function log(erfc(x)).
-# === {}[link:index.html"name="15.1] Probability functions
+# === Probability functions
 # ---
 # * GSL::Sf::erf_Z(x)
 #
@@ -774,70 +774,70 @@
 # ---
 # * GSL::Sf::erf_Q(x)
 #
-#   Computes the upper tail of the Gaussian probability function
+#   Computes the upper tail of the Gaussian probability function
 #   Q(x) = (1/sqrt{2 pi}) int_x^infty dt exp(-t^2/2).
 # ---
 # * GSL::Sf::hazard(x)
 #
 #   The hazard function for the normal distribution, also known as
-#   the inverse Mill's ratio, is defined as
-#   h(x) = Z(x)/Q(x) = sqrt{2/pi exp(-x^2 / 2) / erfc(x/sqrt 2)}.
-#   It decreases rapidly as x approaches -infty and asymptotes to h(x) sim x
+#   the inverse Mill's ratio, is defined as
+#   h(x) = Z(x)/Q(x) = sqrt{2/pi exp(-x^2 / 2) / erfc(x/sqrt 2)}.
+#   It decreases rapidly as x approaches -infty and asymptotes to h(x) sim x
 #   as x approaches +infty.
 #
-# == {}[link:index.html"name="16] Exponential Functions
+# == Exponential Functions
 # ---
 # * GSL::Sf::exp(x)
 # * GSL::Sf::exp_e(x)
 #
-#   These methods provide an exponential function exp(x)
+#   These methods provide an exponential function exp(x)
 #   using GSL semantics and error checking.
 # ---
 # * GSL::Sf::exp_e10_e(x)
 #
-#   This method computes the exponential exp(x) using the
-#   <tt>GSL::Sf::Result_e10</tt> type to return a result with extended range.
-#   This may be useful if the value of exp(x) would overflow the numeric
+#   This method computes the exponential exp(x) using the
+#   <tt>GSL::Sf::Result_e10</tt> type to return a result with extended range.
+#   This may be useful if the value of exp(x) would overflow the numeric
 #   range of <tt>double</tt>.
 # ---
 # * GSL::Sf::exp_mult(x, y)
 # * GSL::Sf::exp_mult_e(x, y)
 # * GSL::Sf::exp_mult_e10_e(x, y)
 #
-#   Exponentiate <tt>x</tt> and multiply by the factor
+#   Exponentiate <tt>x</tt> and multiply by the factor
 #   <tt>y</tt> to return the product y exp(x).
 #
-# === {}[link:index.html"name="16.1] Relative Exponential Functions
+# === Relative Exponential Functions
 # ---
 # * GSL::Sf::expm1(x)
 #
-#   Computes the quantity exp(x)-1 using an algorithm that is
+#   Computes the quantity exp(x)-1 using an algorithm that is
 #   accurate for small <tt>x</tt>.
 # ---
 # * GSL::Sf::exprel(x)
 #
-#   Computes the quantity (exp(x)-1)/x using an algorithm that is
-#   accurate for small <tt>x</tt>. For small <tt>x</tt> the algorithm is
-#   based on the expansion
+#   Computes the quantity (exp(x)-1)/x using an algorithm that is
+#   accurate for small <tt>x</tt>. For small <tt>x</tt> the algorithm is
+#   based on the expansion
 #   (exp(x)-1)/x = 1 + x/2 + x^2/(2*3) + x^3/(2*3*4) + ... .
 # ---
 # * GSL::Sf::exprel_2(x)
 #
-#   Computes the quantity 2(exp(x)-1-x)/x^2 using an algorithm that is
-#   accurate for small <tt>x</tt>. For small <tt>x</tt> the algorithm is based
-#   on the expansion
+#   Computes the quantity 2(exp(x)-1-x)/x^2 using an algorithm that is
+#   accurate for small <tt>x</tt>. For small <tt>x</tt> the algorithm is based
+#   on the expansion
 #   2(exp(x)-1-x)/x^2 = 1 + x/3 + x^2/(3*4) + x^3/(3*4*5) + ... .
 # ---
 # * GSL::Sf::exprel_n(n, x)
 #
-#   Computes the N-relative exponential, which is the <tt>n</tt>-th
-#   generalization of the methods <tt>exprel</tt> and <tt>exprel2</tt>.
+#   Computes the N-relative exponential, which is the <tt>n</tt>-th
+#   generalization of the methods <tt>exprel</tt> and <tt>exprel2</tt>.
 #   The N-relative exponential is given by,
 #      exprel_N(x) = N!/x^N (exp(x) - sum_{k=0}^{N-1} x^k/k!)
 #                  = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ...
 #                  = 1F1 (1,1+N,x)
 #
-# === {}[link:index.html"name="16.2] Exponentiation With Error Estimate
+# === Exponentiation With Error Estimate
 # ---
 # * GSL::Sf::exp_err_e(x, dx)
 #
@@ -845,23 +845,23 @@
 # ---
 # * GSL::Sf::exp_err_e10_e(x, dx)
 #
-#   Exponentiates a quantity <tt>x</tt> with an associated absolute error
-#   <tt>dx</tt> using the <tt>GSL::Sf::Result_e10</tt> type
+#   Exponentiates a quantity <tt>x</tt> with an associated absolute error
+#   <tt>dx</tt> using the <tt>GSL::Sf::Result_e10</tt> type
 #   to return a result with extended range.
 # ---
 # * GSL::Sf::exp_mult_err_e(x, dx, y, dy)
 #
-#   Computes the product y exp(x) for the quantities <tt>x, y</tt>
+#   Computes the product y exp(x) for the quantities <tt>x, y</tt>
 #   with associated absolute errors <tt>dx, dy</tt>.
 # ---
 # * GSL::Sf::exp_mult_err_e10_e(x, dx, y, dy)
 #
-#   Computes the product y exp(x) for the quantities <tt>x, y</tt>
-#   with associated absolute errors <tt>dx, dy</tt>  using the
+#   Computes the product y exp(x) for the quantities <tt>x, y</tt>
+#   with associated absolute errors <tt>dx, dy</tt>  using the
 #   <tt>GSL::Sf::Result_e10</tt> type to return a result with extended range.
 #
-# == {}[link:index.html"name="17] Exponential Integrals
-# === {}[link:index.html"name="17.1] Exponential Integral
+# == Exponential Integrals
+# === Exponential Integral
 # ---
 # * GSL::Sf::expint_E1(x)
 #
@@ -877,14 +877,14 @@
 #
 #   Computes the exponential integral E_n(n, x) of order <tt>n</tt>. (>= GSL-1.10)
 #
-# === {}[link:index.html"name="17.2] Ei(x)
+# === Ei(x)
 # ---
 # * GSL::Sf::expint_Ei(x)
 #
 #   Computes the exponential integral E_i(x),
 #        Ei(x) := - PV(int_{-x}^infty dt exp(-t)/t)
 #   where PV denotes the principal value of the integral.
-# === {}[link:index.html"name="17.3] Hyperbolic Integrals
+# === Hyperbolic Integrals
 # ---
 # * GSL::Sf::Shi(x)
 #
@@ -892,16 +892,16 @@
 # ---
 # * GSL::Sf::Chi(x)
 #
-#   Computes the integral
-#      Chi(x) := Re[ gamma_E + log(x) + int_0^x dt (cosh[t]-1)/t] ,
-#   where gamma_E is the Euler constant
+#   Computes the integral
+#      Chi(x) := Re[ gamma_E + log(x) + int_0^x dt (cosh[t]-1)/t] ,
+#   where gamma_E is the Euler constant
 #   (available as the constant <tt>GSL::M_EULER</tt>).
-# === {}[link:index.html"name="17.4] Ei_3(x)
+# === Ei_3(x)
 # ---
 # * GSL::Sf::expint_3(x)
 #
 #   Computes the exponential integral Ei_3(x) = int_0^x dt exp(-t^3) for x >= 0
-# === {}[link:index.html"name="17.5] Trigonometric Integrals
+# === Trigonometric Integrals
 # ---
 # * GSL::Sf::Si(x)
 #
@@ -910,41 +910,41 @@
 # * GSL::Sf::Ci(x)
 #
 #   Computes the Cosine integral Ci(x) = -int_x^infty dt cos(t)/t for x > 0.
-# === {}[link:index.html"name="17.6] Arctangent Integral
+# === Arctangent Integral
 # ---
 # * GSL::Sf::atanint(x)
 #
 #   Computes the Arctangent integral AtanInt(x) = int_0^x dt arctan(t)/t.
 #
-# == {}[link:index.html"name="18] Fermi-Dirac Functions
-# === {}[link:index.html"name="18.1] Complete Fermi-Dirac Integrals
+# == Fermi-Dirac Functions
+# === Complete Fermi-Dirac Integrals
 # The complete Fermi-Dirac integral F_j(x) is given by,
 #     F_j(x)   := (1/r Gamma(j+1)) int_0^infty dt (t^j / (exp(t-x) + 1))
 #
 # ---
 # * GSL::Sf::fermi_dirac_m1(x)
 #
-#   Computes the complete Fermi-Dirac integral with an index of -1.
+#   Computes the complete Fermi-Dirac integral with an index of -1.
 #   This integral is given by F_{-1}(x) = e^x / (1 + e^x).
 # ---
 # * GSL::Sf::fermi_dirac_0(x)
 #
-#   Computes the complete Fermi-Dirac integral with an index of 0. This
+#   Computes the complete Fermi-Dirac integral with an index of 0. This
 #   integral is given by F_0(x) = ln(1 + e^x).
 # ---
 # * GSL::Sf::fermi_dirac_1(x)
 #
-#   Compute the complete Fermi-Dirac integral with an index of 1,
+#   Compute the complete Fermi-Dirac integral with an index of 1,
 #   F_1(x) = int_0^infty dt (t /(exp(t-x)+1)).
 # ---
 # * GSL::Sf::fermi_dirac_2(x)
 #
-#   Computes the complete Fermi-Dirac integral with an index of 2,
+#   Computes the complete Fermi-Dirac integral with an index of 2,
 #   F_2(x) = (1/2) int_0^infty dt (t^2 /(exp(t-x)+1)).
 # ---
 # * GSL::Sf::fermi_dirac_int(j, x)
 #
-#   Computes the complete Fermi-Dirac integral with an integer index of
+#   Computes the complete Fermi-Dirac integral with an integer index of
 #   <tt>j</tt>, F_j(x) = (1/Gamma(j+1)) int_0^infty dt (t^j /(exp(t-x)+1)).
 # ---
 # * GSL::Sf::fermi_dirac_mhalf(x)
@@ -958,47 +958,47 @@
 # * GSL::Sf::fermi_dirac_3half(x)
 #
 #   Computes the complete Fermi-Dirac integral F_{3/2}(x).
-# === {}[link:index.html"name="18.2] Incomplete Fermi-Dirac Integrals
+# === Incomplete Fermi-Dirac Integrals
 # ---
 # * GSL::Sf::fermi_dirac_inc_0(x, b)
 #
-#   Computes the incomplete Fermi-Dirac integral with an index of zero,
+#   Computes the incomplete Fermi-Dirac integral with an index of zero,
 #   F_0(x,b) = ln(1 + e^{b-x}) - (b-x).
 #
-# == {}[link:index.html"name="19] Gamma Function
+# == Gamma Function
 # The Gamma function is defined by the following integral,
 #    Gamma(x) = int_0^infty dt  t^{x-1} exp(-t)
-# Further information on the Gamma function can be found in
-# Abramowitz & Stegun, Chapter 6.
+# Further information on the Gamma function can be found in
+# Abramowitz & Stegun, Chapter 6.
 #
 # ---
 # * GSL::Sf::gamma(x)
 #
-#   Computes the Gamma function, subject to <tt>x</tt> not being a
-#   negative integer. The function is computed using the real
-#   Lanczos method. The maximum value of <tt>x</tt> such that Gamma(x) is
+#   Computes the Gamma function, subject to <tt>x</tt> not being a
+#   negative integer. The function is computed using the real
+#   Lanczos method. The maximum value of <tt>x</tt> such that Gamma(x) is
 #   not considered an overflow is given by the constant
 #   <tt>GSL::Sf::GAMMA_XMAX</tt> and is 171.0.
 # ---
 # * GSL::Sf::lngamma(x)
 #
-#   Computes the logarithm of the Gamma function, log(Gamma(x)),
-#   subject to <tt>x</tt> not a being negative integer.
-#   For x<0 the real part of log(Gamma(x)) is returned,
-#   which is equivalent to log(|Gamma(x)|).
+#   Computes the logarithm of the Gamma function, log(Gamma(x)),
+#   subject to <tt>x</tt> not a being negative integer.
+#   For x<0 the real part of log(Gamma(x)) is returned,
+#   which is equivalent to log(|Gamma(x)|).
 #   The function is computed using the real Lanczos method.
 # ---
 # * GSL::Sf::lngamma_sgn_e(x)
 #
-#   Computes the sign of the gamma function and the logarithm its magnitude,
+#   Computes the sign of the gamma function and the logarithm its magnitude,
 #   subject to <tt>x</tt> not being a negative integer, and returns the result
-#   as an array of 2 elements, <tt>[result, sng]</tt>. The function is computed
-#   using the real Lanczos method. The value of the gamma function can be
+#   as an array of 2 elements, <tt>[result, sng]</tt>. The function is computed
+#   using the real Lanczos method. The value of the gamma function can be
 #   reconstructed using the relation Gamma(x) = sgn * exp(result).
 # ---
 # * GSL::Sf::gammastar(x)
 #
-#   Computes the regulated Gamma Function Gamma^*(x) for x > 0.
+#   Computes the regulated Gamma Function Gamma^*(x) for x > 0.
 #   The regulated gamma function is given by,
 #      Gamma^*(x) = Gamma(x)/(sqrt{2 pi} x^{(x-1/2)} exp(-x))
 #                 = (1 + (1/12x) + ...)  for x -> infty
@@ -1010,13 +1010,13 @@
 # ---
 # * GSL::Sf::ngamma_complex_e(zr, zi)
 #
-#   These method compute log(Gamma(z)) for complex z = zr + i zi and z not a
-#   negative integer,
-#   using the complex Lanczos method. The result is returned as an array of
-#   2 elements, <tt>[lnr, arg, status]</tt>, where lnr = log|Gamma(z)| and arg = arg(Gamma(z))
-#   in (-pi,pi]. Note that the phase part (arg) is not well-determined when
-#   |z| is very large, due to inevitable roundoff in restricting to (-pi,pi].
-#   This will result in a <tt>GSL::ELOSS</tt> error when it occurs.
+#   These method compute log(Gamma(z)) for complex z = zr + i zi and z not a
+#   negative integer,
+#   using the complex Lanczos method. The result is returned as an array of
+#   2 elements, <tt>[lnr, arg, status]</tt>, where lnr = log|Gamma(z)| and arg = arg(Gamma(z))
+#   in (-pi,pi]. Note that the phase part (arg) is not well-determined when
+#   |z| is very large, due to inevitable roundoff in restricting to (-pi,pi].
+#   This will result in a <tt>GSL::ELOSS</tt> error when it occurs.
 #   The absolute value part (lnr), however, never suffers from loss of precision.
 # ---
 # * GSL::Sf::taylorcoeff(n, x)
@@ -1025,7 +1025,7 @@
 # ---
 # * GSL::Sf::fact(n)
 #
-#   Computes the factorial n!. The factorial is related to the
+#   Computes the factorial n!. The factorial is related to the
 #   Gamma function by n! = Gamma(n+1).
 # ---
 # * GSL::Sf::doublefact(n)
@@ -1034,8 +1034,8 @@
 # ---
 # * GSL::Sf::lnfact(n)
 #
-#   Computes the logarithm of the factorial of <tt>n</tt>, log(n!).
-#   The algorithm is faster than computing ln(Gamma(n+1)) via
+#   Computes the logarithm of the factorial of <tt>n</tt>, log(n!).
+#   The algorithm is faster than computing ln(Gamma(n+1)) via
 #   <tt>GSL::Sf::lngamma</tt> for n < 170, but defers for larger n.
 # ---
 # * GSL::Sf::lndoublefact(n)
@@ -1048,18 +1048,18 @@
 # ---
 # * GSL::Sf::lnchoose(n, m)
 #
-#   Computes the logarithm of n choose m.
+#   Computes the logarithm of n choose m.
 #   This is equivalent to the sum log(n!) - log(m!) - log((n-m)!).
 # ---
 # * GSL::Sf::poch(a, x)
 #
-#   Computes the Pochhammer symbol (a)_x := Gamma(a + x)/Gamma(a),
-#   subject to <tt>a</tt> and <tt>a+x</tt> not being negative integers.
+#   Computes the Pochhammer symbol (a)_x := Gamma(a + x)/Gamma(a),
+#   subject to <tt>a</tt> and <tt>a+x</tt> not being negative integers.
 #   The Pochhammer symbol is also known as the Apell symbol.
 # ---
 # * GSL::Sf::lnpoch(a, x)
 #
-#   Computes the logarithm of the Pochhammer symbol,
+#   Computes the logarithm of the Pochhammer symbol,
 #   log((a)_x) = log(Gamma(a + x)/Gamma(a)) for a > 0, a+x > 0.
 # ---
 # * GSL::Sf::lnpoch_sgn_e(a, x)
@@ -1077,19 +1077,19 @@
 # ---
 # * GSL::Sf::gamma_inc_Q(a, x)
 #
-#   Computes the normalized incomplete Gamma Function
+#   Computes the normalized incomplete Gamma Function
 #   Q(a,x) = 1/Gamma(a) int_x^infty dt t^{a-1} exp(-t) for a > 0, x >= 0.
 # ---
 # * GSL::Sf::gamma_inc_P(a, x)
 #
-#   Computes the complementary normalized incomplete Gamma Function
+#   Computes the complementary normalized incomplete Gamma Function
 #   P(a,x) = 1/Gamma(a) int_0^x dt t^{a-1} exp(-t) for a > 0, x >= 0.
 #   Note that Abramowitz & Stegun call P(a,x) the incomplete gamma function (section 6.5).
 # ---
 # * GSL::Sf::gamma_inc(a, x)
 #
-#   Computes the incomplete Gamma Function the normalization factor included
-#   in the previously defined functions:
+#   Computes the incomplete Gamma Function the normalization factor included
+#   in the previously defined functions:
 #   Gamma(a,x) = int_x^infty dt t^{a-1} exp(-t) for a real and x >= 0.
 # ---
 # * GSL::Sf::beta(a, b)
@@ -1102,31 +1102,31 @@
 # ---
 # * GSL::Sf::beta_inc(a, b, x)
 #
-#   Computes the normalize incomplete Beta function
+#   Computes the normalize incomplete Beta function
 #   B_x(a,b)/B(a,b) for a > 0, b > 0, and 0 <= x <= 1.
 #
-# == {}[link:index.html"name="20] Gegenbauer Functions
+# == Gegenbauer Functions
 # ---
 # * GSL::Sf::gegenpoly_1(lambda, x)
 # * GSL::Sf::gegenpoly_2(lambda, x)
 # * GSL::Sf::gegenpoly_3(lambda, x)
 #
-#   These methods evaluate the Gegenbauer polynomials
+#   These methods evaluate the Gegenbauer polynomials
 #   C^{(lambda)}_n(x) using explicit representations for n =1, 2, 3.
 # ---
 # * GSL::Sf::gegenpoly_n(n, lambda, x)
 #
-#   This evaluates the Gegenbauer polynomial
-#   C^{(lambda)}_n(x) for a specific value of <tt>n, lambda, x</tt>
+#   This evaluates the Gegenbauer polynomial
+#   C^{(lambda)}_n(x) for a specific value of <tt>n, lambda, x</tt>
 #   subject to lambda > -1/2, n >= 0.
 # ---
 # * GSL::Sf::gegenpoly_array(nmax, lambda, x)
 #
-#   This method computes Gegenbauer polynomials C^{(lambda)}_n(x)
+#   This method computes Gegenbauer polynomials C^{(lambda)}_n(x)
 #   for n = 0, 1, 2, ..., nmax, subject to lambda > -1/2, nmax >= 0.
 #   The result is returned as a <tt>GSL::Vector</tt> object.
 #
-# == {}[link:index.html"name="21] Hypergeometric Functions
+# == Hypergeometric Functions
 # ---
 # * GSL::Sf::hyperg_0F1(c, x)
 #
@@ -1134,23 +1134,23 @@
 # ---
 # * GSL::Sf::hyperg_1F1_int(m, n, x)
 #
-#   Computes the confluent hypergeometric function 1F1(m,n,x) = M(m,n,x)
+#   Computes the confluent hypergeometric function 1F1(m,n,x) = M(m,n,x)
 #   for integer parameters <tt>m, n</tt>.
 # ---
 # * GSL::Sf::hyperg_1F1(a, b, x)
 #
-#   Computes the confluent hypergeometric function 1F1(a,b,x) = M(a,b,x)
+#   Computes the confluent hypergeometric function 1F1(a,b,x) = M(a,b,x)
 #   for general parameters <tt>a, b</tt>.
 # ---
 # * GSL::Sf::hyperg_U_int(m, n, x)
 #
-#   Computes the confluent hypergeometric function U(m,n,x) for integer parameters
+#   Computes the confluent hypergeometric function U(m,n,x) for integer parameters
 #   <tt>m, n</tt>.
 # ---
 # * GSL::Sf::hyperg_U_int_e10_e(m, n, x)
 #
-#   Computes the confluent hypergeometric function U(m,n,x)
-#   for integer parameters <tt>m, n</tt> using the <tt>GSL::Sf::Result_e10</tt>
+#   Computes the confluent hypergeometric function U(m,n,x)
+#   for integer parameters <tt>m, n</tt> using the <tt>GSL::Sf::Result_e10</tt>
 #   type to return a result with extended range.
 # ---
 # * GSL::Sf::hyperg_U(a, b, x)
@@ -1159,60 +1159,60 @@
 # ---
 # * GSL::Sf::hyperg_U_e10_e(a, b, x)
 #
-#   Computes the confluent hypergeometric function U(a,b,x)
+#   Computes the confluent hypergeometric function U(a,b,x)
 #   using the <tt>GSL::Sf::Result_e10</tt>  type to return a result with extended range.
 # ---
 # * GSL::Sf::hyperg_2F1(a, b, c, x)
 # * GSL::Sf::hyperg_2F1_e(a, b, c, x)
 #
 #   These methods compute the Gauss hypergeometric function 2F1(a,b,c,x) for |x| < 1.
-#   If the arguments (a,b,c,x) are too close to a singularity then the
-#   function can return the error code <tt>GSL::EMAXITER</tt> when the series
-#   approximation converges too slowly. This occurs in the region of
+#   If the arguments (a,b,c,x) are too close to a singularity then the
+#   function can return the error code <tt>GSL::EMAXITER</tt> when the series
+#   approximation converges too slowly. This occurs in the region of
 #   x=1, c - a - b = m for integer m.
 # ---
 # * GSL::Sf::hyperg_2F1_conj(aR, aI, c, x)
 #
-#   Computes the Gauss hypergeometric function 2F1(a_R + i a_I, a_R - i a_I, c, x)
-#   with complex parameters for |x| < 1.
+#   Computes the Gauss hypergeometric function 2F1(a_R + i a_I, a_R - i a_I, c, x)
+#   with complex parameters for |x| < 1.
 # ---
 # * GSL::Sf::hyperg_2F1_renorm(a, b, c, x)
 #
-#   Computes the renormalized Gauss hypergeometric function
+#   Computes the renormalized Gauss hypergeometric function
 #   2F1(a,b,c,x) / Gamma(c) for |x| < 1.
 # ---
 # * GSL::Sf::hyperg_2F1_renorm(aR, aI, c, x)
 #
-#   Computes the renormalized Gauss hypergeometric function
+#   Computes the renormalized Gauss hypergeometric function
 #   2F1(a_R + i a_I, a_R - i a_I, c, x) / Gamma(c) for |x| < 1.
 # ---
 # * GSL::Sf::hyperg_2F0(a, b, x)
 #
-#   Computes the hypergeometric function 2F0(a,b,x).
-#   The series representation is a divergent hypergeometric series.
+#   Computes the hypergeometric function 2F0(a,b,x).
+#   The series representation is a divergent hypergeometric series.
 #   However, for x < 0 we have 2F0(a,b,x) = (-1/x)^a U(a,1+a-b,-1/x).
 #
-# == {}[link:index.html"name="22] Laguerre Functions
-# The Laguerre polynomials are defined in terms of confluent hypergeometric
+# == Laguerre Functions
+# The Laguerre polynomials are defined in terms of confluent hypergeometric
 # functions as L^a_n(x) = ((a+1)_n / n!) 1F1(-n,a+1,x).
 # ---
 # * GSL::Sf::laguerre_1(a, x)
 # * GSL::Sf::laguerre_2(a, x)
 # * GSL::Sf::laguerre_3(a, x)
 #
-#   These methods evaluate the generalized Laguerre polynomials
+#   These methods evaluate the generalized Laguerre polynomials
 #   L^a_1(x), L^a_2(x), L^a_3(x) using explicit representations.
 # ---
 # * GSL::Sf::laguerre_n(n, a, x)
 #
 #   This evaluates the generalized Laguerre polynomials L^a_n(x) for a > -1, n >= 0.
 #
-# == {}[link:index.html"name="23] Lambert W Functions
-# Lambert's W functions, W(x), are defined to be solutions of the equation
-# W(x) exp(W(x)) = x. This function has multiple branches for x < 0;
-# however, it has only two real-valued branches.
-# We define W_0(x) to be the principal branch,
-# where W > -1 for x < 0, and W_{-1}(x) to be the other real branch, where W < -1 for x < 0.
+# == Lambert W Functions
+# Lambert's W functions, W(x), are defined to be solutions of the equation
+# W(x) exp(W(x)) = x. This function has multiple branches for x < 0;
+# however, it has only two real-valued branches.
+# We define W_0(x) to be the principal branch,
+# where W > -1 for x < 0, and W_{-1}(x) to be the other real branch, where W < -1 for x < 0.
 #
 # ---
 # * GSL::Sf::lambert_W0(x)
@@ -1223,24 +1223,24 @@
 #
 #   This computes the secondary real-valued branch of the Lambert W function, W_{-1}(x).
 #
-# == {}[link:index.html"name="24] Legendre Functions and Spherical Harmonics
-# === {}[link:index.html"name="24.1] Legendre Polynomials
+# == Legendre Functions and Spherical Harmonics
+# === Legendre Polynomials
 # ---
 # * GSL::Sf::legendre_P1(x)
 # * GSL::Sf::legendre_P2(x)
 # * GSL::Sf::legendre_P3(x)
 #
-#   These methods evaluate the Legendre polynomials P_l(x) using explicit
+#   These methods evaluate the Legendre polynomials P_l(x) using explicit
 #   representations for l=1, 2, 3.
 # ---
 # * GSL::Sf::legendre_Pl(l, x)
 #
-#   This evaluates the Legendre polynomial P_l(x) for a specific value of <tt>l, x</tt>,
+#   This evaluates the Legendre polynomial P_l(x) for a specific value of <tt>l, x</tt>,
 #   subject to l >= 0, |x| <= 1.
 # ---
 # * GSL::Sf::legendre_Pl_array(lmax, x)
 #
-#   This function computes Legendre polynomials P_l(x) for l = 0, ..., lmax,
+#   This function computes Legendre polynomials P_l(x) for l = 0, ..., lmax,
 #   and returns the result as a <tt>GSL::Vector</tt> object.
 # ---
 # * GSL::Sf::legendre_Q0(x)
@@ -1255,62 +1255,62 @@
 #
 #   This computes the Legendre function Q_l(x) for x > -1, x != 1 and l >= 0.
 #
-# === {}[link:index.html"name="24.2] Associated Legendre Polynomials and Spherical Harmonics
-# The following functions compute the associated Legendre Polynomials P_l^m(x).
-# Note that this function grows combinatorially with <tt>l</tt> and can overflow for
-# <tt>l</tt> larger than about 150. There is no trouble for small <tt>m</tt>,
-# but overflow occurs when <tt>m</tt> and <tt>l</tt> are both large.
-# Rather than allow overflows, these functions refuse to calculate P_l^m(x)
+# === Associated Legendre Polynomials and Spherical Harmonics
+# The following functions compute the associated Legendre Polynomials P_l^m(x).
+# Note that this function grows combinatorially with <tt>l</tt> and can overflow for
+# <tt>l</tt> larger than about 150. There is no trouble for small <tt>m</tt>,
+# but overflow occurs when <tt>m</tt> and <tt>l</tt> are both large.
+# Rather than allow overflows, these functions refuse to calculate P_l^m(x)
 # and return <tt>GSL::EOVRFLW</tt> when they can sense that <tt>l</tt> and <tt>m</tt> are too big.
-# If you want to calculate a spherical harmonic, then do not use these functions.
-# Instead use <tt>GSL::Sf::legendre_sphPlm()</tt> below,
+# If you want to calculate a spherical harmonic, then do not use these functions.
+# Instead use <tt>GSL::Sf::legendre_sphPlm()</tt> below,
 # which uses a similar recursion, but with the normalized functions.
 #
 # ---
 # * GSL::Sf::legendre_Plm(l, m, x)
 # * GSL::Sf::legendre_Plm_e(l, m, x)
 #
-#   These methods compute the associated Legendre polynomial
+#   These methods compute the associated Legendre polynomial
 #   P_l^m(x) for m >= 0, l >= m, |x| <= 1.
 # ---
 # * GSL::Sf::legendre_Plm_array(lmax, m, x)
 #
-#   This method computes Legendre polynomials P_l^m(x) for m >= 0, l = |m|, ..., lmax,
+#   This method computes Legendre polynomials P_l^m(x) for m >= 0, l = |m|, ..., lmax,
 #   |x| <= 1, and returns the result as a <tt>GSL::Vector</tt> object.
 # ---
 # * GSL::Sf::legendre_sphPlm(l, m, x)
 # * GSL::Sf::legendre_sphPlm_e(l, m, x)
 #
-#   These methods compute the normalized associated Legendre polynomial
-#   sqrt{(2l+1)/(4pi)} sqrt{(l-m)!/(l+m)!} P_l^m(x)
-#   suitable for use in spherical harmonics. The parameters must satisfy
-#   m >= 0, l >= m, |x| <= 1. Theses routines avoid the overflows that
+#   These methods compute the normalized associated Legendre polynomial
+#   sqrt{(2l+1)/(4pi)} sqrt{(l-m)!/(l+m)!} P_l^m(x)
+#   suitable for use in spherical harmonics. The parameters must satisfy
+#   m >= 0, l >= m, |x| <= 1. Theses routines avoid the overflows that
 #   occur for the standard normalization of P_l^m(x).
 # ---
 # * GSL::Sf::legendre_sphPlm_array(lmax, m, x)
 #
-#   This method computes an array of normalized associated Legendre functions
-#   sqrt{(2l+1)/(4pi)} sqrt{(l-m)!/(l+m)!} P_l^m(x)$ for m >= 0, l = |m|, ..., lmax,
+#   This method computes an array of normalized associated Legendre functions
+#   sqrt{(2l+1)/(4pi)} sqrt{(l-m)!/(l+m)!} P_l^m(x)$ for m >= 0, l = |m|, ..., lmax,
 #   |x| <= 1.0, and returns the result as a <tt>GSL::Vector</tt> object.
 # ---
 # * GSL::Sf::legendre_array_size(lmax, m)
 #
-#   This returns the size of resulting array needed for the array versions
+#   This returns the size of resulting array needed for the array versions
 #   of P_l^m(x), lmax - m + 1.
 #
-# === {}[link:index.html"name="24.3] Conical Functions
-# The Conical Functions P^mu_{-(1/2)+i lambda}(x), Q^mu_{-(1/2)+i lambda}
+# === Conical Functions
+# The Conical Functions P^mu_{-(1/2)+i lambda}(x), Q^mu_{-(1/2)+i lambda}
 # are described in Abramowitz & Stegun, Section 8.12.
 #
 # ---
 # * GSL::Sf::conicalP_half(lambda, x)
 #
-#   Computes the irregular Spherical Conical Function
+#   Computes the irregular Spherical Conical Function
 #   P^{1/2}_{-1/2 + i lambda}(x) for x > -1.
 # ---
 # * GSL::Sf::conicalP_mhalf(lambda, x)
 #
-#   Computes the regular Spherical Conical Function
+#   Computes the regular Spherical Conical Function
 #   P^{-1/2}_{-1/2 + i lambda}(x) for x > -1.
 # ---
 # * GSL::Sf::conicalP_0(lambda, x)
@@ -1321,7 +1321,7 @@
 # ---
 # * GSL::Sf::conicalP_sph_reg(l, lambda, x)
 #
-#   Computes the Regular Spherical Conical Function
+#   Computes the Regular Spherical Conical Function
 #   P^{-1/2-l}_{-1/2 + i lambda}(x) for x > -1, l >= -1.
 # ---
 # * GSL::Sf::conicalP_cyc_reg(m, lambda, x)
@@ -1329,29 +1329,29 @@
 #   Computes the Regular Cylindrical Conical Function
 #   P^{-m}_{-1/2 + i lambda}(x) for x > -1, m >= -1.
 #
-# === {}[link:index.html"name="24.4] Radial Functions for Hyperbolic Space
-# The following spherical functions are specializations of Legendre functions which
-# give the regular eigenfunctions of the Laplacian on a 3-dimensional hyperbolic space
+# === Radial Functions for Hyperbolic Space
+# The following spherical functions are specializations of Legendre functions which
+# give the regular eigenfunctions of the Laplacian on a 3-dimensional hyperbolic space
 # H3d. Of particular interest is the flat limit, lambda to infty, eta to 0, lambda eta fixed.
 # ---
 # * GSL::Sf::legendre_H3d_0(lambda, eta)
 #
-#   Computes the zeroth radial eigenfunction of the Laplacian on the 3-dimensional
-#   hyperbolic space, L^{H3d}_0(lambda,eta) := sin(lambda eta)/(lambda sinh(eta))
-#   for eta >= 0. In the flat limit this takes the form
+#   Computes the zeroth radial eigenfunction of the Laplacian on the 3-dimensional
+#   hyperbolic space, L^{H3d}_0(lambda,eta) := sin(lambda eta)/(lambda sinh(eta))
+#   for eta >= 0. In the flat limit this takes the form
 #   L^{H3d}_0(lambda, eta) = j_0( lambda eta).
 # ---
 # * GSL::Sf::legendre_H3d_1(lambda, eta)
 #
-#   Computes the first radial eigenfunction of the Laplacian on the 3-dimensional
-#   hyperbolic space,
-#   L^{H3d}_1(lambda, eta) := 1/sqrt{lambda^2 + 1} sin(lambda eta)/(lambda sinh(eta)) (coth(eta) - lambda cot(lambda eta)) for eta >= 0.
+#   Computes the first radial eigenfunction of the Laplacian on the 3-dimensional
+#   hyperbolic space,
+#   L^{H3d}_1(lambda, eta) := 1/sqrt{lambda^2 + 1} sin(lambda eta)/(lambda sinh(eta)) (coth(eta) - lambda cot(lambda eta)) for eta >= 0.
 #   In the flat limit this takes the form L^{H3d}_1(lambda, eta) = j_1( lambda eta).
 # ---
 # * GSL::Sf::legendre_H3d(l, lambda, eta)
 #
-#   Computes the <tt>l</tt>-th radial eigenfunction of the Laplacian on the
-#   3-dimensional hyperbolic space eta >= 0, l >= 0.
+#   Computes the <tt>l</tt>-th radial eigenfunction of the Laplacian on the
+#   3-dimensional hyperbolic space eta >= 0, l >= 0.
 #   In the flat limit this takes the form L^{H3d}_l(lambda, eta) = j_l(lambda eta).
 # ---
 # * GSL::Sf::legendre_H3d_array(lmax, lambda, eta)
@@ -1359,7 +1359,7 @@
 #   This method computes radial eigenfunctions L^{H3d}_l(lambda, eta) for 0 <= l <= lmax,
 #   and returns the result as a <tt>GSL::Vector</tt> object.
 #
-# == {}[link:index.html"name="25] Logarithm and Related Functions
+# == Logarithm and Related Functions
 # ---
 # * GSL::Sf::log(x)
 #
@@ -1372,8 +1372,8 @@
 # * GSL::Sf::complex_log_e(zr, zi)
 # * GSL::Sf::complex_log_e(z)
 #
-#   This method computes the complex logarithm of z = z_r + i z_i.
-#   The results are returned as an array <tt>[lnr, theta]</tt> such that
+#   This method computes the complex logarithm of z = z_r + i z_i.
+#   The results are returned as an array <tt>[lnr, theta]</tt> such that
 #   exp(lnr + i theta) = z_r + i z_i, where theta lies in the range [-pi, pi].
 # ---
 # * GSL::Sf::log_1plusx(x)
@@ -1384,28 +1384,28 @@
 #
 #   Computes log(1 + x) - x for x > -1 using an algorithm that is accurate for small x.
 #
-# == {}[link:index.html"name="26] Mathieu functions
-# The methods described in this section compute the angular and radial Mathieu functions, and their characteristic values. Mathieu functions are the solutions of the following two differential equations: The angular Mathieu functions ce_r(x,q), se_r(x,q) are the even and odd periodic solutions of the first equation, which is known as Mathieu's equation. These exist only for the discrete sequence of characteristic values a=a_r(q) (even-periodic) and a=b_r(q) (odd-periodic).
+# == Mathieu functions
+# The methods described in this section compute the angular and radial Mathieu functions, and their characteristic values. Mathieu functions are the solutions of the following two differential equations: The angular Mathieu functions ce_r(x,q), se_r(x,q) are the even and odd periodic solutions of the first equation, which is known as Mathieu's equation. These exist only for the discrete sequence of characteristic values a=a_r(q) (even-periodic) and a=b_r(q) (odd-periodic).
 #
-# The radial Mathieu functions Mc^{(j)}_{r}(z,q), Ms^{(j)}_{r}(z,q) are the solutions of the second equation, which is referred to as Mathieu's modified equation. The radial Mathieu functions of the first, second, third and fourth kind are denoted by the parameter <tt>j</tt>, which takes the value 1, 2, 3 or 4.
+# The radial Mathieu functions Mc^{(j)}_{r}(z,q), Ms^{(j)}_{r}(z,q) are the solutions of the second equation, which is referred to as Mathieu's modified equation. The radial Mathieu functions of the first, second, third and fourth kind are denoted by the parameter <tt>j</tt>, which takes the value 1, 2, 3 or 4.
 #
-# For more information on the Mathieu functions, see Abramowitz and Stegun, Chapter 20.
+# For more information on the Mathieu functions, see Abramowitz and Stegun, Chapter 20.
 #
-# === {}[link:index.html"name="26.1] Mathieu Function Workspace
+# === Mathieu Function Workspace
 # The Mathieu functions can be computed for a single order or for multiple orders, using array-based routines.
 # ---
 # * GSL::Sf::Mathieu.alloc(n, qmax)
 #
-#   This method returns a workspace for the array versions of the Mathieu routines. The arguments <tt>n</tt> and <tt>qmax</tt> specify the maximum order and q-value of Mathieu functions which can be computed with this workspace.
+#   This method returns a workspace for the array versions of the Mathieu routines. The arguments <tt>n</tt> and <tt>qmax</tt> specify the maximum order and q-value of Mathieu functions which can be computed with this workspace.
 #
-# === {}[link:index.html"name="26.2] Mathieu Function Characteristic Values
+# === Mathieu Function Characteristic Values
 # ---
 # * GSL::Sf::mathieu_a(n, q)
 # * GSL::Sf::mathieu_a_e(n, q)
 # * GSL::Sf::mathieu_b(n, q)
 # * GSL::Sf::mathieu_b_e(n, q)
 #
-#   These methodss compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.
+#   These methodss compute the characteristic values a_n(q), b_n(q) of the Mathieu functions ce_n(q,x) and se_n(q,x), respectively.
 #
 # ---
 # * GSL::Sf::mathieu_a_array(nmin, nmax, q, work)
@@ -1413,31 +1413,31 @@
 #
 #   These methods compute a series of Mathieu characteristic values a_n(q), b_n(q) for n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and return the results as a <tt>GSL::Vector</tt> object.
 #
-# === {}[link:index.html"name="26.3] Angular Mathieu Functions
+# === Angular Mathieu Functions
 # ---
 # * GSL::Sf::mathieu_ce(n, q, x)
 # * GSL::Sf::mathieu_ce_e(n, q, x)
 # * GSL::Sf::mathieu_se(n, q, x)
 # * GSL::Sf::mathieu_se_e(n, q, x)
 #
-#   These methods compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.
+#   These methods compute the angular Mathieu functions ce_n(q,x) and se_n(q,x), respectively.
 #
 # ---
 # * GSL::Sf::mathieu_ce_array(nmin, nmax, q, x, work)
 # * GSL::Sf::mathieu_se_array(nmin, nmax, q, x, work)
 #
 #   These methods compute a series of the angular Mathieu functions ce_n(q,x) and se_n(q,x) of order n from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and return the results as a <tt>GSL::Vector</tt> object.
-#
-# === {}[link:index.html"name="26.4] Radial Mathieu Functions
+#
+# === Radial Mathieu Functions
 # ---
 # * GSL::Sf::mathieu_Mc(j, n, q, x)
 # * GSL::Sf::mathieu_Mc_e(j, n, q, x)
 # * GSL::Sf::mathieu_Ms(j, n, q, x)
 # * GSL::Sf::mathieu_Ms_e(j, n, q, x)
 #
-#   These methods compute the radial <tt>j</tt>-th kind Mathieu functions Mc_n^{(j)}(q,x) and Ms_n^{(j)}(q,x) of order <tt>n</tt>.
+#   These methods compute the radial <tt>j</tt>-th kind Mathieu functions Mc_n^{(j)}(q,x) and Ms_n^{(j)}(q,x) of order <tt>n</tt>.
 #
-#   The allowed values of <tt>j</tt> are 1 and 2. The functions for <tt>j = 3,4</tt> can be computed as M_n^{(3)} = M_n^{(1)} + iM_n^{(2)} and M_n^{(4)} = M_n^{(1)} - iM_n^{(2)}, where M_n^{(j)} = Mc_n^{(j)} or Ms_n^{(j)}.
+#   The allowed values of <tt>j</tt> are 1 and 2. The functions for <tt>j = 3,4</tt> can be computed as M_n^{(3)} = M_n^{(1)} + iM_n^{(2)} and M_n^{(4)} = M_n^{(1)} - iM_n^{(2)}, where M_n^{(j)} = Mc_n^{(j)} or Ms_n^{(j)}.
 #
 # ---
 # * GSL::Sf::mathieu_Mc_array(j, nmin, nmax, q, x, work)
@@ -1445,26 +1445,26 @@
 #
 #   These methods compute a series of the radial Mathieu functions of kind <tt>j</tt>, with order from <tt>nmin</tt> to <tt>nmax</tt> inclusive, and return the results as a <tt>GSL::Vector</tt> object.
 #
-# == {}[link:index.html"name="27] Power Functions
+# == Power Functions
 # ---
 # * GSL::Sf::pow_int(x, n)
 # * GSL::Sf::pow_int_e(x, n)
 #
-#   These methods compute the power x^n for integer n. The power is computed using
-#   the minimum number of multiplications. For example, x^8 is computed as
-#   ((x^2)^2)^2, requiring only 3 multiplications. For reasons of efficiency,
+#   These methods compute the power x^n for integer n. The power is computed using
+#   the minimum number of multiplications. For example, x^8 is computed as
+#   ((x^2)^2)^2, requiring only 3 multiplications. For reasons of efficiency,
 #   these functions do not check for overflow or underflow conditions.
 #
-# == {}[link:index.html"name="28] Psi (Digamma) Function
-# The polygamma functions of order <tt>m</tt> defined by
-# psi^{(m)}(x) = (d/dx)^m psi(x) = (d/dx)^{m+1} log(Gamma(x)),
+# == Psi (Digamma) Function
+# The polygamma functions of order <tt>m</tt> defined by
+# psi^{(m)}(x) = (d/dx)^m psi(x) = (d/dx)^{m+1} log(Gamma(x)),
 # where psi(x) = Gamma'(x)/Gamma(x) is known as the digamma function.
 #
-# === {}[link:index.html"name="28.1] Digamma Function
+# === Digamma Function
 # ---
 # * GSL::Sf::psi_int(n)
 #
-#   Computes the digamma function psi(n) for positive integer <tt>n</tt>.
+#   Computes the digamma function psi(n) for positive integer <tt>n</tt>.
 #   The digamma function is also called the Psi function.
 # ---
 # * GSL::Sf::psi(x)
@@ -1475,7 +1475,7 @@
 #
 #   Computes the real part of the digamma function on the line 1+i y, Re[psi(1 + i y)].
 #
-# === {}[link:index.html"name="28.2] Trigamma Function
+# === Trigamma Function
 # ---
 # * GSL::Sf::psi_1_int(n)
 #
@@ -1485,13 +1485,13 @@
 #
 #   Computes the Trigamma function psi'(x) for general <tt>x</tt>.
 #
-# === {}[link:index.html"name="28.3] Polygamma Function
+# === Polygamma Function
 # ---
 # * GSL::Sf::psi_n(m, x)
 #
 #   Computes the polygamma function psi^{(m)}(x) for m >= 0, x > 0.
 #
-# == {}[link:index.html"name="29] Synchrotron Functions
+# == Synchrotron Functions
 # ---
 # * GSL::Sf::synchrotron_1(x)
 #
@@ -1502,8 +1502,8 @@
 #
 #   Computes the second synchrotron function x K_{2/3}(x) for x >= 0.
 #
-# == {}[link:index.html"name="30] Transport Functions
-# The transport functions J(n,x) are defined by the integral representations
+# == Transport Functions
+# The transport functions J(n,x) are defined by the integral representations
 # J(n,x) := int_0^x dt t^n e^t /(e^t - 1)^2.
 #
 # ---
@@ -1514,8 +1514,8 @@
 #
 #   These methods compute the transport function J(n, x), for n = 2, 3, 4, and 5.
 #
-# == {}[link:index.html"name="31] Trigonometric Functions
-# === {}[link:index.html"name="31.1] Circular Trigonometric Functions
+# == Trigonometric Functions
+# === Circular Trigonometric Functions
 # ---
 # * GSL::Sf::sin(x)
 # * GSL::Sf::cos(x)
@@ -1527,7 +1527,7 @@
 #
 #   sinc(x) = sin(pi x) / (pi x)
 #
-# === {}[link:index.html"name="31.2] Trigonometric Functions for Complex Arguments
+# === Trigonometric Functions for Complex Arguments
 # ---
 # * GSL::Sf::complex_sin_e(zr, zi)
 # * GSL::Sf::complex_sin_e(z)
@@ -1537,19 +1537,19 @@
 # * GSL::Sf::complex_logsin_e(z)
 #
 #
-# === {}[link:index.html"name="31.3] Hyperbolic Trigonometric Functions
+# === Hyperbolic Trigonometric Functions
 # ---
 # * GSL::Sf::lnsinh(x)
 # * GSL::Sf::lncosh(x)
 #
 #
-# === {}[link:index.html"name="31.4] Conversion Functions
+# === Conversion Functions
 # ---
 # * GSL::Sf::polar_to_rect(r, theta)
 # * GSL::Sf::rect_to_polar(x, y)
 #
 #
-# === {}[link:index.html"name="31.5] Restriction Functions
+# === Restriction Functions
 # ---
 # * GSL::Sf::angle_restrict_symm(theta)
 #
@@ -1559,21 +1559,21 @@
 #
 #   This forces the angle <tt>theta</tt> to lie in the range [0, 2pi).
 #
-# === {}[link:index.html"name="31.6] Trigonometric Functions With Error Estimates
+# === Trigonometric Functions With Error Estimates
 # ---
 # * GSL::Sf::sin_err(x, dx)
 #
-#   Computes the sine of an angle <tt>x</tt> with an associated absolute error <tt>dx</tt>,
+#   Computes the sine of an angle <tt>x</tt> with an associated absolute error <tt>dx</tt>,
 #   sin(x +- dx).
 # ---
 # * GSL::Sf::cos_err(x, dx)
 #
-#   Computes the cosine of an angle <tt>x</tt> with an associated absolute error <tt>dx</tt>,
+#   Computes the cosine of an angle <tt>x</tt> with an associated absolute error <tt>dx</tt>,
 #   cos(x +- dx).
 #
-# == {}[link:index.html"name="32] Zeta Functions
-# === {}[link:index.html"name="32.1] Riemann Zeta Function
-# The Riemann zeta function is defined by the infinite sum
+# == Zeta Functions
+# === Riemann Zeta Function
+# The Riemann zeta function is defined by the infinite sum
 # zeta(s) = sum_{k=1}^infty k^{-s}.
 #
 # ---
@@ -1585,7 +1585,7 @@
 #
 #   Computes the Riemann zeta function zeta(s) for arbitrary s, s != 1.
 #
-# === {}[link:index.html"name="32.2] Riemann Zeta Function Minus One
+# === Riemann Zeta Function Minus One
 # ---
 # * GSL::Sf::zetam1_int(n)
 #
@@ -1595,14 +1595,14 @@
 #
 #   Computes zeta(s) - 1 for arbitrary s, s != 1.
 #
-# === {}[link:index.html"name="32.3] Hurwitz Zeta Function
+# === Hurwitz Zeta Function
 # The Hurwitz zeta function is defined by zeta(s,q) = sum_0^infty (k+q)^{-s}.
 # ---
 # * GSL::Sf::hzeta(s, q)
 #
 #   Computes the Hurwitz zeta function zeta(s,q) for s > 1, q > 0.
 #
-# === {}[link:index.html"name="32.4] Eta Function
+# === Eta Function
 # The eta function is defined by eta(s) = (1-2^{1-s}) zeta(s).
 # ---
 # * GSL::Sf::eta_int(n)
@@ -1613,10 +1613,10 @@
 #
 #   Computes the eta function eta(s) for arbitrary s.
 #
-# {prev}[link:rdoc/poly_rdoc.html]
-# {next}[link:rdoc/vector_rdoc.html]
+# {prev}[link:poly_rdoc.html]
+# {next}[link:vector_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #