rb-gsl 1.16.0.5 → 1.16.0.6

data/rdoc/perm.rdoc

@@ -1,221 +0,0 @@
-#
-# = Permutations
-# Contents:
-# 1. {Permuation allocations}[link:rdoc/perm_rdoc.html#label-Permuation+allocations]
-# 1. {Methods}[link:rdoc/perm_rdoc.html#label-Methods]
-#    1. {Accessing permutation elements}[link:rdoc/perm_rdoc.html#label-Accessing+permutation+elements]
-#    1. {Permuation properties}[link:rdoc/perm_rdoc.html#label-Permutation+properties]
-#    1. {Permuation functions}[link:rdoc/perm_rdoc.html#label-Permutation+functions]
-#    1. {Reading and writing permutations}[link:rdoc/perm_rdoc.html#label-Reading+and+writing+permutations]
-# 1. {Permutations in cyclic form}[link:rdoc/perm_rdoc.html#label-Permutations+in+cyclic+Form]
-# 1. {Applying Permutations}[link:rdoc/perm_rdoc.html#label-Applying+Permutations]
-#
-# == Permuation allocations
-# ---
-# * GSL::Permutation.alloc(n)
-#
-#   These functions create a new permutation of size <tt>n</tt>.
-#   The permutation is not initialized and its elements are undefined.
-#   Use <tt>GSL::Permutation.calloc</tt> if you want to create a permutation
-#   which is initialized to the identity.
-#
-# ---
-# * GSL::Permutation.calloc(n)
-#
-#   This creates a new permutation of size <tt>n</tt> and initializes it to the identity.
-#
-# == Methods
-# ---
-# * GSL::Permutation#init()
-#
-#   This initializes the permutation to the identity, i.e. (0,1,2,...,n-1).
-#
-# ---
-# * GSL::Permutation.memcpy(dest, src)
-#
-#   This method copies the elements of the permutation <tt>src</tt>
-#   into the permutation <tt>dest</tt>. The two permutations must have the same size.
-#
-# ---
-# * GSL::Permutation#clone
-#
-#   This creates a new permutation with the same elements of <tt>self</tt>.
-#
-# === Accessing permutation elements
-#
-# ---
-# * GSL::Permutation#get(i)
-#
-#   Returns the value of the <tt>i</tt>-th element of the permutation.
-#
-# ---
-# * GSL::Permutation#swap(i, j)
-#
-#   This exchanges the <tt>i</tt>-th and <tt>j</tt>-th elements of the permutation.
-#
-# === Permutation properties
-# ---
-# * GSL::Permutation#size
-#
-#   Returns the size of the permutation.
-# ---
-# * GSL::Permutation#valid
-#
-#   This checks that the permutation <tt>self</tt> is valid.
-#   The n elements should contain each of the numbers 0 .. n-1 once and only once.
-#
-# ---
-# * GSL::Permutation#valid?
-#
-#   This returns true if the permutation <tt>self</tt> is valid, and false otherwise.
-#
-# === Permutation functions
-#
-# ---
-# * GSL::Permutation#reverse
-#
-#   This reverses the elements of the permutation <tt>self</tt>.
-# ---
-# * GSL::Permutation#inverse
-#
-#   This computes the inverse of the permutation <tt>self</tt>, and returns
-#   as a new permutation.
-#
-# ---
-# * GSL::Permutation#next
-#
-#   This method advances the permutation <tt>self</tt> to the next permutation in
-#   lexicographic order and returns <tt>GSL::SUCCESS</tt>. If no further permutations
-#   are available it returns <tt>GSL::FAILURE</tt> and leaves <tt>self</tt> unmodified.
-#   Starting with the identity permutation and repeatedly applying this function
-#   will iterate through all possible permutations of a given order.
-# ---
-# * GSL::Permutation#prev
-#
-#   This method steps backwards from the permutation <tt>self</tt> to the previous
-#   permutation in lexicographic order, returning <tt>GSL_SUCCESS</tt>.
-#   If no previous permutation is available it returns <tt>GSL_FAILURE</tt>
-#   and leaves <tt>self</tt> unmodified.
-#
-# === Reading and writing permutations
-# ---
-# * GSL::Permutation#fwrite(io)
-# * GSL::Permutation#fwrite(filename)
-# * GSL::Permutation#fread(io)
-# * GSL::Permutation#fread(filename)
-# * GSL::Permutation#fprintf(io, format = "%u\n")
-# * GSL::Permutation#fprintf(filename, format = "%u\n")
-# * GSL::Permutation#fscanf(io)
-# * GSL::Permutation#fscanf(filename)
-#
-#
-# === Permutations in cyclic Form
-# A permutation can be represented in both <tt>linear</tt> and
-# <tt>cyclic</tt> notations. The functions described in this section convert
-# between the two forms. The linear notation is an index mapping, and has
-# already been described above. The cyclic notation expresses a
-# permutation as a series of circular rearrangements of groups
-# of elements, or <tt>cycles</tt>.
-#
-# For example, under the cycle (1 2 3), 1 is replaced by 2, 2 is replaced
-# by 3 and 3 is replaced by 1 in a circular fashion. Cycles of different
-# sets of elements can be combined independently, for example (1 2 3) (4 5)
-# combines the cycle (1 2 3) with the cycle (4 5), which is an exchange of
-# elements 4 and 5. A cycle of length one represents an element which is
-# unchanged by the permutation and is referred to as a <tt>singleton</tt>.
-#
-# It can be shown that every permutation can be decomposed into combinations
-# of cycles. The decomposition is not unique, but can always be rearranged
-# into a standard <tt>canonical form</tt> by a reordering of elements.
-# The library uses the canonical form defined in Knuth's
-# <tt>Art of Computer Programming</tt> (Vol 1, 3rd Ed, 1997) Section 1.3.3, p.178.
-#
-# The procedure for obtaining the canonical form given by Knuth is,
-#
-#
-# 1. Write all singleton cycles explicitly
-# 1. Within each cycle, put the smallest number first
-# 1. Order the cycles in decreasing order of the first number in the cycle.
-#
-# For example, the linear representation (2 4 3 0 1) is represented as
-# (1 4) (0 2 3) in canonical form. The permutation corresponds to an
-# exchange of elements 1 and 4, and rotation of elements 0, 2 and 3.
-#
-# The important property of the canonical form is that it can be reconstructed
-# from the contents of each cycle without the brackets. In addition, by removing
-# the brackets it can be considered as a linear representation of a different
-# permutation. In the example given above the permutation (2 4 3 0 1) would
-# become (1 4 0 2 3). This mapping has many applications in the theory of
-# permutations.
-#
-# ---
-# * GSL::Permutation#linear_to_canonical
-# * GSL::Permutation#to_canonical
-#
-#   Computes the canonical form of the permutation <tt>self</tt> and
-#   returns it as a new <tt>GSL::Permutation</tt>.
-#
-# ---
-# * GSL::Permutation#canonical_to_linear
-# * GSL::Permutation#to_linear
-#
-#   Converts a permutation <tt>self</tt> in canonical form back into linear
-#   form and returns it as a new <tt>GSL::Permutation</tt>.
-#
-#
-# ---
-# * GSL::Permutation#inversions
-#
-#   Counts the number of inversions in the permutation <tt>self</tt>.
-#   An inversion is any pair of elements that are not in order.
-#   For example, the permutation 2031 has three inversions, corresponding
-#   to the pairs (2,0) (2,1) and (3,1).
-#   The identity permutation has no inversions.
-#
-# ---
-# * GSL::Permutation#linear_cycles
-#
-#   Counts the number of cycles in the permutation <tt>self</tt>,
-#   given in linear form.
-#
-# ---
-# * GSL::Permutation#canonical_cycles
-#
-#   Counts the number of cycles in the permutation <tt>self</tt>,
-#   given in canonical form.
-#
-# == Applying Permutations
-# ---
-# * GSL::Permutation::permute(v)
-#
-#   Applies the permutation <tt>self</tt> to the elements of the vector <tt>v</tt>,
-#   considered as a row-vector acted on by a permutation matrix from the
-#   right, v' = v P. The j-th column of the permutation matrix P is
-#   given by the p_j-th column of the identity matrix.
-#   The permutation <tt>self</tt> and the vector <tt>v</tt> must have the same length.
-# ---
-# * GSL::Permutation::permute_inverse(v)
-#
-#   Applies the inverse of the permutation <tt>self</tt> to the elements of
-#   the vector <tt>v</tt>, considered as a row-vector acted on by an inverse
-#   permutation matrix from the right, v' = v P^T.
-#   Note that for permutation matrices the inverse is the same as the
-#   transpose. The j-th column of the permutation matrix P is given by
-#   the p_j-th column of the identity matrix.
-#   The permutation <tt>self</tt> and the vector <tt>v</tt> must have the same length.
-# ---
-# * GSL::Permutation.mul(pa, pb)
-#
-#   Combines the two permutations <tt>pa</tt> and <tt>pb</tt> into a single
-#   permutation <tt>p</tt> and returns it.
-#   The permutation <tt>p</tt> is equivalent to applying <tt>pb</tt> first
-#   and then <tt>pa</tt>.
-#
-#
-# {prev}[link:rdoc/matrix_rdoc.html]
-# {next}[link:rdoc/combi_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#

data/rdoc/poly.rdoc

@@ -1,335 +0,0 @@
-#
-# = Polynomials
-# Contents:
-# 1. {Polynomial Evaluation}[link:rdoc/poly_rdoc.html#label-Polynomial+Evaluation]
-# 1. {Solving polynomial equations}[link:rdoc/poly_rdoc.html#label-Solving+polynomial+equations]
-#    1. {Quadratic Equations}[link:rdoc/poly_rdoc.html#label-Quadratic+Equations]
-#    1. {Cubic Equations}[link:rdoc/poly_rdoc.html#label-Cubic+Equations]
-#    1. {General Polynomial Equations}[link:rdoc/poly_rdoc.html#label-General+Polynomial+Equations]
-# 1. {GSL::Poly class}[link:rdoc/poly_rdoc.html#label-Poly+class]
-#    1. {Constructors}[link:rdoc/poly_rdoc.html#label-Constructors]
-#    1. {Methods}[link:rdoc/poly_rdoc.html#label-Instance+Methods]
-# 1. {Polynomial Fitting}[link:rdoc/poly_rdoc.html#label-Polynomial+fitting]
-# 1. {Divided-difference representations}[link:rdoc/poly_rdoc.html#label-Divided-difference+representations]
-# 1. {Extensions}[link:rdoc/poly_rdoc.html#label-Extensions]
-#    1. {Special Polynomials}[link:rdoc/poly_rdoc.html#label-Special+Polynomials]
-#    1. {Polynomial Operations}[link:rdoc/poly_rdoc.html#label-Polynomial+Operations]
-#
-# == Polynomial Evaluation
-# ---
-# * GSL::Poly.eval(c, x)
-#
-#   Evaluates the polynomial <tt>c[0] + c[1]x + c[2]x^2 + ...</tt>.
-#   The polynomial coefficients <tt>c</tt> can be an <tt>Array</tt>,
-#   a <tt>GSL::Vector</tt>, or an <tt>NArray</tt>. The evaluation point <tt>x</tt>
-#   is a <tt>Numeric</tt>, <tt>Array</tt>, <tt>GSL::Vector</tt> or <tt>NArray</tt>.
-#   From GSL 1.11, <tt>x</tt> can be a complex number, and <tt>c</tt> can be a complex polynomial given by a <tt>GSL::Vector::Complex</tt> or an <tt>Array</tt>.
-#
-#   Ex)
-#      >> require("gsl")
-#      => true
-#      >> GSL::Poly.eval([1, 2, 3], 2)
-#      => 17.0
-#      >> GSL::Poly.eval(GSL::Vector[1, 2, 3], 2)
-#      => 17.0
-#      >> GSL::Poly.eval(NArray[1.0, 2, 3], 2)
-#      => 17.0
-#      >> GSL::Poly.eval([1, 2, 3], [1, 2, 3])
-#      => [6.0, 17.0, 34.0]
-#      >> GSL::Poly.eval([1, 2, 3], GSL::Vector[1, 2, 3])
-#      => GSL::Vector
-#      [ 6.000e+00 1.700e+01 3.400e+01 ]
-#      >> GSL::Poly.eval([1, 2, 3], NArray[1.0, 2, 3])
-#      => NArray.float(3):
-#      [ 6.0, 17.0, 34.0 ]
-#
-# ---
-# * GSL::Poly.eval_derivs(c, x)
-# * GSL::Poly.eval_derivs(c, x, lenres)
-#
-#   (GSL-1.13) Evaluate and return a polynomial and its derivatives. The output contains the values of d^k P/d x^k for the specified value of x starting with k = 0. The input polynomial <tt>c</tt> can be an <tt>Array</tt>, <tt>GSL::Poly</tt> or an <tt>NArray</tt>. If <tt>lenres</tt> is not given, <tt>lenres = LENGTH(c) + 1</tt> is used, therefore the last element of the output is 0.
-#
-# ---
-# * GSL::Poly#eval_derivs(x)
-# * GSL::Poly#eval_derivs(x, lenres)
-#
-#   (GSL-1.13) Evaluate and return a polynomial and its derivatives. The output contains the values of d^k P/d x^k for the specified value of x starting with k = 0. If <tt>lenres</tt> is not given, <tt>lenres = LENGTH(self) + 1</tt> is used, therefore the last element of the output is 0.
-#
-#   Ex.)
-#    >> ary = [1, 2, 3]
-#    => [1, 2, 3]
-#    >> GSL::Poly.eval_derivs(ary, 1)
-#    => [6.0, 8.0, 6.0, 0.0]
-#    >> na = NArray[1.0, 2, 3]
-#    => NArray.float(3):
-#    [ 1.0, 2.0, 3.0 ]
-#    >> GSL::Poly.eval_derivs(na, 1)
-#    => NArray.float(4):
-#    [ 6.0, 8.0, 6.0, 0.0 ]
-#    >> poly = GSL::Poly[1.0, 2, 3]
-#    => GSL::Poly
-#    [ 1.000e+00 2.000e+00 3.000e+00 ]
-#    >> GSL::Poly.eval_derivs(poly, 1)
-#    => GSL::Poly
-#    [ 6.000e+00 8.000e+00 6.000e+00 0.000e+00 ]
-#    >> poly.eval_derivs(1)
-#    => GSL::Poly
-#    [ 6.000e+00 8.000e+00 6.000e+00 0.000e+00 ]
-#    >> poly.eval_derivs(1, 3)
-#    => GSL::Poly
-#    [ 6.000e+00 8.000e+00 6.000e+00 ]
-#
-# == Solving polynomial equations
-# === Quadratic Equations
-# ---
-# * GSL::Poly::solve_quadratic(a, b, c)
-# * GSL::Poly::solve_quadratic([a, b, c])
-#
-#   Find the real roots of the quadratic equation,
-#     a x^2 + b x + c = 0
-#   The coefficients are given by 3 numbers, or a Ruby array,
-#   or a <tt>GSL::Vector</tt> object. The roots are returned as a <tt>GSL::Vector</tt>.
-#
-#   * Ex: z^2 - 3z + 2 = 0
-#       >> GSL::Poly::solve_quadratic(1, -3, 2)
-#       => GSL::Vector:
-#       [ 1.000e+00 2.000e+00 ]
-#
-#
-# ---
-# * GSL::Poly::complex_solve_quadratic(a, b, c)
-# * GSL::Poly::complex_solve_quadratic([a, b, c])
-#
-#   Find the complex roots of the quadratic equation,
-#     a z^2 + b z + z = 0
-#   The coefficients are given by 3 numbers or a Ruby array, or a
-#   <tt>GSL::Vector</tt>.
-#   The roots are returned as a <tt>GSL::Vector::Complex</tt> of two elements.
-#
-#   * Ex: z^2 - 3z + 2 = 0
-#      >> require("gsl")
-#      => true
-#      >> GSL::Poly::complex_solve_quadratic(1, -3, 2)
-#      [ [1.000e+00 0.000e+00] [2.000e+00 0.000e+00] ]
-#      => #<GSL::Vector::Complex:0x764014>
-#      >> GSL::Poly::complex_solve_quadratic(1, -3, 2).real  <--- Real part
-#      => GSL::Vector::View:
-#      [ 1.000e+00 2.000e+00 ]
-#
-# === Cubic Equations
-# ---
-# * GSL::Poly::solve_cubic(same as solve_quadratic)
-#
-#   This method finds the real roots of the cubic equation,
-#     x^3 + a x^2 + b x + c = 0
-#
-# ---
-# * GSL::Poly::complex_solve_cubic(same as solve_cubic)
-#
-#   This method finds the complex roots of the cubic equation,
-#     z^3 + a z^2 + b z + c = 0
-#
-# === General Polynomial Equations
-# ---
-# * GSL::Poly::complex_solve(c0, c1, c2,,, )
-# * GSL::Poly::solve(c0, c1, c2,,, )
-#
-#   Find the complex roots of the polynomial equation. Note that
-#   the coefficients are given by "ascending" order.
-#
-#   * Ex: x^2 - 3 x + 2 == 0
-#        >> GSL::Poly::complex_solve(2, -3, 1)    <--- different from Poly::quadratic_solve
-#        [ [1.000e+00 0.000e+00] [2.000e+00 0.000e+00] ]
-#        => #<GSL::Vector::Complex:0x75e614>
-#
-# == Poly class
-# This class expresses polynomials of arbitrary orders.
-#
-# === Constructors
-# ---
-# * GSL::Poly.alloc(c0, c1, c2, ....)
-# * GSL::Poly[c0, c1, c2, ....]
-#
-#   This creates an instance of the <tt>GSL::Poly</tt> class,
-#   which represents a polynomial
-#       c0 + c1 x + c2 x^2 + ....
-#   This class is derived from <tt>GSL::Vector</tt>.
-#
-#   * Ex: x^2 - 3 x + 2
-#       poly = GSL::Poly.alloc([2, -3, 1])
-#
-# === Instance Methods
-# ---
-# * GSL::Poly#eval(x)
-# * GSL::Poly#at(x)
-#
-#   Evaluates the polynomial
-#   <tt>c[0] + c[1] x + c[2] x^2 + ... + c[len-1] x^{len-1}</tt>
-#   using Horner's method for stability. The argument <tt>x</tt> is a
-#   <tt>Numeric</tt>, <tt>GSL::Vector, Matrix</tt> or an <tt>Array</tt>.
-#
-# ---
-# * GSL::Poly#solve_quadratic
-#
-#   Solve the quadratic equation.
-#
-#   * Ex:  z^2 - 3 z + 2 = 0:
-#       >> a = GSL::Poly[2, -3, 1]
-#       => GSL::Poly:
-#       [ 2.000e+00 -3.000e+00 1.000e+00 ]
-#       >> a.solve_quadratic
-#       => GSL::Vector:
-#       [ 1.000e+00 2.000e+00 ]
-#
-# ---
-# * GSL::Poly#solve_cubic
-#
-#   Solve the cubic equation.
-#
-# ---
-# * GSL::Poly#complex_solve
-# * GSL::Poly#solve
-# * GSL::Poly#roots
-#
-#   These methods find the complex roots of the quadratic equation,
-#     c0 + c1 z + c2 z^2 + .... = 0
-#
-#   * Ex: z^2 - 3 z + 2 = 0:
-#       >> a = GSL::Poly[2, -3, 1]
-#       => GSL::Poly:
-#       [ 2.000e+00 -3.000e+00 1.000e+00 ]
-#       >> a.solve
-#       [ [1.000e+00 0.000e+00] [2.000e+00 0.000e+00] ]
-#       => #<GSL::Vector::Complex:0x35db28>
-#
-# == Polynomial fitting
-# ---
-# * GSL::Poly.fit(x, y, order)
-# * GSL::Poly.wfit(x, w, y, order)
-#
-#   Finds the coefficient of a polynomial of order <tt>order</tt>
-#   that fits the vector data (<tt>x, y</tt>) in a least-square sense.
-#   This provides a higher-level interface to the method
-#   {GSL::Multifit#linear}[link:rdoc/fit_rdoc.html] in a case of polynomial fitting.
-#
-#   Example:
-#     #!/usr/bin/env ruby
-#     require("gsl")
-#
-#     x = GSL::Vector[1, 2, 3, 4, 5]
-#     y = GSL::Vector[5.5, 43.1, 128, 290.7, 498.4]
-#     # The results are stored in a polynomial "coef"
-#     coef, cov, chisq, status = Poly.fit(x, y, 3)
-#
-#     x2 = GSL::Vector.linspace(1, 5, 20)
-#     graph([x, y], [x2, coef.eval(x2)], "-C -g 3 -S 4")
-#
-# == Divided-difference representations
-#
-# ---
-# * GSL::Poly::dd_init(xa, ya)
-#
-#   This method computes a divided-difference representation of the
-#   interpolating polynomial for the points <tt>(xa, ya)</tt>.
-#
-# ---
-# * GSL::Poly::DividedDifference#eval(x)
-#
-#   This method evaluates the polynomial stored in divided-difference form
-#   <tt>self</tt> at the point <tt>x</tt>.
-#
-# ---
-# * GSL::Poly::DividedDifference#taylor(xp)
-#
-#   This method converts the divided-difference representation of a polynomial
-#   to a Taylor expansion. On output the Taylor coefficients of the polynomial
-#   expanded about the point <tt>xp</tt> are returned.
-#
-# == Extensions
-# === Special Polynomials
-# ---
-# * GSL::Poly.hermite(n)
-#
-#   This returns coefficients of the <tt>n</tt>-th order Hermite polynomial, <tt>H(x; n)</tt>.
-#   For order of <tt>n</tt> >= 3, this method uses the recurrence relation
-#        H(x; n+1) = 2 x H(x; n) - 2 n H(x; n-1)
-#   * Ex:
-#       >> GSL::Poly.hermite(2)
-#       => GSL::Poly::Int:
-#       [ -2 0 4 ]                            <----- 4x^2 - 2
-#       >> GSL::Poly.hermite(5)
-#       => GSL::Poly::Int:
-#       [ 0 120 0 -160 0 32 ]                 <----- 32x^5 - 160x^3 + 120x
-#       >> GSL::Poly.hermite(7)
-#       => GSL::Poly::Int:
-#       [ 0 -1680 0 3360 0 -1344 0 128 ]
-#
-# ---
-# * GSL::Poly.cheb(n)
-# * GSL::Poly.chebyshev(n)
-#
-#   Return the coefficients of the <tt>n</tt>-th order Chebyshev polynomial, <tt>T(x; n</tt>.
-#   For order of <tt>n</tt> >= 3, this method uses the recurrence relation
-#        T(x; n+1) = 2 x T(x; n) - T(x; n-1)
-#
-# ---
-# * GSL::Poly.cheb_II(n)
-# * GSL::Poly.chebyshev_II(n)
-#
-#   Return the coefficients of the <tt>n</tt>-th order Chebyshev polynomial of type II,
-#   <tt>U(x; n</tt>.
-#        U(x; n+1) = 2 x U(x; n) - U(x; n-1)
-#
-# ---
-# * GSL::Poly.bell(n)
-#
-#   Bell polynomial
-#
-# ---
-# * GSL::Poly.bessel(n)
-#
-#   Bessel polynomial
-#
-# ---
-# * GSL::Poly.laguerre(n)
-#
-#   Retunrs the coefficients of the <tt>n</tt>-th order Laguerre polynomial
-#   multiplied by n!.
-#
-#   Ex:
-#        rb(main):001:0> require("gsl")
-#        => true
-#        >> GSL::Poly.laguerre(0)
-#        => GSL::Poly::Int:
-#        [ 1 ]                              <--- 1
-#        >> GSL::Poly.laguerre(1)
-#        => GSL::Poly::Int:
-#        [ 1 -1 ]                           <--- -x + 1
-#        >> GSL::Poly.laguerre(2)
-#        => GSL::Poly::Int:
-#        [ 2 -4 1 ]                         <--- (x^2 - 4x + 2)/2!
-#        >> GSL::Poly.laguerre(3)
-#        => GSL::Poly::Int:
-#        [ 6 -18 9 -1 ]                     <--- (-x^3 + 9x^2 - 18x + 6)/3!
-#        >> GSL::Poly.laguerre(4)
-#        => GSL::Poly::Int:
-#        [ 24 -96 72 -16 1 ]                <--- (x^4 - 16x^3 + 72x^2 - 96x + 24)/4!
-#
-# === Polynomial Operations
-# ---
-# * GSL::Poly#conv
-# * GSL::Poly#deconv
-# * GSL::Poly#reduce
-# * GSL::Poly#deriv
-# * GSL::Poly#integ
-# * GSL::Poly#compan
-#
-#
-# {prev}[link:rdoc/complex_rdoc.html]
-# {next}[link:rdoc/sf_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#
-#