rb-gsl 1.15.3.1

data/lib/ool.rb

@@ -0,0 +1,22 @@
+
+module OOL
+  module Conmin
+    class Pgrad_parameters < Array
+      attr_accessor :fmin, :tol, :alpha, :sigma1, :sigma2
+    end
+    class Spg_parameters < Array
+      attr_accessor :fmin, :tol, :M, :alphamin, :alphamax, :gamma
+      attr_accessor :sigma1, :sigma2
+    end
+    class Gencan_parameters < Array
+      attr_accessor :epsgpen, :epsgpsn, :fmin, :udelta0
+      attr_accessor :ucgmia, :ucgmib
+      attr_accessor :cg_scre, :cg_gpnf, :cg_epsi, :cg_epsf
+      attr_accessor :cg_epsnqmp, :cg_maxitnqmp, :nearlyq
+      attr_accessor :nint, :next, :mininterp, :maxextrap
+      attr_accessor :trtype, :eta, :deltamin, :lspgmi, :lspgma
+      attr_accessor :theta, :gamma, :beta, :sigma1, :sigma2
+      attr_accessor :epsrel, :epsabs, :infrel, :infabs
+    end    
+  end
+end

data/lib/ool/conmin.rb

@@ -0,0 +1,30 @@
+
+module OOL
+  module Conmin
+    class Minimizer
+      class Pgrad
+        class Parameters
+          attr_accessor :fmin, :tol, :alpha, :sigma1, :sigma2
+        end
+      end
+      class Spg
+        class Parameters
+          attr_accessor :fmin, :tol, :M, :alphamin, :alphamax, :gamma
+          attr_accessor :sigma1, :sigma2
+        end
+      end
+      class Gencan
+        class Parameters
+          attr_accessor :epsgpen, :epsgpsn, :fmin, :udelta0
+          attr_accessor :ucgmia, :ucgmib
+          attr_accessor :cg_scre, :cg_gpnf, :cg_epsi, :cg_epsf
+          attr_accessor :cg_epsnqmp, :cg_maxitnqmp, :nearlyq
+          attr_accessor :nint, :next, :mininterp, :maxextrap
+          attr_accessor :trtype, :eta, :deltamin, :lspgmi, :lspgma
+          attr_accessor :theta, :gamma, :beta, :sigma1, :sigma2
+          attr_accessor :epsrel, :epsabs, :infrel, :infabs
+        end    
+      end
+    end
+  end
+end

data/lib/rbgsl.rb

@@ -0,0 +1,3 @@
+require('narray')
+require('rb_gsl')
+require('gsl/oper.rb')

data/rdoc/alf.rdoc

@@ -0,0 +1,77 @@
+#
+# = ALF: a collection of routines for computing associated Legendre polynomials (ALFs)
+# ALF is an extension library for GSL to compute associated Legendre polynomials developed by Patrick Alken.
+# Ruby/GSL includes interfaces to it if ALF is found during installlation.
+#
+# The class and method descriptions below are based on references from the document of ALF (alf-1.0/doc/alf.texi) by P.Alken.
+#
+# == {}[link:index.html"name="1] Module structure
+# * GSL::ALF (module)
+#   * GSL::ALF::Workspace (Class)
+#
+# == {}[link:index.html"name="2] Creating ALF workspace
+# ---
+# * GSL::ALF::Workspace.alloc(lmax)
+# * GSL::ALF.alloc(lmax)
+#
+# Creates a workspace for computing associated Legendre polynomials (ALFs). The maximum ALF degree is specified by lmax. The size of this workspace is O(lmax).
+#
+# == {}[link:index.html"name="3] Methods
+# ---
+# * GSL::ALF::Workspace#params(csphase, cnorm, norm)
+#
+#   Sets various parameters for the subsequent computation of ALFs. If
+#   <tt>csphase</tt> is set to a non-zero value, the Condon-Shortley phase of
+#   (-1)^m will be applied to the associated Legendre functions. The
+#   Condon-Shortley phase is included by default. If <tt>cnorm</tt> is set to
+#   zero, the real normalization of the associated Legendre functions will be
+#   used. The default is to use complex normalization. The norm parameter
+#   defines the type of normalization which will be used. The possible values
+#   are as follows.
+#   * ALF::NORM_SCHMIDT: Schmidt semi-normalized associated Legendre polynomials S_l^m(x). (default)
+#   * ALF::NORM_SPHARM: Associated Legendre polynomials Y_l^m(x) suitable for the calculation of spherical harmonics.
+#   * ALF::NORM_ORTHO: Fully orthonormalized associated Legendre polynomials N_l^m(x).
+#   * ALF::NORM_NONE:: Unnormalized associated Legendre polynomials P_l^m(x).
+# ---
+# * GSL::ALF::Workspace#Plm_array(x)
+# * GSL::ALF::Workspace#Plm_array(lmax, x)
+# * GSL::ALF::Workspace#Plm_array(x, result)
+# * GSL::ALF::Workspace#Plm_array(lmax, x, result)
+# * GSL::ALF::Workspace#Plm_array(x, result, deriv)
+# * GSL::ALF::Workspace#Plm_array(lmax, x, result, deriv)
+#
+#   Compute all associated Legendre polynomials P_l^m(x) and optionally their
+#   first derivatives dP_l^m(x)/dx for 0 <= l <= lmax, 0 <= m <= l. The value
+#   of <tt>lmax</tt> cannot exceed the previously specified lmax parameter to
+#   <tt>ALF.alloc</tt>, but may be less. If <tt>lmax</tt> is not given, the
+#   parameter to <tt>ALF.alloc()</tt> is used. The results are stored in
+#   <tt>result</tt>, an instance of <tt>GSL::Vector</tt>. Note that this vector
+#   must have enough length to store all the values for the polynomial
+#   P_l^m(x), and the length required can be known using
+#   <tt>ALF::array_size(lmax)</tt>. If a vector is not given, a new vector is
+#   created and returned. 
+#
+#   The indices of <tt>result</tt> (and <tt>deriv</tt> corresponding to the
+#   associated Legendre function of degree <tt>l</tt> and order <tt>m</tt> can
+#   be obtained by calling <tt>ALF::array_index(l, m)</tt>.
+# ---
+# * GSL::ALF::Workspace#Plm_deriv_array(x)
+# * GSL::ALF::Workspace#Plm_deriv_array(lmax, x)
+# * GSL::ALF::Workspace#Plm_deriv_array(x, result, deriv)
+# * GSL::ALF::Workspace#Plm_deriv_array(lmax, x, result, deriv)
+#
+#   Compute all associated Legendre polynomials P_l^m(x) and their first
+#   derivatives dP_l^m(x)/dx for 0 <= l <= lmax, 0 <= m <= l. 
+#
+# ---
+# * GSL::ALF::array_size(lmax)
+#
+#   Returns the size of arrays needed for the array versions of P_l^m(x).
+# ---
+# * GSL::ALF::array_index(l, m)
+#
+#   Returns the array index of results of <tt>Plm_array()</tt> and
+#   <tt>Plm_deriv_array()</tt> corresponding to P_l^m(x) and dP_l^m(x)/dx
+#   respectively. The index is given by l(l + 1)/2 + m.
+#
+#

data/rdoc/blas.rdoc

@@ -0,0 +1,269 @@
+#
+# = BLAS Support
+# The following is the list of the methods defined in <tt>GSL::Blas</tt> module.
+# See {GSL reference}[http://www.gnu.org/software/gsl/manual/gsl-ref_12.html#SEC212"target="_top] for details.
+#
+# == {}[link:index.html"name="1] Level 1
+# ---
+# * GSL::Blas::ddot(x, y)
+# * GSL::Vector#blas_ddot(y)
+# * GSL::Vector#ddot(y)
+#
+#
+# ---
+# * GSL::Blas::zdotu(x, y)
+# * GSL::Vector::Complex#blas_zdotu(y)
+# * GSL::Vector::Complex#zdotu(y)
+#
+#
+# ---
+# * GSL::Blas::zdotc(x, y)
+# * GSL::Vector::Complex#blas_zdotc(y)
+# * GSL::Vector::Complex#zdotc(y)
+#
+#
+# ---
+# * GSL::Blas::dnrm2(x)
+# * GSL::Vector#blas_dnrm2
+# * GSL::Vector#dnrm2
+#
+#
+# ---
+# * GSL::Blas::dznrm2(x)
+# * GSL::Vector::Complex#blas_dznrm2
+# * GSL::Vector::Complex#dznrm2
+#
+#
+# ---
+# * GSL::Blas::dasum(x)
+# * GSL::Vector#blas_dasum
+# * GSL::Vector#dasum
+#
+#
+# ---
+# * GSL::Blas::dzasum(x)
+# * GSL::Vector::Complex#blas_dzasum
+# * GSL::Vector::Complex#dzasum
+#
+#
+# ---
+# * GSL::Blas::idamax(x)
+# * GSL::Vector#blas_idamax
+# * GSL::Vector#idamax
+#
+#
+# ---
+# * GSL::Blas::izamax(x)
+# * GSL::Vector::Complex#blas_izamax
+# * GSL::Vector::Complex#izamax
+#
+#
+# ---
+# * GSL::Blas::dswap(x, y)
+# * GSL::Vector#blas_dswap(y)
+# * GSL::Vector#dswap(y)
+#
+#
+# ---
+# * GSL::Blas::zswap(x, y)
+# * GSL::Vector::Complex#blas_zswap(y)
+# * GSL::Vector::Complex#zswap(y)
+#
+#
+# ---
+# * GSL::Blas::dcopy(x, y)
+# * GSL::Vector#blas_dcopy(y)
+# * GSL::Vector#dcopy(y)
+#
+#
+# ---
+# * GSL::Blas::zcopy(x, y)
+# * GSL::Vector::Complex#blas_zcopy(y)
+# * GSL::Vector::Complex#zcopy(y)
+#
+#
+# ---
+# * GSL::Blas::daxpy!(a, x, y)
+# * GSL::Vector#blas_daxpy!(a, y)
+# * GSL::Vector#daxpy!(a, y)
+# * GSL::Blas::daxpy(a, x, y)
+# * GSL::Vector#blas_daxpy(a, y)
+# * GSL::Vector#daxpy(a, y)
+#
+#
+# ---
+# * GSL::Blas::zaxpy!(a, x, y)
+# * GSL::Vector::Complex#blas_zaxpy!(a, y)
+# * GSL::Vector::Complex#zaxpy!(a, y)
+# * GSL::Blas::zaxpy(a, x, y)
+# * GSL::Vector::Complex#blas_zaxpy(a, y)
+# * GSL::Vector::Complex#zaxpy(a, y)
+#
+#
+# ---
+# * GSL::Blas::dscal!(a, x)
+# * GSL::Vector#blas_dscal!(a)
+# * GSL::Vector#dscal!(a)
+# * GSL::Blas::dscal(a, x)
+# * GSL::Vector#blas_dscal(a)
+# * GSL::Vector#dscal(a)
+#
+#
+# ---
+# * GSL::Blas::zscal!(a, x)
+# * GSL::Vector::Complex#blas_zscal!(a)
+# * GSL::Vector::Complex#zscal!(a)
+# * GSL::Blas::zscal(a, x)
+# * GSL::Vector::Complex#blas_zscal(a)
+# * GSL::Vector::Complex#zscal(a)
+#
+#
+# ---
+# * GSL::Blas::zdscal!(a, x)
+# * GSL::Vector::Complex#blas_zdscal!(a)
+# * GSL::Vector::Complex#zdscal!(a)
+# * GSL::Blas::zdscal(a, x)
+# * GSL::Vector::Complex#blas_zdscal(a)
+# * GSL::Vector::Complex#zdscal(a)
+#
+#
+# ---
+# * GSL::Blas::drot(x, y, c, s)
+# * GSL::Blas::drot!(x, y, c, s)
+# * GSL::Blas::drotm(x, y, p)
+# * GSL::Blas::drotm!(x, y, p)
+#
+#
+# == {}[link:index.html"name="2] Level 2
+# ---
+# * GSL::Blas::dgemv(trans, a, A, x, b, y)
+# * GSL::Blas::dgemv!(trans, a, A, x, b, y)
+# * GSL::Blas::zgemv(trans, a, A, x, b, y)
+# * GSL::Blas::zgemv!(trans, a, A, x, b, y)
+#
+#
+# ---
+# * GSL::Blas::dtrmv(trans, a, A, x, b, y)
+# * GSL::Blas::dtrmv!(trans, a, A, x, b, y)
+# * GSL::Blas::ztrmv(trans, a, A, x, b, y)
+# * GSL::Blas::ztrmv!(trans, a, A, x, b, y)
+#
+#
+# ---
+# * GSL::Blas::dtrsv(uplo, trans, diag, A, x)
+# * GSL::Blas::dtrsv!uplo, trans, diag, A, x)
+# * GSL::Blas::ztrsvuplo, trans, diag, A, x)
+# * GSL::Blas::ztrsv!uplo, trans, diag, A, x)
+#
+#
+# ---
+# * GSL::Blas::dsymv(uplo, a, A, x, b, y)
+# * GSL::Blas::dsymv!(uplo, a, A, x, b, y)
+# * GSL::Blas::zhemv(uplo, a, A, x, b, y)
+# * GSL::Blas::zhemv!(uplo, a, A, x, b, y)
+#
+#
+# ---
+# * GSL::Blas::dger(a, x, y, A)
+# * GSL::Blas::dger!(a, x, y, A)
+# * GSL::Blas::zgeru(a, x, y, A)
+# * GSL::Blas::zgeru!(a, x, y, A)
+# * GSL::Blas::zgerc(a, x, y, A)
+# * GSL::Blas::zgerc!(a, x, y, A)
+#
+#
+# ---
+# * GSL::Blas::dsyr(uplo, a, x, A)
+# * GSL::Blas::dsyr!(uplo, a, x, A)
+# * GSL::Blas::zher(uplo, a, x, A)
+# * GSL::Blas::zher!(uplo, a, x, A)
+#
+#
+# ---
+# * GSL::Blas::dsyr2(uplo, a, x, y, A)
+# * GSL::Blas::dsyr2!(uplo, a, x, y, A)
+# * GSL::Blas::zher2(uplo, a, x, y, A)
+# * GSL::Blas::zher2!(uplo, a, x, y, A)
+#
+#
+# == {}[link:index.html"name="3] Level 3
+# ---
+# * GSL::Blas::dgemm(transA, transB, alpha, A, B, beta, C)
+# * GSL::Blas::dgemm(A, B)
+#
+#
+# ---
+# * GSL::Blas::zgemm(transA, transB, alpha, A, B, beta, C)
+# * GSL::Blas::zgemm(A, B)
+#
+#
+# ---
+# * GSL::Blas::dsymm(transA, transB, alpha, A, B, beta, C)
+# * GSL::Blas::dsymm(A, B)
+#
+#
+# ---
+# * GSL::Blas::zsymm(transA, transB, alpha, A, B, beta, C)
+# * GSL::Blas::zsymm(A, B)
+#
+#
+# ---
+# * GSL::Blas::zhemm(transA, transB, alpha, A, B, beta, C)
+# * GSL::Blas::zhemm(A, B)
+#
+#
+# ---
+# * GSL::Blas::dtrmm(side, uplo, trans, diag, alpha, A, B)
+# * GSL::Blas::ztrmm(side, uplo, trans, diag, alpha, A, B)
+#
+#
+# ---
+# * GSL::Blas::dtrsm(side, uplo, trans, diag, alpha, A, B)
+# * GSL::Blas::ztrsm(side, uplo, trans, diag, alpha, A, B)
+#
+#
+# ---
+# * GSL::Blas::dsyrk(uplo, trans, diag, alpha, A, beta, C)
+# * GSL::Blas::zsyrk(uplo, trans, diag, alpha, A, beta, C)
+# * GSL::Blas::zherk(uplo, trans, diag, alpha, A, beta, C)
+#
+#
+# ---
+# * GSL::Blas::dsyr2k(uplo, trans, diag, alpha, A, B, beta, C)
+# * GSL::Blas::zsyr2k(uplo, trans, diag, alpha, A, B, beta, C)
+# * GSL::Blas::zher2k(uplo, trans, diag, alpha, A, B, beta, C)
+#
+#
+# == {}[link:index.html"name="4] Constants
+# ---
+# * GSL::Blas::CblasRowMajor
+# * GSL::Blas::RowMajor
+# * GSL::Blas::CblasColMajor
+# * GSL::Blas::ColMajor
+# * GSL::Blas::CblasNoTrans
+# * GSL::Blas::NoTrans
+# * GSL::Blas::CblasTrans
+# * GSL::Blas::Trans
+# * GSL::Blas::CblasConjTrans
+# * GSL::Blas::ConjTrans
+# * GSL::Blas::CblasUpper
+# * GSL::Blas::Upper
+# * GSL::Blas::CblasTrans
+# * GSL::Blas::Lower
+# * GSL::Blas::CblasNonUnit
+# * GSL::Blas::NonUnit
+# * GSL::Blas::CblasUnit
+# * GSL::Blas::Unit
+# * GSL::Blas::CblasLeft
+# * GSL::Blas::Left
+# * GSL::Blas::CblasRight
+# * GSL::Blas::Right
+#
+#
+# {prev}[link:files/rdoc/sort_rdoc.html]
+# {next}[link:files/rdoc/linalg_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#

data/rdoc/bspline.rdoc

@@ -0,0 +1,42 @@
+#
+# = 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:files/rdoc/bspline_rdoc.html#1]
+# 1. {Initializing the B-splines solver}[link:files/rdoc/bspline_rdoc.html#2]
+# 1. {Constructing the knots vector}[link:files/rdoc/bspline_rdoc.html#3]
+# 1. {Evaluation of B-splines}[link:files/rdoc/bspline_rdoc.html#4]
+#
+# == {}[link:index.html"name="1] 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. 
+#
+# == {}[link:index.html"name="2] 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>. 
+#
+# == {}[link:index.html"name="3] 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. 
+# == {}[link:index.html"name="4] 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:files/rdoc/nonlinearfit_rdoc.html]
+# {next}[link:files/rdoc/const_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#