gsl 1.12.109 → 1.14.5

data/rdoc/interp.rdoc

@@ -0,0 +1,231 @@
+#
+# = 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:files/rdoc/interp_rdoc.html#1]
+# 1. {Initializing interpolation objects}[link:files/rdoc/interp_rdoc.html#2]
+# 1. {Index Look-up and Acceleration}[link:files/rdoc/interp_rdoc.html#3]
+# 1. {Evaluation of Interpolating Functions}[link:files/rdoc/interp_rdoc.html#4]
+# 1. {Higher level interface: GSL::Spline class}[link:files/rdoc/interp_rdoc.html#5]
+#    1. {Class initialization}[link:files/rdoc/interp_rdoc.html#5.1]
+#    1. {Evaluation}[link:files/rdoc/interp_rdoc.html#5.2]
+#    1. {Finding and acceleration}[link:files/rdoc/interp_rdoc.html#5.3]
+#
+# == {}[link:index.html"name="1] Interpolation Classes
+# * GSL
+#   * Interp (class)
+#     * Accel (class)
+#   * Spline (class)
+#   
+# == {}[link:index.html"name="2] 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.
+#
+# == {}[link:index.html"name="3] 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>.
+#
+#
+# == {}[link:index.html"name="4] 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>.
+#
+# == {}[link:index.html"name="5] Higher level interface: GSL::Spline class
+# === {}[link:index.html"name="5.1] 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>.
+#
+# === {}[link:index.html"name="5.2] 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>].
+#
+# === {}[link:index.html"name="5.3] 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:files/rdoc/odeiv_rdoc.html]
+# {next}[link:files/rdoc/diff_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#
+#   

data/rdoc/intro.rdoc

@@ -0,0 +1,27 @@
+#
+# = Introduction
+#
+# The GNU Scientific Library ({GSL}[http://sources.redhat.com/gsl/"target="_top])
+# 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}[http://rubyforge.org/projects/rb-gsl/"target="_top] is a Ruby
+# extension for GSL. This provides higher-level interfaces to the GSL functions.
+#
+# == {}[link:index.html"name="1] Requirements
+# * GSL (1.4 or later recommended)
+# * ANSI C compiler
+# * Ruby (1.8 or later recommended)
+#
+# == {}[link:index.html"name="2] Installation
+# See {here}[link:files/rdoc/index_rdoc.html].
+#
+# {next}[link:files/rdoc/use_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#

data/rdoc/linalg.rdoc

@@ -0,0 +1,681 @@
+#
+# = Linear Algebra
+#
+# Contents:
+# 1. {LU Decomposition}[link:files/rdoc/linalg_rdoc.html#1]
+# 1. {QR Decomposition}[link:files/rdoc/linalg_rdoc.html#2]
+# 1. {QR Decomposition with Column Pivoting}[link:files/rdoc/linalg_rdoc.html#3]
+# 1. {Singular Value Decomposition}[link:files/rdoc/linalg_rdoc.html#4]
+# 1. {Cholesky Decomposition}[link:files/rdoc/linalg_rdoc.html#5]
+# 1. {Tridiagonal Decomposition of Real Symmetric Matrices}[link:files/rdoc/linalg_rdoc.html#6]
+# 1. {Tridiagonal Decomposition of Hermitian Matrices}[link:files/rdoc/linalg_rdoc.html#7]
+# 1. {Hessenberg Decomposition of Real Matrices}[link:files/rdoc/linalg_rdoc.html#8]
+# 1. {Hessenberg-Triangular Decomposition of Real Matrices}[link:files/rdoc/linalg_rdoc.html#9]
+# 1. {Bidiagonalization}[link:files/rdoc/linalg_rdoc.html#10]
+# 1. {Householder Transformations}[link:files/rdoc/linalg_rdoc.html#11]
+# 1. {Householder solver for linear systems}[link:files/rdoc/linalg_rdoc.html#12]
+# 1. {Tridiagonal Systems}[link:files/rdoc/linalg_rdoc.html#13]
+# 1. {Balancing}[link:files/rdoc/linalg_rdoc.html#14]
+# 1. {NArray}[link:files/rdoc/linalg_rdoc.html#15]
+#
+# == {}[link:index.html"name="1] 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.
+#
+# === {}[link:index.html"name="1.1] {Complex LU decomposition}[link:files/rdoc/linalg_complex_rdoc.html]
+#
+# == {}[link:index.html"name="2] 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>.
+#
+# == {}[link:index.html"name="3] 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)
+#
+#
+# == {}[link:index.html"name="4] 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)
+#
+# == {}[link:index.html"name="6] 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>.
+#
+# === {}[link:index.html"name="5.1] {Complex Cholesky decomposition}[link:files/rdoc/cholesky_complex_rdoc.html]
+#
+# == {}[link:index.html"name="6] 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>. 
+#
+# == {}[link:index.html"name="7] 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>. 
+#
+# == {}[link:index.html"name="8] 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>.
+#
+# == {}[link:index.html"name="9] 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>.
+#
+# == {}[link:index.html"name="10] 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
+#
+#
+# == {}[link:index.html"name="11] 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>.
+#
+# == {}[link:index.html"name="12] 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.
+#
+# == {}[link:index.html"name="13] 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 )
+#
+# == {}[link:index.html"name="14] 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>. 
+#
+#
+# == {}[link:index.html"name="15] 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:files/rdoc/blas_rdoc.html]
+# {next}[link:files/rdoc/eigen_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#