rb-gsl 1.16.0.5 → 1.16.0.6

data/rdoc/bspline.rdoc

@@ -1,42 +0,0 @@
-#
-# = 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#label-Overview]
-# 1. {Initializing the B-splines solver}[link:rdoc/bspline_rdoc.html#label-Initializing+the+B-splines+solver]
-# 1. {Constructing the knots vector}[link:rdoc/bspline_rdoc.html#label-Constructing+the+knots+vector]
-# 1. {Evaluation of B-splines}[link:rdoc/bspline_rdoc.html#label-Evaluation+of+B-splines]
-#
-# == 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.
-#
-# 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.
-#
-# == 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>.
-#
-# == Constructing the knots vector
-# ---
-# * GSL::BSpline#knots(breakpts)
-#
-#   This method computes the knots associated with the given breakpoints <tt>breakpts</tt> and returns the knots as a <tt>GSL::Vector::View</tt> object.
-# ---
-# * 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.
-# == 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.
-#
-# {prev}[link:rdoc/nonlinearfit_rdoc.html]
-# {next}[link:rdoc/const_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#

data/rdoc/changes.rdoc

@@ -1,159 +0,0 @@
-#
-# = Changes since Ruby/GSL 1.10.3
-#
-# Ruby/GSL 1.11.2 introduced enhancements and some important bug fixes since the
-# earlier 1.10.3 release.  Some of the enhancements and bug fixes involve changes
-# that are not backwards compatible.  Existing scripts that work with Ruby/GSL
-# 1.10.3 may break under 1.11.2 (or later) if they use certain constructs that
-# are no longer supported or have changed in an incompatible way.
-#
-# The changes that could break old scripts are described below.  They are
-# followed by highlights of the other enhancements and new features.
-#
-# == Backwards incompatibilities introduced in Ruby/GSL 1.11.2
-#
-# * FFT interface has been extensively changed.
-#
-# * Matrix#get has been modified.
-#
-# * Size changing methods of GSL::Vector et al have, in general, been removed.
-#
-# * The #shift, #unshift, #push, and #pop methods have been removed from
-#   GSL::Vector et al since they result increasing the size of <tt>self</tt>.  This
-#   can cause new memory to be allocated and old memory to be freed, but because
-#   existing Views contain pointers to the old memory, this cannot be allowed.
-#   Also removed #up and #down aliases from GSL::Poly.
-#
-# * The #concat method of GSL::Vector et al has been changed to always return a
-#   new, longer instance rather than reallocating memory for <tt>self</tt>.
-#
-# * Return values from #delete, #delete_at, and #delete_if now follow same
-#   convention as similarly named methods in Ruby's Array class.  These methods
-#   should be considered deprecated because existing Views could still refer to
-#   now unmanged (but still allocated) memory.
-#
-# * GSL::Complex objects are now immutable.
-#
-# == 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, <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.
-#
-# * Improved GSL::Vector::Complex#inspect.
-#
-# * Added GSL::Vector::Complex#set_real and GSL::Vector::Complex#set_imag methods
-#   (and real=, re=, imag=, im= aliases).  Currently only work with Numerics, but
-#   could be made to work with GSL::Vectors (and Arrays of Floats).
-#
-# * Added GSL::Vector::Complex#conjugate and GSL::Vector::Complex#conjugate!
-#   methods along with corresponding "conj" and "conj!" aliases.
-#
-# * Added "#add!", "#sub!", "#mul!", and "#div!" methods to GSL::Vector::Complex.
-#   Also "add_constant!", and "scale!" aliases.
-#
-# * Added the following stats methods to GSL::Vector::Complex, #sum, #mean, #tss,
-#   #tss_m, #variance, #variance_m, #variance_fm, #sd, #sd_m, and #sd_fm.  #sum
-#   and #mean return GSL::Complex; all others return Float.
-#
-# * Added "dup" alias for "clone" method of Vector and Maxtrix.
-#
-# * Added support for three parameter call to #subvector to support stride.
-#
-# * Added #shape method with alias #size for Matrix.
-#
-# * Provide GSL_Object#dup method to override Object#dup.  GSL_Object#dup simply
-#   raises NotImplementedError.  Subclasses that want dup functionality should
-#   provide their own implementation.
-#
-# * Added length alias to Vector and Vector::Complex.
-#
-# * Added #angle alias for #arg method of Complex, Vector::Complex, and
-#   Matrix::Complex
-#
-# * Added #conj alias for #conjugate for GSL::Complex.  Added #conjugate! method
-#   with #conj! alias for GSL::Complex.
-#
-# * Added #[]= alias for #set method, #conj alias for #conjugate method, and
-#   #conj! alias for #conjugate! method to GSL::Matrix::Complex
-#
-# * Support GSL::Permutation as parameter to Vector::Complex#get (and #[]).
-#
-# * Disallow the stride and length parameters of the various FFT methods.  The
-#   Vector being transformed could really be a Vector::View (e.g. a view of a
-#   Matrix column).  In that case, we need to use the stride of the Vector::View.
-#   Users wishing to use a custom stride or length will be able to do so by
-#   transforming  a subvector of the Vector.
-#
-# * Added Block#length alias for Block#size.
-#
-# * Fixed bug #16023.
-#
-# * Calling #to_v on a single column matrix view will return column vector.
-#   Related to #19757.
-#
-# * Provided GSL::Matrix::Complex with reasonable #to_s and #inspect
-#   implementations.
-#
-# * Made Vector#{add,sub,mul,div}! methods work with non-Vector parameter (i.e.
-#   constant).
-#
-# * Added #collect and #collect! methods to Matrix::Complex.
-#
-# * Added #map and #map! aliases for collect and collect! to Block, Vector et al,
-#   and Matrix et al.
-#
-# * Vector::Complex#each, #reverse_each, #collect, and #collect! now yield
-#   objects that are allocated on heap rather than stack.
-#
-# * Made Vector#subvector work with negative offsets
-#
-# * Added Vector#sgn and Matrix#sgn, both with #signum alias.
-#
-# * Added support for a Range parameter (with optional stride) to
-#   Vector#subvector and Vector::Complex#subvector.
-#
-# * Modified Vector#get and Vector::Complex#get to return Views (via #subvector)
-#   if more than one (or none) parameters are given or if a single Range
-#   parameter is given.
-#
-# * Enhanced Matrix#submatrix with many new options and updated docs to reflect
-#   changes
-#
-# * Modified Matrix#get to use new Matrix#submatrix functionality.
-#
-# * Added Matrix#to_a and Matrix::Complex#to_a methods.
-#
-# * Enhanced Vector#set functionality.
-#
-# * Added more details, examples, and a warning to Vector#set documentation.
-#
-# * Changed Range handling to support Floats for begin and end values where
-#   appropriate.
-#
-# * Changed Vector#view_with_stride to require non-zero stride rather then
-#   positive stride.
-#
-# * Enhanced Vector::Complex#set functionality.
-#
-# * Enhanced Matrix#set.  Changed behavior of Matrix#get when called with a
-#   single Fixnum argument; now returns individual element rather than
-#   Vector::View of row.  See html/matrix.html for more details.  Changed tests
-#   and examples to accomdate the change in Matrix#get.
-#
-# * Match to the latest tensor extension (version 0.99)
-#
-# * Modified GSL::Matrix::Complex#set to have same (i.e. newly enhanced)
-#   functionality as GSL::Matrix#set.  [Possibly incomplete; please report any
-#   discrepancies.]
-#
-# * Added #diag alias for Matrix#diagonal.
-#
-# * Added #fftshift, #fftshift!, #ifftshift, and #ifftshift!  methods to
-#   GSL::Vector::Complex and documented them.
-#
-#

data/rdoc/cheb.rdoc

@@ -1,99 +0,0 @@
-#
-# = 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#label-Cheb+class]
-# 1. {Chebyshev Series Evaluation}[link:rdoc/cheb_rdoc.html#label-Chebyshev+Series+Evaluation]
-# 1. {Derivatives and Integrals}[link:rdoc/cheb_rdoc.html#label-Derivatives+and+Integrals]
-# 1. {Examples}[link:rdoc/cheb_rdoc.html#label-Example]
-#
-# == <tt>Cheb</tt> class
-#
-# ---
-# * GSL::Cheb.alloc(n)
-#
-#   This create an instance of the GSL::Cheb class for a Chebyshev series of order n.
-#
-#
-# ---
-# * 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.
-#
-#   * ex: Approximate a step function defined in (0, 1) by a Chebyshev series of order 40.
-#       f = GSL::Function.alloc { |x|
-#         if x < 0.5
-#           0.25
-#         else
-#           0.75
-#         end
-#       }
-#
-#       cs = GSL::Cheb.alloc(40)
-#       cs.init(f, 0, 1)
-#
-# == Chebyshev Series Evaluation
-# ---
-# * GSL::Cheb#eval(x)
-#
-#   This evaluates the Chebyshev series at a given point <tt>x</tt>.
-#
-# ---
-# * GSL::Cheb#eval_n(n, x)
-#
-#   This evaluates the Chebyshev series at a given point <tt>x</tt>, to (at most) the given order <tt>n</tt>.
-#
-# == Derivatives and Integrals
-#
-# ---
-# * GSL::Cheb#calc_deriv()
-# * GSL::Cheb#deriv()
-#
-#   This computes the derivative of the series, and returns a new GSL::Cheb object which contains the computed derivative. The reciever is not changed.
-#
-# ---
-# * GSL::Cheb#calc_integ()
-# * GSL::Cheb#integ()
-#
-#   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.
-#
-# == Example
-#    #!/usr/bin/env ruby
-#    require("gsl")
-#
-#    f = GSL::Function.alloc { |x|
-#      if x < 0.5
-#        0.25
-#      else
-#        0.75
-#      end
-#    }
-#
-#    n = 1000
-#    order = 40
-#    cs = GSL::Cheb.alloc(order)
-#    cs.init(f, 0, 1)
-#
-#    x = Vector.linspace(0, 1, n)
-#    ff = f.eval(x)
-#    r10 = cs.eval_n(10, x)
-#    r40 = cs.eval(x)
-#    GSL::graph(x, ff, r10, r40)
-#
-#
-# See also the example scripts in <tt>examples/cheb/</tt>.
-#
-# {prev}[link:rdoc/diff_rdoc.html]
-# {next}[link:rdoc/sum_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#

data/rdoc/cholesky_complex.rdoc

@@ -1,46 +0,0 @@
-#
-# === 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
-# <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
-# <tt>L y = b, L^T x = y</tt>,
-# 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
-#   Cholesky decomposition <tt>A = L L^H</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
-#   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>.
-#
-# ---
-# * 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
-#   <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.
-#
-# {back}[link:rdoc/linalg_rdoc.html]
-#

data/rdoc/combi.rdoc

@@ -1,125 +0,0 @@
-#
-# = Combinations
-# Contents:
-# 1. {Combination allocation}[link:rdoc/combi_rdoc.html#label-Combination+allocation]
-# 1. {Methods}[link:rdoc/combi_rdoc.html#label-Methods]
-#    1. {Accessing combination elements}[link:rdoc/combi_rdoc.html#label-Accessing+combination+elements]
-#    1. {Combination properties}[link:rdoc/combi_rdoc.html#label-Combination+properties]
-#    1. {Combination functions}[link:rdoc/combi_rdoc.html#label-Combination+functions]
-#    1. {Reading and writing combinations}[link:rdoc/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.
-#
-# ---
-# * GSL::Combination.calloc(n, k)
-#
-#   This creates a new combination with parameters <tt>n, k</tt> and initializes
-#   it to the lexicographically first combination.
-#
-# == Methods
-#
-# ---
-# * GSL::Combination#init_first
-#
-#   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
-#   combination, i.e. (n-k,n-k+1,...,n-1).
-#
-# === Accessing combination elements
-# ---
-# * GSL::Combination#get(i)
-# * \GSL::Combination#[i]
-#
-#   This returns the value of the <tt>i</tt>-th element of the combination <tt>self</tt>.
-#
-# === Combination properties
-# ---
-# * GSL::Combination#n
-#
-#   Returns the <tt>n</tt> parameter of the combination <tt>self</tt>.
-#
-# ---
-# * GSL::Combination#k
-#
-#   Returns the <tt>k</tt> parameter of the combination <tt>self</tt>.
-#
-# ---
-# * GSL::Combination#data
-#
-#   Returns the vector of elements in the combination <tt>self</tt>.
-#
-# ---
-# * 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,
-#   each number at most once. The numbers have to be in increasing order.
-#
-# ---
-# * GSL::Combination#valid?
-#
-#   Thie returns true if the combination is valid, and false otherwise.
-#
-# === 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
-#   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>
-#   and leaves <tt>self</tt> unmodified.
-#
-# === Reading and writing combinations
-# ---
-# * GSL::Combination#fwrite(filename)
-# * GSL::Combination#fwrite(io)
-# * GSL::Combination#fread(filename)
-# * GSL::Combination#fread(io)
-# * GSL::Combination#fprintf(filename, format = "%u")
-# * GSL::Combination#fprintf(io, format = "%u")
-# * GSL::Combination#fscanf(filename)
-# * GSL::Combination#fscanf(io)
-#
-#
-# == Example
-#      #!/usr/bin/env ruby
-#      require("gsl")
-#
-#      printf("All subsets of {0,1,2,3} by size:\n") ;
-#      for i in 0...4 do
-#        c = GSL::Combination.calloc(4, i);
-#        begin
-#          printf("{");
-#          c.fprintf(STDOUT, " %u");
-#          printf(" }\n");
-#        end while c.next == GSL::SUCCESS
-#      end
-#
-# {prev}[link:rdoc/perm_rdoc.html]
-# {next}[link:rdoc/sort_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#