rb-gsl 1.16.0.2 → 1.16.0.3.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8d84ec677e9881209b3a25a5e78c1254bc29155
-  data.tar.gz: 1d309471b9bbb6e9776d829e06d6611c817caa31
+  metadata.gz: 6cd1daf4ebeac19da26e8f07a1a7f9c98a11f47a
+  data.tar.gz: 94b8324c961064d0dc8d41969f0658fcff3a4b35
 SHA512:
-  metadata.gz: 246c81e8b4e2bca4861b205f842354b8bc343c34fb0ba69abc7858ffcc9a262482d583290fec85d16924891afb2b45628d03a5128ec34f2d7667f3437b43cfb7
-  data.tar.gz: 4bc542cb294cc691c0cb3e058af66317ae6c6d77b919b264c7e0446cbe348a27e1692a3a35190c794bd537c135cca56b3f99f3226b24e6b3381dc28880b89d96
+  metadata.gz: 979c8f99f5f3f2a6efa2713fcc9180dd080b671aecabc8a4cb91df4d22b3a3c6559fbc238bd8a746f4ba79d5440c33b21158019c1c1004530f2656b62c7e2170
+  data.tar.gz: 6dc5252a9bc46a377520bead0a4287a5e5984689afe56909c64c441f282561f2f0eccd15826933039be04a9500f142a646f941f91689207b20804f329a3a9b7a

data/ChangeLog

@@ -1,3 +1,8 @@
+Mon Oct 20 2014
+  * Ruby/GSL 1.16.0.3
+		* Fixed RDoc issues. Issue #6 by @bigtunacan.
+	  * Fixed $LOAD_PATH problem. Pull request #7 by Takahiro SATOH.
+
 Wed Jul  9 2014
   * Ruby/GSL 1.16.0.2
 	  * Fixed linking problem.

data/README

@@ -4,11 +4,11 @@ Ruby/GSL, a ruby interface to GSL (GNU Scientific library)
 
 == Installation
 
-See http://blackwinter.github.io/rb-gsl/.
+See http://blackwinter.github.com/rb-gsl.
 
 == Reference
 
-See http://blackwinter.github.io/rb-gsl/rdoc/ref_rdoc.
+See http://blackwinter.github.com/rb-gsl/rdoc/ref_rdoc.
 
 == Licence
 

data/Rakefile

@@ -17,7 +17,6 @@ begin
       :homepage      => :blackwinter,
       :dependencies  => [['narray', '>= 0.5.9']],
       :requirements  => ['GSL (http://www.gnu.org/software/gsl/)'],
-      :require_paths => %w[lib lib/gsl lib/ool ext],
 
       :extra_files => FileList['examples/**/*', 'rdoc/*'].to_a,
 
@@ -28,8 +27,8 @@ begin
     :rdoc => {
       :title      => 'Ruby/GSL{version: (v%s)}',
       :rdoc_files => FileList['rdoc/*'].to_a,
-      :exclude    => %w[ext lib],
-      :main       => 'rdoc/index.rdoc'
+      :main       => 'index.rdoc',
+      :root       => 'rdoc'
     },
     :test => {
       :libs => %w[lib test]

data/lib/gsl/version.rb

@@ -1,5 +1,5 @@
 module GSL
 
-  RUBY_GSL_VERSION = RB_GSL_VERSION = '1.16.0.2'
+  RUBY_GSL_VERSION = RB_GSL_VERSION = '1.16.0.3.rc1'
 
 end

data/rdoc/alf.rdoc

@@ -5,18 +5,18 @@
 #
 # The class and method descriptions below are based on references from the document of ALF (alf-1.0/doc/alf.texi) by P.Alken.
 #
-# == {}[link:index.html"name="1] Module structure
+# == Module structure
 # * GSL::ALF (module)
 #   * GSL::ALF::Workspace (Class)
 #
-# == {}[link:index.html"name="2] Creating ALF workspace
+# == Creating ALF workspace
 # ---
 # * GSL::ALF::Workspace.alloc(lmax)
 # * GSL::ALF.alloc(lmax)
 #
 # Creates a workspace for computing associated Legendre polynomials (ALFs). The maximum ALF degree is specified by lmax. The size of this workspace is O(lmax).
 #
-# == {}[link:index.html"name="3] Methods
+# == Methods
 # ---
 # * GSL::ALF::Workspace#params(csphase, cnorm, norm)
 #
@@ -49,7 +49,7 @@
 #   must have enough length to store all the values for the polynomial
 #   P_l^m(x), and the length required can be known using
 #   <tt>ALF::array_size(lmax)</tt>. If a vector is not given, a new vector is
-#   created and returned. 
+#   created and returned.
 #
 #   The indices of <tt>result</tt> (and <tt>deriv</tt> corresponding to the
 #   associated Legendre function of degree <tt>l</tt> and order <tt>m</tt> can
@@ -61,7 +61,7 @@
 # * GSL::ALF::Workspace#Plm_deriv_array(lmax, x, result, deriv)
 #
 #   Compute all associated Legendre polynomials P_l^m(x) and their first
-#   derivatives dP_l^m(x)/dx for 0 <= l <= lmax, 0 <= m <= l. 
+#   derivatives dP_l^m(x)/dx for 0 <= l <= lmax, 0 <= m <= l.
 #
 # ---
 # * GSL::ALF::array_size(lmax)

data/rdoc/blas.rdoc

@@ -1,9 +1,9 @@
 #
 # = BLAS Support
 # The following is the list of the methods defined in <tt>GSL::Blas</tt> module.
-# See {GSL reference}[http://www.gnu.org/software/gsl/manual/gsl-ref_12.html#SEC212"target="_top] for details.
+# See {GSL reference}[https://gnu.org/software/gsl/manual/gsl-ref_12.html#SEC212] for details.
 #
-# == {}[link:index.html"name="1] Level 1
+# == Level 1
 # ---
 # * GSL::Blas::ddot(x, y)
 # * GSL::Vector#blas_ddot(y)
@@ -134,7 +134,7 @@
 # * GSL::Blas::drotm!(x, y, p)
 #
 #
-# == {}[link:index.html"name="2] Level 2
+# == Level 2
 # ---
 # * GSL::Blas::dgemv(trans, a, A, x, b, y)
 # * GSL::Blas::dgemv!(trans, a, A, x, b, y)
@@ -186,7 +186,7 @@
 # * GSL::Blas::zher2!(uplo, a, x, y, A)
 #
 #
-# == {}[link:index.html"name="3] Level 3
+# == Level 3
 # ---
 # * GSL::Blas::dgemm(transA, transB, alpha, A, B, beta, C)
 # * GSL::Blas::dgemm(A, B)
@@ -234,7 +234,7 @@
 # * GSL::Blas::zher2k(uplo, trans, diag, alpha, A, B, beta, C)
 #
 #
-# == {}[link:index.html"name="4] Constants
+# == Constants
 # ---
 # * GSL::Blas::CblasRowMajor
 # * GSL::Blas::RowMajor
@@ -260,10 +260,10 @@
 # * GSL::Blas::Right
 #
 #
-# {prev}[link:rdoc/sort_rdoc.html]
-# {next}[link:rdoc/linalg_rdoc.html]
+# {prev}[link:sort_rdoc.html]
+# {next}[link:linalg_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #

data/rdoc/bspline.rdoc

@@ -2,24 +2,24 @@
 # = Basis Splines
 # This chapter describes functions for the computation of smoothing basis splines (B-splines). This is only for GSL-1.9 or later.
 #
-# 1. {Overview}[link:rdoc/bspline_rdoc.html#1]
-# 1. {Initializing the B-splines solver}[link:rdoc/bspline_rdoc.html#2]
-# 1. {Constructing the knots vector}[link:rdoc/bspline_rdoc.html#3]
-# 1. {Evaluation of B-splines}[link:rdoc/bspline_rdoc.html#4]
+# 1. {Overview}[link:bspline_rdoc.html#label-Overview]
+# 1. {Initializing the B-splines solver}[link:bspline_rdoc.html#label-Initializing+the+B-splines+solver]
+# 1. {Constructing the knots vector}[link:bspline_rdoc.html#label-Constructing+the+knots+vector]
+# 1. {Evaluation of B-splines}[link:bspline_rdoc.html#label-Evaluation+of+B-splines]
 #
-# == {}[link:index.html"name="1] Overview
+# == Overview
 #
-# B-splines are commonly used as basis functions to fit smoothing curves to large data sets. To do this, the abscissa axis is broken up into some number of intervals, where the endpoints of each interval are called breakpoints. These breakpoints are then converted to knots by imposing various continuity and smoothness conditions at each interface. Given a nondecreasing knot vector t = \{t_0, t_1, \dots, t_{n+k-1\, the n basis splines of order k are defined by for i = 0, \dots, n-1. The common case of cubic B-splines is given by k = 4. The above recurrence relation can be evaluated in a numerically stable way by the de Boor algorithm. 
+# B-splines are commonly used as basis functions to fit smoothing curves to large data sets. To do this, the abscissa axis is broken up into some number of intervals, where the endpoints of each interval are called breakpoints. These breakpoints are then converted to knots by imposing various continuity and smoothness conditions at each interface. Given a nondecreasing knot vector t = \{t_0, t_1, \dots, t_{n+k-1\, the n basis splines of order k are defined by for i = 0, \dots, n-1. The common case of cubic B-splines is given by k = 4. The above recurrence relation can be evaluated in a numerically stable way by the de Boor algorithm.
 #
-# If we define appropriate knots on an interval [a,b] then the B-spline basis functions form a complete set on that interval. Therefore we can expand a smoothing function as given enough (x_j, f(x_j)) data pairs. The c_i can be readily obtained from a least-squares fit. 
+# If we define appropriate knots on an interval [a,b] then the B-spline basis functions form a complete set on that interval. Therefore we can expand a smoothing function as given enough (x_j, f(x_j)) data pairs. The c_i can be readily obtained from a least-squares fit.
 #
-# == {}[link:index.html"name="2] Initializing the B-splines solver 
+# == Initializing the B-splines solver
 # ---
 # * GSL::BSpline.alloc(k, nbreak)
 #
-#   This method creates a workspace for computing B-splines of order <tt>k</tt>. The number of breakpoints is given by <tt>nbreak</tt>. This leads to <tt>n = nbreak + k - 2</tt> basis functions. Cubic B-splines are specified by <tt>k = 4</tt>. The size of the workspace is <tt>O(5k + nbreak)</tt>. 
+#   This method creates a workspace for computing B-splines of order <tt>k</tt>. The number of breakpoints is given by <tt>nbreak</tt>. This leads to <tt>n = nbreak + k - 2</tt> basis functions. Cubic B-splines are specified by <tt>k = 4</tt>. The size of the workspace is <tt>O(5k + nbreak)</tt>.
 #
-# == {}[link:index.html"name="3] Constructing the knots vector 
+# == Constructing the knots vector
 # ---
 # * GSL::BSpline#knots(breakpts)
 #
@@ -27,16 +27,16 @@
 # ---
 # * GSL::BSpline#knots_uniform(a, b)
 #
-#   This method assumes uniformly spaced breakpoints on [<tt>a,b</tt>] and constructs the corresponding knot vector using the previously specified <tt>nbreak</tt> parameter. 
-# == {}[link:index.html"name="4] Evaluation of B-splines 
+#   This method assumes uniformly spaced breakpoints on [<tt>a,b</tt>] and constructs the corresponding knot vector using the previously specified <tt>nbreak</tt> parameter.
+# == Evaluation of B-splines
 # ---
 # * GSL::BSpline#eval(x[, B])
 #
-#   This method evaluates all B-spline basis functions at the position <tt>x</tt> and stores them in <tt>B</tt> (if given), so that the ith element of <tt>B</tt> is <tt>B_i(x)</tt>. <tt>B</tt> must be of length <tt>n = nbreak + k - 2</tt>. If <tt>B</tt> is not given, a newly created vector is returned.It is far more efficient to compute all of the basis functions at once than to compute them individually, due to the nature of the defining recurrence relation. 
+#   This method evaluates all B-spline basis functions at the position <tt>x</tt> and stores them in <tt>B</tt> (if given), so that the ith element of <tt>B</tt> is <tt>B_i(x)</tt>. <tt>B</tt> must be of length <tt>n = nbreak + k - 2</tt>. If <tt>B</tt> is not given, a newly created vector is returned.It is far more efficient to compute all of the basis functions at once than to compute them individually, due to the nature of the defining recurrence relation.
 #
-# {prev}[link:rdoc/nonlinearfit_rdoc.html]
-# {next}[link:rdoc/const_rdoc.html]
+# {prev}[link:nonlinearfit_rdoc.html]
+# {next}[link:const_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #

data/rdoc/changes.rdoc

@@ -10,12 +10,7 @@
 # The changes that could break old scripts are described below.  They are
 # followed by highlights of the other enhancements and new features.
 #
-# A complete log of changes since Ruby/GSL version 1.10.3 can be obtained by
-# using Subversion's log command to look at the repository...
-#
-#   svn log http://rb-gsl.rubyforge.org/svn/trunk/rb-gsl
-#
-# == {}[link:index.html"name="1] Backwards incompatibilities introduced in Ruby/GSL 1.11.2
+# == Backwards incompatibilities introduced in Ruby/GSL 1.11.2
 #
 # * FFT interface has been extensively changed.
 #
@@ -39,13 +34,13 @@
 #
 # * GSL::Complex objects are now immutable.
 #
-# == {}[link:index.html"name="2] Enhancements and features introduced in Ruby/GSL 1.11.2
+# == Enhancements and features introduced in Ruby/GSL 1.11.2
 #
 # * Now distributed and installable as a Ruby Gem.
 #
 # * Allow nil for real and/or imag in GSL::Vector::Complex#set(i,re,im) to NOT
-#   set that component.  For example, "z=GSL::Vector::Complex[1]; z[0] = [nil,
-#   1]" will set z[0] to GSL::Complex[0,1].
+#   set that component.  For example, <tt>z=GSL::Vector::Complex[1]; z[0] = [nil,
+#   1]</tt> will set \z[0] to \GSL::Complex[0,1].
 #
 # * Added GSL::Vector::Complex#to_s method.
 #

data/rdoc/cheb.rdoc

@@ -1,24 +1,24 @@
 #
 # = Chebyshev Approximations
-# This chapter describes routines for computing Chebyshev approximations to 
-# univariate functions. A Chebyshev approximation is a truncation of the series 
-# f(x) = \sum c_n T_n(x), 
-# where the Chebyshev polynomials T_n(x) = \cos(n \arccos x) 
-# provide an orthogonal basis of polynomials on the interval [-1,1] 
-# with the weight function 1 / \sqrt{1-x^2}. 
-# The first few Chebyshev polynomials are, 
-# T_0(x) = 1, T_1(x) = x, T_2(x) = 2 x^2 - 1. 
-# For further information see Abramowitz & Stegun, Chapter 22. 
-#
-# 1. {GSL::Cheb class}[link:rdoc/cheb_rdoc.html#1]
-# 1. {Chebyshev Series Evaluation}[link:rdoc/cheb_rdoc.html#2]
-# 1. {Derivatives and Integrals}[link:rdoc/cheb_rdoc.html#3]
-# 1. {Examples}[link:rdoc/cheb_rdoc.html#4]
-#
-# == {}[link:index.html"name="1] <tt>GSL::Cheb</tt> class
+# This chapter describes routines for computing Chebyshev approximations to
+# univariate functions. A Chebyshev approximation is a truncation of the series
+# f(x) = \sum c_n T_n(x),
+# where the Chebyshev polynomials T_n(x) = \cos(n \arccos x)
+# provide an orthogonal basis of polynomials on the interval [-1,1]
+# with the weight function 1 / \sqrt{1-x^2}.
+# The first few Chebyshev polynomials are,
+# T_0(x) = 1, T_1(x) = x, T_2(x) = 2 x^2 - 1.
+# For further information see Abramowitz & Stegun, Chapter 22.
+#
+# 1. {GSL::Cheb class}[link:cheb_rdoc.html#label-Cheb+class]
+# 1. {Chebyshev Series Evaluation}[link:cheb_rdoc.html#label-Chebyshev+Series+Evaluation]
+# 1. {Derivatives and Integrals}[link:cheb_rdoc.html#label-Derivatives+and+Integrals]
+# 1. {Examples}[link:cheb_rdoc.html#label-Example]
+#
+# == <tt>Cheb</tt> class
 #
 # ---
-# * GSL::Cheb.alloc(n) 
+# * GSL::Cheb.alloc(n)
 #
 #   This create an instance of the GSL::Cheb class for a Chebyshev series of order n.
 #
@@ -26,7 +26,7 @@
 # ---
 # * GSL::Cheb#init(f, a, b)
 #
-#   This computes the Chebyshev approximation the function <tt>f</tt> over the range (<tt>a,b</tt>) to the previously specified order. Where <tt>f</tt> is a {GSL::Function}[link:rdoc/function_rdoc.html] object. The computation of the Chebyshev approximation is an O(n^2) process, and requires <tt>n</tt> function evaluations.
+#   This computes the Chebyshev approximation the function <tt>f</tt> over the range (<tt>a,b</tt>) to the previously specified order. Where <tt>f</tt> is a {GSL::Function}[link:function_rdoc.html] object. The computation of the Chebyshev approximation is an O(n^2) process, and requires <tt>n</tt> function evaluations.
 #
 #   * ex: Approximate a step function defined in (0, 1) by a Chebyshev series of order 40.
 #       f = GSL::Function.alloc { |x|
@@ -40,7 +40,7 @@
 #       cs = GSL::Cheb.alloc(40)
 #       cs.init(f, 0, 1)
 #
-# == {}[link:index.html"name="2] Chebyshev Series Evaluation
+# == Chebyshev Series Evaluation
 # ---
 # * GSL::Cheb#eval(x)
 #
@@ -51,7 +51,7 @@
 #
 #   This evaluates the Chebyshev series at a given point <tt>x</tt>, to (at most) the given order <tt>n</tt>.
 #
-# == {}[link:index.html"name="3] Derivatives and Integrals 
+# == Derivatives and Integrals
 #
 # ---
 # * GSL::Cheb#calc_deriv()
@@ -65,7 +65,7 @@
 #
 #   This computes the integral of the series, and returns a new GSL::Cheb object which contains the computed integral coefficients. The reciever is not changed.
 #
-# == {}[link:index.html"name="4] Example
+# == Example
 #    #!/usr/bin/env ruby
 #    require("gsl")
 #
@@ -91,9 +91,9 @@
 #
 # See also the example scripts in <tt>examples/cheb/</tt>.
 #
-# {prev}[link:rdoc/diff_rdoc.html]
-# {next}[link:rdoc/sum_rdoc.html]
+# {prev}[link:diff_rdoc.html]
+# {next}[link:sum_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #

data/rdoc/cholesky_complex.rdoc

@@ -1,46 +1,46 @@
 #
 # === Cholesky decomposition (>= GSL-1.10)
-# A symmetric, positive definite square matrix <tt>A</tt> has 
-# a Cholesky decomposition into a product of a lower triangular matrix 
+# A symmetric, positive definite square matrix <tt>A</tt> has
+# a Cholesky decomposition into a product of a lower triangular matrix
 # <tt>L</tt> and its transpose <tt>L^T</tt>.
-# This is sometimes referred to as taking the square-root of a matrix. 
-# The Cholesky decomposition can only be carried out when all the eigenvalues 
-# of the matrix are positive. This decomposition can be used to convert the 
-# linear system <tt>A x = b</tt> into a pair of triangular systems 
+# This is sometimes referred to as taking the square-root of a matrix.
+# The Cholesky decomposition can only be carried out when all the eigenvalues
+# of the matrix are positive. This decomposition can be used to convert the
+# linear system <tt>A x = b</tt> into a pair of triangular systems
 # <tt>L y = b, L^T x = y</tt>,
-# which can be solved by forward and back-substitution. 
+# which can be solved by forward and back-substitution.
 #
 # ---
 # * GSL::Linalg::Complex::Cholesky::decomp(A)
 # * GSL::Linalg::Complex::cholesky_decomp(A)
 #
-#   Factorize the positive-definite square matrix <tt>A</tt> into the 
+#   Factorize the positive-definite square matrix <tt>A</tt> into the
 #   Cholesky decomposition <tt>A = L L^H</tt>.
-#   On input only the diagonal and lower-triangular part of the matrix <tt>A</tt> 
+#   On input only the diagonal and lower-triangular part of the matrix <tt>A</tt>
 #   are needed. The diagonal and lower triangular part of the returned matrix
-#   contain the matrix <tt>L</tt>. The upper triangular part of the 
+#   contain the matrix <tt>L</tt>. The upper triangular part of the
 #   returned matrix contains L^T, and
-#   the diagonal terms being identical for both L and L^T. 
-#   If the input matrix is not positive-definite then the decomposition 
-#   will fail, returning the error code <tt>GSL::EDOM</tt>. 
+#   the diagonal terms being identical for both L and L^T.
+#   If the input matrix is not positive-definite then the decomposition
+#   will fail, returning the error code <tt>GSL::EDOM</tt>.
 #
 # ---
 # * GSL::Linalg::Complex::Cholesky::solve(chol, b, x)
 # * GSL::Linalg::Complex::cholesky_solve(chol, b, x)
 #
-#   Solve the system <tt>A x = b</tt> using the Cholesky decomposition 
-#   of <tt>A</tt> into the matrix <tt>chol</tt> given by 
+#   Solve the system <tt>A x = b</tt> using the Cholesky decomposition
+#   of <tt>A</tt> into the matrix <tt>chol</tt> given by
 #   <tt>GSL::Linalg::Complex::Cholesky::decomp</tt>.
 #
 # ---
 # * GSL::Linalg::Complex::Cholesky::svx(chol, x)
 # * GSL::Linalg::Complex::cholesky_svx(chol, x)
 #
-#   Solve the system <tt>A x = b</tt> in-place using the Cholesky decomposition 
-#   of <tt>A</tt> into the matrix <tt>chol</tt> given by 
-#   <tt>GSL::Linalg::Complex::Cholesky::decomp</tt>. On input <tt>x</tt> 
-#   should contain the right-hand side <tt>b</tt>, 
-#   which is replaced by the solution on output. 
+#   Solve the system <tt>A x = b</tt> in-place using the Cholesky decomposition
+#   of <tt>A</tt> into the matrix <tt>chol</tt> given by
+#   <tt>GSL::Linalg::Complex::Cholesky::decomp</tt>. On input <tt>x</tt>
+#   should contain the right-hand side <tt>b</tt>,
+#   which is replaced by the solution on output.
 #
-# {back}[link:rdoc/linalg_rdoc.html]
+# {back}[link:linalg_rdoc.html]
 #

data/rdoc/combi.rdoc

@@ -1,50 +1,50 @@
 #
 # = Combinations
 # Contents:
-# 1. {Combination allocation}[link:rdoc/combi_rdoc.html#1]
-# 1. {Methods}[link:rdoc/combi_rdoc.html#2]
-#    1. {Accessing combination elements}[link:rdoc/combi_rdoc.html#2.1]
-#    1. {Combination properties}[link:rdoc/combi_rdoc.html#2.2]
-#    1. {Combination functions}[link:rdoc/combi_rdoc.html#2.3]
-#    1. {Reading and writing combinations}[link:rdoc/combi_rdoc.html#2.4]
-#
-# == {}[link:index.html"name="1] Combination allocation
+# 1. {Combination allocation}[link:combi_rdoc.html#label-Combination+allocation]
+# 1. {Methods}[link:combi_rdoc.html#label-Methods]
+#    1. {Accessing combination elements}[link:combi_rdoc.html#label-Accessing+combination+elements]
+#    1. {Combination properties}[link:combi_rdoc.html#label-Combination+properties]
+#    1. {Combination functions}[link:combi_rdoc.html#label-Combination+functions]
+#    1. {Reading and writing combinations}[link:combi_rdoc.html#label-Reading+and+writing+combinations]
+#
+# == Combination allocation
 # ---
 # * GSL::Combination.alloc(n, k)
 #
-#   These create a new combination with parameters <tt>n, k</tt>. 
-#   The combination is not initialized and its elements are undefined. 
-#   Use the method <tt>GSL::Combination.calloc</tt> if you want to create a 
-#   combination which is initialized to the lexicographically first combination. 
+#   These create a new combination with parameters <tt>n, k</tt>.
+#   The combination is not initialized and its elements are undefined.
+#   Use the method <tt>GSL::Combination.calloc</tt> if you want to create a
+#   combination which is initialized to the lexicographically first combination.
 #
 # ---
 # * GSL::Combination.calloc(n, k)
 #
-#   This creates a new combination with parameters <tt>n, k</tt> and initializes 
-#   it to the lexicographically first combination. 
+#   This creates a new combination with parameters <tt>n, k</tt> and initializes
+#   it to the lexicographically first combination.
 #
-# == {}[link:index.html"name="2] Methods
+# == Methods
 #
 # ---
 # * GSL::Combination#init_first
 #
-#   This method initializes the combination <tt>self</tt> to the lexicographically 
+#   This method initializes the combination <tt>self</tt> to the lexicographically
 #   first combination, i.e. (0,1,2,...,k-1).
 #
 # ---
 # * GSL::Combination#init_last
 #
-#   This method initializes the combination <tt>self</tt> to the lexicographically last 
+#   This method initializes the combination <tt>self</tt> to the lexicographically last
 #   combination, i.e. (n-k,n-k+1,...,n-1).
 #
-# === {}[link:index.html"name="2.1] Accessing combination elements
+# === Accessing combination elements
 # ---
 # * GSL::Combination#get(i)
-# * GSL::Combination#[i]
+# * \GSL::Combination#[i]
 #
-#   This returns the value of the <tt>i</tt>-th element of the combination <tt>self</tt>. 
+#   This returns the value of the <tt>i</tt>-th element of the combination <tt>self</tt>.
 #
-# === {}[link:index.html"name="2.2] Combination properties
+# === Combination properties
 # ---
 # * GSL::Combination#n
 #
@@ -63,8 +63,8 @@
 # ---
 # * GSL::Combination#valid
 #
-#   This method checks that the combination <tt>self</tt> is valid. 
-#   The <tt>k</tt> elements should contain numbers from range 0 .. n-1, 
+#   This method checks that the combination <tt>self</tt> is valid.
+#   The <tt>k</tt> elements should contain numbers from range 0 .. n-1,
 #   each number at most once. The numbers have to be in increasing order.
 #
 # ---
@@ -72,25 +72,25 @@
 #
 #   Thie returns true if the combination is valid, and false otherwise.
 #
-# === {}[link:index.html"name="2.3] Combination functions
+# === Combination functions
 # ---
 # * GSL::Combination#next
 #
-#   This method advances the combination <tt>self</tt> to the next combination in 
-#   lexicographic order and returns <tt>GSL::SUCCESS</tt>. If no further combinations are 
-#   available it returns <tt>GSL::FAILURE</tt> and leaves <tt>self</tt> unmodified. 
-#   Starting with the first combination and repeatedly applying this function will 
+#   This method advances the combination <tt>self</tt> to the next combination in
+#   lexicographic order and returns <tt>GSL::SUCCESS</tt>. If no further combinations are
+#   available it returns <tt>GSL::FAILURE</tt> and leaves <tt>self</tt> unmodified.
+#   Starting with the first combination and repeatedly applying this function will
 #   iterate through all possible combinations of a given order.
 #
 # ---
 # * GSL::Combination#prev
 #
-#   This method steps backwards from the combination <tt>self</tt> to the previous 
-#   combination in lexicographic order, returning <tt>GSL::SUCCESS</tt>. 
-#   If no previous combination is available it returns <tt>GSL::FAILURE</tt> 
+#   This method steps backwards from the combination <tt>self</tt> to the previous
+#   combination in lexicographic order, returning <tt>GSL::SUCCESS</tt>.
+#   If no previous combination is available it returns <tt>GSL::FAILURE</tt>
 #   and leaves <tt>self</tt> unmodified.
 #
-# === {}[link:index.html"name="2.4] Reading and writing combinations
+# === Reading and writing combinations
 # ---
 # * GSL::Combination#fwrite(filename)
 # * GSL::Combination#fwrite(io)
@@ -102,7 +102,7 @@
 # * GSL::Combination#fscanf(io)
 #
 #
-# == {}[link:index.html"name="3] Example
+# == Example
 #      #!/usr/bin/env ruby
 #      require("gsl")
 #
@@ -116,10 +116,10 @@
 #        end while c.next == GSL::SUCCESS
 #      end
 #
-# {prev}[link:rdoc/perm_rdoc.html]
-# {next}[link:rdoc/multiset_rdoc.html]
+# {prev}[link:perm_rdoc.html]
+# {next}[link:sort_rdoc.html]
 #
-# {Reference index}[link:rdoc/ref_rdoc.html]
+# {Reference index}[link:ref_rdoc.html]
 # {top}[link:index.html]
 #
 #