rb-gsl 1.16.0.5 → 1.16.0.6

data/rdoc/interp.rdoc

@@ -1,231 +0,0 @@
-#
-# = Interpolation
-# This chapter describes functions for performing interpolation.
-# The library provides a variety of interpolation methods, including
-# Cubic splines and Akima splines. The interpolation types are interchangeable,
-# allowing different methods to be used without recompiling. Interpolations can
-# be defined for both normal and periodic boundary conditions. Additional
-# functions are available for computing derivatives and integrals of
-# interpolating functions.
-#
-# 1. {Interpolation classes}[link:rdoc/interp_rdoc.html#label-Interpolation+Classes]
-# 1. {Initializing interpolation objects}[link:rdoc/interp_rdoc.html#label-Initializing+interpolation+objects]
-# 1. {Index Look-up and Acceleration}[link:rdoc/interp_rdoc.html#label-Index+Look-up+and+Acceleration]
-# 1. {Evaluation of Interpolating Functions}[link:rdoc/interp_rdoc.html#label-Evaluation+of+Interpolating+Functions]
-# 1. {Higher level interface: GSL::Spline class}[link:rdoc/interp_rdoc.html#label-Higher+level+interface]
-#    1. {Class initialization}[link:rdoc/interp_rdoc.html#label-Class+initialization]
-#    1. {Evaluation}[link:rdoc/interp_rdoc.html#label-Evaluation]
-#    1. {Finding and acceleration}[link:rdoc/interp_rdoc.html#label-Finding+and+acceleration]
-#
-# == Interpolation Classes
-# * GSL
-#   * Interp (class)
-#     * Accel (class)
-#   * Spline (class)
-#
-# == Initializing interpolation objects
-#
-# ---
-# * GSL::Interp.alloc(T, n)
-# * GSL::Interp.alloc(T, x, y)
-# * GSL::Interp.alloc(x, y)
-#
-#   These methods create an  interpolation object of type <tt>T</tt> for <tt>n</tt>
-#   data-points.
-#
-#   The library provides six types, which are specifiled by an identifier of a
-#   constant or a string:
-#
-#   * Interp::LINEAR or "linear"
-#
-#     Linear interpolation. This interpolation method does not require any additional memory.
-#   * Interp::POLYNOMIAL or "polynomial"
-#
-#     Polynomial interpolation. This method should only be used for interpolating small numbers of points because polynomial interpolation introduces large oscillations, even for well-behaved datasets. The number of terms in the interpolating polynomial is equal to the number of points.
-#
-#   * Interp::CSPLINE or "cspline"
-#
-#     Cubic spline with natural boundary conditions.
-#   * Interp::CSPLINE_PERIODIC or "gsl_cspline_periodic" or "cspline_periodic"
-#
-#     Cubic spline with periodic boundary conditions
-#   * Interp::AKIMA or "akima"
-#
-#     Non-rounded Akima spline with natural boundary conditions. This method uses the non-rounded corner algorithm of Wodicka.
-#   * Interp::AKIMA_PERIODIC or "akima_periodic"
-#
-#     Non-rounded Akima spline with periodic boundary conditions. This method uses the non-rounded corner algorithm of Wodicka.
-#
-#     * ex: For cubic spline for 10 points,
-#         sp = Interp.alloc("cspline", 10)
-#
-# ---
-# * GSL::Interp#init(xa, ya)
-#
-#   This method initializes the interpolation object interp for the data
-#   <tt>(xa,ya)</tt> where <tt>xa</tt> and <tt>ya</tt> are vectors.
-#   The interpolation object (<tt>GSL::Interp</tt>) does not save the data
-#   vectors <tt>xa, ya</tt> and only stores the static state computed from the data.
-#   The <tt>xa</tt> vector is always assumed to be strictly ordered; the behavior
-#   for other arrangements is not defined.
-#
-#
-# ---
-# * GSL::Interp#name
-#
-#   This returns the name of the interpolation type used by <tt>self</tt>.
-#
-#
-#
-# ---
-# * GSL::Interp#min_size
-#
-#   This returns the minimum number of points required by the interpolation
-#   type of <tt>self</tt>. For example, Akima spline interpolation requires
-#   a minimum of 5 points.
-#
-# == Index Look-up and Acceleration
-# ---
-# * GSL::Interp.bsearch(xa, x, index_lo, index_hi)
-#
-#   This returns the index i of the vector <tt>xa</tt> such that
-#   <tt>xa[i] <= x < x[i+1]</tt>. The index is searched for in the range
-#   <tt>[index_lo,index_hi]</tt>.
-#
-#
-# ---
-# * GSL::Interp#accel
-#
-#   In C level, the library requires a <tt>gsl_interp_accel</tt> object,
-#   but it is hidden in Ruby/GSL. It is automatically allocated
-#   when a <tt>GSL::Interp</tt> object is created, stored in it,
-#   and destroyed when the <tt>Interp</tt> object
-#   is cleaned by the Ruby GC.
-#   This method is used to access to the <tt>Interp::Accel</tt> object
-#   stored in <tt>self</tt>.
-#
-# ---
-# * GSL::Interp#find(xa, x)
-# * GSL::Interp#accel_find(xa, x)
-# * GSL::Interp::Accel#find(xa, x)
-#
-#   This method performs a lookup action on the data array <tt>xa</tt>.
-#   This is how lookups are performed during evaluation
-#   of an interpolation. The function returns an index <tt>i</tt> such that
-#   <tt>xa[i] <= x < xa[i+1]</tt>.
-#
-#
-# == Evaluation of Interpolating Functions
-#
-# ---
-# * GSL::Interp#eval(xa, ya, x)
-# * GSL::Interp#eval_e(xa, ya, x)
-#
-#   These methods return the interpolated value for a given point <tt>x</tt>,
-#   using the interpolation object <tt>self</tt>, data vectors <tt>xa</tt> and <tt>ya</tt>.
-#   The data <tt>x</tt> can be a <tt>Numeric, Vector, Matrix</tt> or an <tt>NArray</tt>.
-# ---
-# * GSL::Interp#eval_deriv(xa, ya, x)
-# * GSL::Interp#eval_deriv_e(xa, ya, x)
-#
-#   These methods return the derivative of an interpolated function for a
-#   given point <tt>x</tt>, using the interpolation object <tt>self</tt>,
-#   data vectors <tt>xa</tt> and <tt>ya</tt>.
-#
-# ---
-# * GSL::Interp#eval_deriv2(xa, ya, x)
-# * GSL::Interp#eval_deriv2_e(xa, ya, x)
-#
-#   These methods return the second derivative of an interpolated function
-#   for a given point <tt>x</tt>, using the interpolation object <tt>self</tt>,
-#   data vectors <tt>xa</tt> and <tt>ya</tt>.
-#
-# ---
-# * GSL::Interp#eval_integ(xa, ya, a, b)
-# * GSL::Interp#eval_integ_e(xa, ya, a, b)
-#
-#   These methods return the numerical integral result of an interpolated
-#   function over the range <tt>[a, b]</tt>, using the interpolation object <tt>self</tt>,
-#   data vectors <tt>xa</tt> and <tt>ya</tt>.
-#
-# == Higher level interface
-# === Class initialization
-#
-# ---
-# * GSL::Spline.alloc(T, n)
-# * GSL::Spline.alloc(T, x, y)
-# * GSL::Spline.alloc(x, y, T)
-#
-#   This creates a <tt>GSL::Spline</tt> object of type <tt>T</tt> for <tt>n</tt>
-#   data-points. The type <tt>T</tt> is the same as <tt>GSL::Interp</tt> class.
-#
-#   These two are equivalent.
-#   * <tt>GSL::Spline.alloc</tt> and <tt>GSL::Spline#init</tt>
-#       sp = GSL::Spline.alloc(T, n)
-#       sp.init(x, y)                 # x and y are vectors of length n
-#   * <tt>GSL::Spline.alloc</tt> with two vectors
-#       sp = GSL::Spline.alloc(T, x, y)
-#   If <tt>T</tt> is not given, "cspline" is used.
-#
-# ---
-# * GSL::Spline#init(xa, ya)
-#
-#   This initializes a <tt>GSL::Spline</tt> object <tt>self</tt> for the data
-#   (<tt>xa, ya</tt>) where <tt>xa</tt> and <tt>ya</tt> are Ruby arrays of equal sizes
-#   or <tt>GSL::Vector</tt>.
-#
-# ---
-# * GSL::Spline#name
-#
-#   This returns the name of the spline type used by <tt>self</tt>.
-#
-# === Evaluation
-# ---
-# * GSL::Spline#eval(x)
-#
-#   This returns the interpolated value for a given point <tt>x</tt>.
-#   The data <tt>x</tt> can be a <tt>Numeric, Vector, Matrix</tt> or an <tt>NArray</tt>.
-#
-#   NOTE: In a GSL-C program, a <tt>gsl_interp_accel</tt> object is required to use
-#   the function <tt>gsl_spline_eval</tt>.
-#   In Ruby/GSL, the <tt>gsl_interp_accel</tt> is hidden, it is automatically
-#   allocated when a <tt>GSL::Spline</tt> object is created,
-#   and also destroyed when the <tt>Spline</tt> object
-#   is cleaned by the Ruby GC. The accel object can be accessed via the method
-#   <tt>GSL::Spline#accel</tt>.
-#
-# ---
-# * GSL::Spline#eval_deriv(x)
-#
-#   This returns the derivative of an interpolated function for a given point <tt>x</tt>, usingthe data arrays <tt>xa</tt> and <tt>ya</tt> set by <tt>init</tt>.
-#
-# ---
-# * GSL::Spline#eval_deriv2(x)
-#
-#   This returns the second derivative at <tt>x</tt>.
-#
-# ---
-# * GSL::Spline#eval_integ(a, b)
-#
-#   Returns the numerical integral over the range [<tt>a, b</tt>].
-#
-# === Finding and acceleration
-# ---
-# * GSL::Spline#find(xa, x)
-# * GSL::Spline#accel_find(xa, x)
-#
-#   This method performs a lookup action on the data array <tt>xa</tt>.
-#   This is how lookups are performed during evaluation
-#   of an interpolation. The function returns an index <tt>i</tt> such that
-#   <tt>xa[i] <= x < xa[i+1]</tt>.
-#
-# See also the GSL manual and the examples in <tt>examples/</tt>
-#
-# {prev}[link:rdoc/odeiv_rdoc.html]
-# {next}[link:rdoc/diff_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#
-#

data/rdoc/intro.rdoc

@@ -1,27 +0,0 @@
-#
-# = Introduction
-#
-# The GNU Scientific Library ({GSL}[https://gnu.org/software/gsl/])
-# is a collection of routines for numerical computing.
-# The routines have been written from scratch in C, and present a modern Applications
-# Programming Interface (API) for C programmers, allowing wrappers to be
-# written for very  high level languages. The source code is distributed
-# under the GNU General Public License.
-#
-# {Ruby/GSL}[https://sciruby.github.com/rb-gsl] is a Ruby
-# extension for GSL. This provides higher-level interfaces to the GSL functions.
-#
-# == Requirements
-# * GSL (1.4 or later recommended)
-# * ANSI C compiler
-# * Ruby (1.8 or later recommended)
-#
-# == Installation
-# See {here}[link:index.html].
-#
-# {next}[link:rdoc/use_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#

data/rdoc/linalg.rdoc

@@ -1,681 +0,0 @@
-#
-# = Linear Algebra
-#
-# Contents:
-# 1. {LU Decomposition}[link:rdoc/linalg_rdoc.html#label-LU+Decomposition]
-# 1. {QR Decomposition}[link:rdoc/linalg_rdoc.html#label-QR+decomposition]
-# 1. {QR Decomposition with Column Pivoting}[link:rdoc/linalg_rdoc.html#label-QR+Decomposition+with+Column+Pivoting]
-# 1. {Singular Value Decomposition}[link:rdoc/linalg_rdoc.html#label-Singular+Value+Decomposition]
-# 1. {Cholesky Decomposition}[link:rdoc/linalg_rdoc.html#label-Cholesky+Decomposition]
-# 1. {Tridiagonal Decomposition of Real Symmetric Matrices}[link:rdoc/linalg_rdoc.html#label-Tridiagonal+Decomposition+of+Real+Symmetric+Matrices]
-# 1. {Tridiagonal Decomposition of Hermitian Matrices}[link:rdoc/linalg_rdoc.html#label-Tridiagonal+Decomposition+of+Hermitian+Matrices]
-# 1. {Hessenberg Decomposition of Real Matrices}[link:rdoc/linalg_rdoc.html#label-Hessenberg+Decomposition+of+Real+Matrices]
-# 1. {Hessenberg-Triangular Decomposition of Real Matrices}[link:rdoc/linalg_rdoc.html#label-Hessenberg-Triangular+Decomposition+of+Real+Matrices]
-# 1. {Bidiagonalization}[link:rdoc/linalg_rdoc.html#label-Bidiagonalization]
-# 1. {Householder Transformations}[link:rdoc/linalg_rdoc.html#label-Householder+Transformations]
-# 1. {Householder solver for linear systems}[link:rdoc/linalg_rdoc.html#label-Householder+solver+for+linear+systems]
-# 1. {Tridiagonal Systems}[link:rdoc/linalg_rdoc.html#label-Tridiagonal+Systems]
-# 1. {Balancing}[link:rdoc/linalg_rdoc.html#label-Balancing]
-# 1. {NArray}[link:rdoc/linalg_rdoc.html#label-NArray]
-#
-# == LU Decomposition
-# ---
-# * GSL::Linalg::LU.decomp(A)
-# * GSL::Matrix#LU_decomp
-#
-#   These method calculate the LU decomposition of the matrix. The returned
-#   value is an array of <tt>[LU, perm, sign]</tt>.
-#
-#   Examples:
-#
-# 1. Singleton method of the <tt>GSL::Linalg::LU</tt> module
-#
-#         >> m = Matrix[1..9, 3, 3]
-#         => GSL::Matrix:
-#         [ 1.000e+00 2.000e+00 3.000e+00
-#           4.000e+00 5.000e+00 6.000e+00
-#           7.000e+00 8.000e+00 9.000e+00 ]
-#         >> lu, perm, sign = Linalg::LU.decomp(m)
-#
-# 1. Instance method of <tt>GSL::Matrix</tt> class
-#
-#         >> lu, perm, sign = m.LU_decomp
-#
-# ---
-# * GSL::Linalg::LU.solve(A, b)
-# * GSL::Linalg::LU.solve(lu, perm, b)
-# * GSL::Matrix#LU_solve(b)
-# * GSL::Linalg::LUMatrix#solve(perm, b)
-#
-#   The following is an example to solve a linear system
-#
-#      A x = b, b = [1, 2, 3, 4]
-#
-#   using LU decomposition.
-#
-# 1. Singleton method of the <tt>GSL::Linalg::LU</tt> module
-#
-#         A = Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58],
-#                    [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]]
-#         lu, perm, sign = A.LU_decomp
-#         b = Vector[1, 2, 3, 4]
-#         x = Linalg::LU.solve(lu, perm, b)
-#
-# 1. Instance method of <tt>GSL::Linalg::LUMatrix</tt> class
-#
-#         lu, perm, sign = A.LU_decomp  # lu is an instance of Linalg::LUMatrix class
-#         b = Vector[1, 2, 3, 4]
-#         x = lu.solve(perm, b)
-#
-# 1. Solve directly
-#
-#         x = Linalg::LU.solve(A, b)  # LU decomposition is calculated internally (A is not modified)
-#
-# ---
-# * GSL::Linalg::LU.svx(A, b)
-# * GSL::Linalg::LU.svx(lu, perm, b)
-# * GSL::Matrix#svx(b)
-# * GSL::Linalg::LUMatrix#svx(perm, b)
-#
-#   These solve the system Ax = b. The input vector <tt>b</tt> is overwitten by
-#   the solution <tt>x</tt>.
-#
-# ---
-# * GSL::Linalg::LU.refine(A, lu, perm, b, x)
-#
-#   This method applys an iterative improvement to <tt>x</tt>,
-#   the solution of <tt>A x = b</tt>, using the LU decomposition of <tt>A</tt>.
-#
-# ---
-# * GSL::Linalg::LU.invert(A)
-# * GSL::Linalg::LU.invert(lu, perm)
-# * GSL::Matrix#invert
-# * GSL::Linalg::LUMatrix#invert(perm)
-#
-#   These computes and returns the inverse of the matrix.
-#
-# ---
-# * GSL::Linalg::LU.det(A)
-# * GSL::Linalg::LU.det(lu, signum)
-# * GSL::Matrix#det
-# * GSL::Linalg::LUMatrix#det(signum)
-#
-#   These methods return the determinant of the matrix.
-#
-# === {Complex LU decomposition}[link:rdoc/linalg_complex_rdoc.html]
-#
-# == QR decomposition
-#
-# ---
-# * GSL::Linalg::QR_decomp(A)
-# * GSL::Linalg::QR.decomp(A)
-# * GSL::Matrix#QR_decomp
-#
-#   These compute QR decomposition of the matrix and return an array [QR, tau].
-#
-# 1. Singleton method of the module <tt>GSL::Linalg</tt>
-#         qr, tau = Linalg::QR_decomp(m)
-#         p qr.class                 # GSL::Linalg::QRMatrix, subclass of GSL::Matrix
-#         p tau.class                # GSL::Linalg::TauVector, subclass of GSL::Vector
-# 1. Singleton method of the module <tt>GSL::Linalg:QR</tt>
-#         qr, tau = Linalg::QR.decomp(m)
-# 1. Instance method of <tt>GSL::Matrix</tt>
-#         qr, tau = m.QR_decomp
-#
-# ---
-# * GSL::Linalg::QR.solve(A, b)
-# * GSL::Linalg::QR.solve(QR, tau, b)
-# * GSL::Matrix#QR_solve(b)
-# * GSL::Linalg::QRMatrix#solve(tau, b)
-#
-#   Solve the system A x = b using the QR decomposition.
-#
-#   * Ex1:
-#       m = Matrix.alloc(...)
-#       b = Vector.alloc(...)
-#       x = Linalg::QR.solve(m, b)
-#   * Ex2:
-#       x = m.QR_solve(b)
-#   * Ex3:
-#       qr, tau = Linalg::QR.decomp(m)   # or m.QR_decomp
-#       x = Linalg::QR.solve(qr, tau, b)
-#   * Ex4:
-#       qr, tau = m.QR_decomp
-#       x = qr.solve(tau, b)
-#
-# ---
-# * GSL::Linalg::QR.svx(A, x)
-# * GSL::Linalg::QR.svx(QR, tau, x)
-# * GSL::Matrix#QR_svx(x)
-# * GSL::Linalg::QRMatrix#svx(tau, x)
-#
-#   Solve the system A x = b. The input vector <tt>x</tt> is first give by
-#   the right-hand side vector <tt>b</tt>, and is overwritten by the solution.
-#
-# ---
-# * GSL::Linalg::QR.unpack(QR, tau)
-# * GSL::Linalg::QRMatrix#unpack(tau)
-#
-#   Unpack the encoded QR decomposition <tt>QR,tau</tt> and return an array
-#   <tt>[Q, R]</tt>.
-#
-#   Ex:
-#     >> m = Matrix[1..9, 3, 3]
-#     => GSL::Matrix:
-#     [ 1.000e+00 2.000e+00 3.000e+00
-#       4.000e+00 5.000e+00 6.000e+00
-#       7.000e+00 8.000e+00 9.000e+00 ]
-#     >> qr, tau = m.QR_decomp
-#     >> q, r = qr.unpack(tau)
-#     >> q*r               # Reconstruct the metrix m
-#     => GSL::Matrix:
-#     [ 1.000e+00 2.000e+00 3.000e+00
-#       4.000e+00 5.000e+00 6.000e+00
-#       7.000e+00 8.000e+00 9.000e+00 ]
-#
-# ---
-# * GSL::Linalg::QR.QRsolve(Q, R, tau)
-#
-#   This method solves the system <tt>R x = Q^T b</tt> for <tt>x</tt>.
-#   It can be used when the QR decomposition of a matrix is available
-#   in unpacked form as <tt>Q,R</tt>.
-#
-# == QR Decomposition with Column Pivoting
-# ---
-# * GSL::Linalg::QRPT.decomp(A)
-# * GSL::Matrix#QRPT_decomp
-#
-#   These methods factorize the M-by-N matrix <tt>A</tt> into the QRP^T decomposition A = Q R P^T, and return an array <tt>[QR, tau, perm, signum]</tt>.
-#
-#   * Ex1:
-#       require("gsl")
-#       include GSL::Linalg
-#       m = Matrix.alloc(...)
-#       qr, tau, perm = QRPT.decomp(m)
-#       p qr.class                 # GSL::Linalg::QRPTMatrix, subclass of GSL::Matrix
-#
-#   * Ex2:
-#       qr, tau, perm = m.QROT_decomp
-#
-# ---
-# * GSL::Linalg::QRPT.decomp2(A)
-# * GSL::Matrix#QRPT_decomp2
-#
-#   These return an array <tt>[Q, R, tau, perm, signum]</tt>.
-#
-#   * Ex
-#       q, r, tau, perm = QRPT.decomp2(m)
-#       p q.class                  <----- GSL::Linalg::QMatrix
-#       p r.class                  <----- GSL::Linalg::RMatrix
-#
-# ---
-# * GSL::Linalg::QRPT.solve(m, b)
-# * GSL::Linalg::QRPT.solve(qr, tau, perm, b)
-# * GSL::Matrix#QRPT_solve(A, b)
-# * GSL::Linalg::QRPQMatrix#solve(qr, tau, perm, b)
-#
-#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of
-#   <tt>A</tt> into <tt>QR, tau, perm</tt>. The solution <tt>x</tt> is returned as a Vector.
-#
-#   * Ex1:
-#       m = Matrix.alloc(...)
-#       qr, tau, perm = m.QRPT_decomp
-#       b = Vector.alloc([1, 2, 3, 4])
-#       x = Linalg::QRPT.solve(qr, tau, perm, b)
-#   * Ex2:
-#       x = Linalg::QRPT.solve(m, b)
-#   * Ex3:
-#       x = qr.solve(tau, p, b)
-#   * Ex4:
-#       x = m.QRPT_solve(b)
-#
-# ---
-# * GSL::Linalg::QRPT.svx(m, b)
-# * GSL::Linalg::QRPT.svx(qr, tau, perm, b)
-# * GSL::Matrix#QRPT_svx(A, b)
-#
-#   These methods solve the system <tt>A x = b</tt> using the QRP^T decomposition of
-#   <tt>A</tt> into <tt>QR, tau, perm</tt>. The input <tt>b</tt> is overwritten by the solution
-#   <tt>x</tt>.
-#
-# ---
-# * GSL::Linalg::QRPT.QRsolve(q, r, tau, perm, b)
-#
-#   This method solves the system <tt>R P^T x = Q^T b</tt> for x.
-#   It can be used when the QR decomposition of a matrix is available in
-#   unpacked form as <tt>q, r</tt> obtained by the method <tt>decomp2</tt>.
-#
-#   * Ex:
-#      q, r, tau, perm = QRPT_decomp2
-#      x = Linalg::QRPT.QRsolve(q, r, perm, b)
-#
-# ---
-# * GSL::Linalg::QRPT.update(q, r, perm, u, v)
-# * GSL::Linalg::QRPT.Rsolve(qr, perm, b)
-# * GSL::Linalg::QRPTMatrix#Rsolve(perm, b)
-# * GSL::Linalg::QRPT.Rsvx(qr, perm, b)
-# * GSL::Linalg::QRPTMatrix#Rsvx(perm, b)
-#
-#
-# == Singular Value Decomposition
-# ---
-# * GSL::Linalg::SV.decomp(A[, work])
-# * \GSL::Matrix#SV_decomp([work])
-#
-#   These methods factorize the M-by-N matrix <tt>A</tt> into the singular value
-#   decomposition <tt>A = U S V^T</tt> using  the Golub-Reinsch SVD algorithm,
-#   and return an array <tt>[U, V, S]</tt>.
-#
-#   Ex:
-#      >> m = Matrix[[3, 5, 2], [5, 1, 4], [7, 6, 3]]
-#      => GSL::Matrix:
-#      [ 3.000e+00 5.000e+00 2.000e+00
-#        5.000e+00 1.000e+00 4.000e+00
-#        7.000e+00 6.000e+00 3.000e+00 ]
-#      >> u, v, s = m.SV_decomp  # u, v: Matrix, s: Vector (singular values)
-#      >> u*u.trans              # u is orthnormal
-#      => GSL::Matrix:
-#      [  1.000e+00  2.452e-17 -4.083e-16
-#         2.452e-17  1.000e+00 -3.245e-16
-#        -4.083e-16 -3.245e-16  1.000e+00 ]
-#      >> v*v.trans              # v is also orthnormal
-#      => GSL::Matrix:
-#      [  1.000e+00  3.555e-17 -1.867e-16
-#         3.555e-17  1.000e+00 -1.403e-16
-#        -1.867e-16 -1.403e-16  1.000e+00 ]
-#      >> u*Matrix.diagonal(s)*v.trans # Reconstruct the matrix
-#      => GSL::Matrix:
-#      [ 3.000e+00 5.000e+00 2.000e+00
-#        5.000e+00 1.000e+00 4.000e+00
-#        7.000e+00 6.000e+00 3.000e+00 ]
-#
-# ---
-# * GSL::Linalg::SV.decomp_mod(A)
-# * GSL::Matrix#SV_decomp_mod
-#
-#   These compute the SVD using the modified Golub-Reinsch algorithm,
-#   which is faster for M>>N.
-#
-# ---
-# * GSL::Linalg::SV.decomp_jacobi(A)
-# * GSL::Matrix#SV_decomp_jacobi
-#
-#   These compute the SVD using one-sided Jacobi orthogonalization.
-#   The Jacobi method can compute singular values to higher relative accuracy
-#   than Golub-Reinsch algorithms.
-#
-# ---
-# * GSL::Linalg::SV.solve(A, b)
-# * GSL::Linalg::SV.solve(U, V, S, b)
-# * GSL::Matrix#SV_solve(b)
-#
-#   These methods solve the system <tt>A x = b</tt> using the singular value
-#   decomposition <tt>U, S, V</tt> of <tt>A</tt>.
-#
-#   * Ex1:
-#       m = Matrix.alloc(...)
-#       b = Vector.alloc(...)
-#       u, v, s = GSL::Linalg::SV.decomp(m)
-#       x = GSL::Linalg::SV.solve(u, v, s, b)
-#   * Ex2:
-#       x = GSL::Linalg::SV.solve(m, b)
-#   * Ex3:
-#       x = m.SV_solve(b)
-#
-# == Cholesky Decomposition
-# A symmetric, positive definite square matrix <tt>A</tt> has a Cholesky decomposition
-# into a product of a lower triangular matrix L and its transpose L^T,
-# as <tt>A = L 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 (<tt>L y = b, L^T x = y</tt>),
-# which can be solved by forward and back-substitution.
-#
-# ---
-# * GSL::Linalg::Cholesky.decomp(A)
-#
-#   This method factorizes the positive-definite square matrix <tt>A</tt>
-#   into the Cholesky decomposition <tt>A = L L^T</tt>.
-#   The upper triangular part of the matrix returned contains L^T, the diagonal terms
-#   being identical for both L and L^T. If the matrix is not positive-definite
-#   then the decomposition will fail.
-#
-#   Ex:
-#     >> m = Matrix.pascal(3)
-#     => GSL::Matrix
-#     [  1.000e+00  1.000e+00  1.000e+00
-#        1.000e+00  2.000e+00  3.000e+00
-#        1.000e+00  3.000e+00  6.000e+00 ]
-#     >> c = Linalg::Cholesky.decomp(m)
-#     => GSL::Linalg::Cholesky::CholeskyMatrix
-#     [  1.000e+00  1.000e+00  1.000e+00
-#        1.000e+00  1.000e+00  2.000e+00
-#        1.000e+00  2.000e+00  1.000e+00 ]
-#     >> l = c.lower
-#     => GSL::Matrix
-#     [  1.000e+00  0.000e+00  0.000e+00
-#        1.000e+00  1.000e+00  0.000e+00
-#        1.000e+00  2.000e+00  1.000e+00 ]
-#     >> (l*l.trans) == m
-#     => true
-#
-# ---
-# * GSL::Linalg::Cholesky.solve(cholesky, b)
-# * GSL::Linalg::Cholesky.svx(cholesky, x)
-#
-#   These methods solve the system <tt>A x = b</tt> using the Cholesky decomposition
-#   of <tt>A</tt> into the matrix <tt>cholesky</tt> given by <tt>GSL::Linalg::Cholesky.decomp</tt>.
-#
-# === {Complex Cholesky decomposition}[link:rdoc/cholesky_complex_rdoc.html]
-#
-# == Tridiagonal Decomposition of Real Symmetric Matrices
-# ---
-# * GSL::Linalg::Symmtd::decomp(A)
-#
-#   Factorizes the symmetric square matrix <tt>A</tt> into the symmetric
-#   tridiagonal decomposition Q T Q^T, and returns the results
-#   <tt>(A', tau)</tt>. On output the diagonal and subdiagonal part of the
-#   matrix <tt>A'</tt>  contain the tridiagonal matrix <tt>T</tt>.
-#   The remaining lower triangular part of the matrix <tt>A'</tt> contains
-#   the Householder vectors which, together with the Householder
-#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>.
-#   This storage scheme is the same as used by LAPACK.
-#   The upper triangular part of <tt>A</tt> is not referenced.
-# ---
-# * GSL::Linalg::Symmtd::unpack(A', tau)
-#
-#   Unpacks the encoded symmetric tridiagonal decomposition <tt>(A', tau)</tt>
-#   obtained from <tt>GSL::Linalg::Symmtd::decomp</tt> into the orthogonal
-#   matrix <tt>Q</tt>, the vector of diagonal elements <tt>diag</tt>
-#   and the vector of subdiagonal elements <tt>subdiag</tt>.
-# ---
-# * GSL::Linalg::Symmtd::unpack_T(A', tau)
-#
-#   Unpacks the diagonal and subdiagonal of the encoded symmetric tridiagonal
-#   decomposition <tt>(A', tau)</tt> obtained from
-#   <tt>GSL::Linalg::Symmtd::decomp</tt> into the vectors
-#   <tt>diag</tt> and <tt>subdiag</tt>.
-#
-# == Tridiagonal Decomposition of Hermitian Matrices
-# ---
-# * GSL::Linalg::Hermtd::decomp(A)
-#
-#   Factorizes the hermitian matrix <tt>A</tt> into the symmetric tridiagonal
-#   decomposition U T U^T, and returns the result as <tt>(A', tau)</tt>.
-#   On output the real parts of the diagonal and subdiagonal part of the
-#   matrix <tt>A'</tt> contain the tridiagonal matrix <tt>T</tt>.
-#   The remaining lower triangular part of the matrix <tt>A'</tt> contains
-#   the Householder vectors which, together with the Householder
-#   coefficients <tt>tau</tt>, encode the orthogonal matrix <tt>Q</tt>.
-#   This storage scheme is the same as used by LAPACK.
-#   The upper triangular part of <tt>A</tt> and imaginary parts of the diagonal
-#   are not referenced.
-#
-# ---
-# * GSL::Linalg::Hermtd::unpack(A', tau)
-#
-#   Unpacks the encoded tridiagonal decomposition <tt>(A', tau)</tt>
-#   obtained from <tt>GSL::Linalg::Hermtd::decomp</tt> into the unitary matrix
-#   <tt>U</tt>, the real vector of diagonal elements <tt>diag</tt> and
-#   the real vector of subdiagonal elements <tt>subdiag</tt>.
-#
-# ---
-# * GSL::Linalg::Hermtd::unpack_T(A', tau)
-#
-#   Unpacks the diagonal and subdiagonal of the encoded tridiagonal
-#   decomposition <tt>(A, tau)</tt> obtained from the
-#   <tt>GSL::Linalg::Hermtd::decomp</tt>
-#   into the real vectors <tt>diag</tt> and <tt>subdiag</tt>.
-#
-# == Hessenberg Decomposition of Real Matrices
-# ---
-# * GSL::Linalg::Hessenberg::decomp(A)
-# * GSL::Linalg::hessenberg_decomp(A)
-#
-#   Computes the Hessenberg decomposition of the matrix <tt>A</tt>
-#   by applying the similarity transformation <tt>H = U^T A U</tt>, and returns
-#   the result as <tt>(A', tau</tt>. On output, <tt>H</tt> is stored in the upper
-#   portion of <tt>A'</tt>. The information required to construct the matrix
-#   <tt>U</tt> is stored in the lower triangular portion of <tt>A'</tt>.
-#   <tt>U</tt> is a product of N - 2 Householder matrices.
-#   The Householder vectors are stored in the lower portion of <tt>A'</tt>
-#   (below the subdiagonal) and the Householder coefficients are stored
-#   in the vector <tt>tau</tt>.
-#
-# ---
-# * GSL::Linalg::Hessenberg::unpack(A', tau)
-# * GSL::Linalg::hessenberg_unpack(A', tau)
-#
-#   Constructs the orthogonal matrix <tt>U</tt> and returns it
-#   from the information stored  in the Hessenberg matrix <tt>A'</tt>
-#   along with the vector <tt>tau</tt>. <tt>A'</tt> and <tt>tau</tt>
-#   are outputs from <tt>GSL::Linalg::Hessenberg::decomp</tt>.
-#
-# ---
-# * GSL::Linalg::Hessenberg::unpack_accum(A', tau, V = I)
-# * GSL::Linalg::hessenberg_unpack_accum(A', tau, V = I)
-#
-#   This method is similar to <tt>GSL::Linalg::Hessenberg::unpack</tt>,
-#   except it accumulates the matrix <tt>U</tt> into <tt>V</tt>, so that
-#   <tt>V' = VU</tt>, and returns <tt>V</tt>. Setting V to the identity matrix
-#   provides the same result <tt>GSL::Linalg::Hessenberg::unpack</tt>.
-#
-# ---
-# * GSL::Linalg::Hessenberg::set_zero(A')
-# * GSL::Linalg::hessenberg_set_zero(A')
-#
-#   Sets the lower triangular portion of <tt>A'</tt>, below the subdiagonal,
-#   to zero.
-#   It is useful for clearing out the Householder vectors after calling
-#   <tt>GSL::Linalg::Hessenberg::decomp</tt>.
-#
-# == Hessenberg-Triangular Decomposition of Real Matrices
-# ---
-# * GSL::Linalg::hesstri_decomp(A, B)
-# * GSL::Linalg::hesstri_decomp(A, B, work)
-# * GSL::Linalg::hesstri_decomp(A, B, U, V)
-# * GSL::Linalg::hesstri_decomp(A, B, U, V, work)
-#
-#   Compute the Hessenberg-Triangular decomposition of the matrix pair
-#   <tt>(A, B)</tt>, and return <tt>(H, R</tt>.
-#   If U and V are provided (they may be null), the similarity
-#   transformations are stored in them. <tt>work</tt> is an additional workspace
-#   of length <tt>N</tt>.
-#
-# ---
-# * GSL::Linalg::hesstri_decomp!(A, B)
-# * GSL::Linalg::hesstri_decomp!(A, B, work)
-# * GSL::Linalg::hesstri_decomp!(A, B, U, V)
-# * GSL::Linalg::hesstri_decomp!(A, B, U, V, work)
-#
-#   Compute the Hessenberg-Triangular decomposition of the matrix pair
-#   <tt>(A, B)</tt>. On output, <tt>H</tt> is stored in <tt>A</tt>,
-#   and <tt>R</tt> is stored in <tt>B</tt>.
-#   If U and V are provided (they may be null), the similarity
-#   transformations are stored in them. <tt>work</tt> is an additional workspace
-#   of length <tt>N</tt>.
-#
-# == Bidiagonalization
-# ---
-# * GSL::Linalg::Bidiag::decomp!(A)
-# * GSL::Linalg::bidiag_decomp!(A)
-# * GSL::Linalg::Bidiag::decomp(A)
-# * GSL::Linalg::bidiag_decomp(A)
-#
-#
-# ---
-# * GSL::Linalg::Bidiag::unpack
-# * GSL::Linalg::bidiag_unpack
-# * GSL::Linalg::Bidiag::unpack2
-# * GSL::Linalg::bidiag_unpack2
-# * GSL::Linalg::Bidiag::unpack_B
-# * GSL::Linalg::bidiag_unpack_B
-#
-#
-# == Householder Transformations
-# ---
-# * GSL::Linalg::Householder::transform(v)
-# * GSL::Linalg::HH::transform(v)
-# * GSL::Vector#householder_transform
-#
-#   These methods prepare a Householder transformation P = I - tau v v^T
-#   which can be used to zero all the elements of the input vector except the first.
-#   On output the transformation is stored in the vector <tt>v</tt>
-#   and the scalar tau is returned.
-#
-# ---
-# * GSL::Linalg::Householder::hm(tau, v, A)
-# * GSL::Linalg::HH::hm(tau, v, A)
-#
-#   These methods apply the Householder matrix P defined by the scalar
-#   <tt>tau</tt> and the vector <tt>v</tt> to the left-hand side of the matrix <tt>A</tt>.
-#   On output the result P A is stored in <tt>A</tt>.
-#
-# ---
-# * GSL::Linalg::Householder::mh(tau, v, A)
-# * GSL::Linalg::HH::mh(tau, v, A)
-#
-#   These methods apply the Householder matrix P defined by the scalar <tt>tau</tt>
-#   and the vector <tt>v</tt> to the right-hand side of the matrix <tt>A</tt>.
-#   On output the result A P is stored in <tt>A</tt>.
-#
-# ---
-# * GSL::Linalg::Householder::hv(tau, v, w)
-# * GSL::Linalg::HH::hv(tau, v, w)
-#
-#   These methods apply the Householder transformation P defined by the scalar
-#   <tt>tau</tt> and the vector <tt>v</tt> to the vector <tt>w</tt>.
-#   On output the result P w is stored in <tt>w</tt>.
-#
-# == Householder solver for linear systems
-# ---
-# * GSL::Linalg::HH.solve(A, b)
-# * GSL::Matrix#HH_solve(b)
-#
-#   These methods solve the system <tt>A x = b</tt> directly using Householder
-#   transformations. The matrix <tt>A</tt> is not modified.
-# ---
-# * GSL::Linalg::HH.solve!(A, b)
-# * GSL::Matrix#HH_solve!(b)
-#
-#   These methods solve the system <tt>A x = b</tt> directly using Householder
-#   transformations. The matrix <tt>A</tt> is destroyed by the
-#   Householder transformations.
-#
-# ---
-# * GSL::Linalg::HH.svx(A, b)
-# * GSL::Matrix#HH_svx(b)
-#
-#   These methods solve the system <tt>A x = b</tt> in-place directly using Householder
-#   transformations. The input vector <tt>b</tt> is replaced by the solution.
-#
-# == Tridiagonal Systems
-# ---
-# * GSL::Linglg::solve_tridiag(diag, e, f, b)
-# * GSL::Linglg::Tridiag::solve(diag, e, f, b)
-#
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt>
-#   is tridiagonal ( N >= 2). The super-diagonal and sub-diagonal vectors <tt>e</tt>
-#   and <tt>f</tt> must be one element shorter than the diagonal vector <tt>diag</tt>.
-#   The form of <tt>A</tt> for the 4-by-4 case is shown below,
-#        A = ( d_0 e_0  0   0  )
-#            ( f_0 d_1 e_1  0  )
-#            (  0  f_1 d_2 e_2 )
-#            (  0   0  f_2 d_3 )
-#
-# ---
-# * GSL::Linglg::solve_symm_tridiag(diag, e, b)
-# * GSL::Linglg::Tridiag::solve_symm(diag, e, b)
-#
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is
-#   symmetric tridiagonal ( N >= 2). The off-diagonal vector <tt>e</tt> must
-#   be one element shorter than the diagonal vector <tt>diag</tt>.
-#   The form of <tt>A</tt> for the 4-by-4 case is shown below,
-#        A = ( d_0 e_0  0   0  )
-#            ( e_0 d_1 e_1  0  )
-#            (  0  e_1 d_2 e_2 )
-#            (  0   0  e_2 d_3 )
-#
-# ---
-# * GSL::Linglg::solve_cyc_tridiag(diag, e, f, b)
-# * GSL::Linglg::Tridiag::solve_cyc(diag, e, f, b)
-#
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt> is
-#   cyclic tridiagonal ( N >= 3). The cyclic super-diagonal and sub-diagonal
-#   vectors <tt>e</tt> and <tt>f</tt> must have the same number of elements as the
-#   diagonal vector <tt>diag</tt>. The form of <tt>A</tt> for the 4-by-4 case is shown below,
-#        A = ( d_0 e_0  0  f_3 )
-#            ( f_0 d_1 e_1  0  )
-#            (  0  f_1 d_2 e_2 )
-#            ( e_3  0  f_2 d_3 )
-#
-# ---
-# * GSL::Linglg::solve_symm_cyc_tridiag(diag, e, b)
-# * GSL::Linglg::Tridiag::solve_symm_cyc(diag, e, b)
-#
-#   These methods solve the general N-by-N system A x = b where <tt>A</tt>
-#   is symmetric cyclic tridiagonal ( N >= 3). The cyclic off-diagonal vector <tt>e</tt>
-#   must have the same number of elements as the diagonal vector <tt>diag</tt>.
-#   The form of <tt>A</tt> for the 4-by-4 case is shown below,
-#        A = ( d_0 e_0  0  e_3 )
-#            ( e_0 d_1 e_1  0  )
-#            (  0  e_1 d_2 e_2 )
-#            ( e_3  0  e_2 d_3 )
-#
-# == Balancing
-# The process of balancing a matrix applies similarity transformations to
-# make the rows and columns have comparable norms. This is useful,
-# for example, to reduce roundoff errors in the solution of eigenvalue problems.
-# Balancing a matrix <tt>A</tt> consists of replacing <tt>A</tt> with a similar matrix
-# where <tt>D</tt> is a diagonal matrix whose entries are powers of the floating
-# point radix.
-#
-# ---
-# * GSL::Linalg::balance(A)
-# * GSL::Linalg::balance(A, D)
-#
-#   Calculates the balanced counterpart of <tt>A</tt> and the diagonal elements
-#   of the similarity transformation. The result is returned as <tt>(A', D)</tt>.
-#
-# ---
-# * GSL::Linalg::balance!(A)
-# * GSL::Linalg::balance!(A, D)
-#
-#   Replaces the matrix <tt>A</tt> with its balanced counterpart and
-#   stores the diagonal elements of the similarity transformation into
-#   the vector <tt>D</tt>.
-#
-#
-# == NArray
-# The following Linalg methods can handle NArray objects:
-# * GSL::Linalg::
-#   * LU::
-#     * LU.decomp(m)
-#     * LU.solve(lu, b)
-#     * LU.svx(lu, bx)
-#     * LU.det(lu, sign)
-#     * LU.lndet(lu)
-#     * LU.invert(lu, perm)
-#   * QR::
-#     * QR.decomp(m)
-#     * QR.solve(qr, tau, b)
-#     * QR.svx(qr, tau, bx)
-#   * SV::
-#     * SV.decomp(m)
-#     * SV.solve(u, v, s, b)
-#     * SV.svx(u, v, s, bx)
-#   * Cholesky::
-#     * Cholesky.decomp(m)
-#     * Cholesky.solve(u, v, s, b)
-#     * Cholesky.svx(u, v, s, bx)
-#   * HH::
-#     * HH.solve(m, b)
-#     * HH.svx(m, bx)
-#
-# {prev}[link:rdoc/blas_rdoc.html]
-# {next}[link:rdoc/eigen_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#