gsl 1.12.109 → 1.14.5

data/rdoc/siman.rdoc

@@ -0,0 +1,89 @@
+#
+# = Simulated Annealing
+# === {}[link:index.html"name="0.1] Library
+#
+# == {}[link:index.html"name="1] Module and classes
+# * GSL::
+#   * Siman::  (Module)
+#     * Params (Class)
+#     * Efunc (Class)
+#     * Step (Class)
+#     * Metric (Class)
+#     * Print (Class)
+#
+# == {}[link:index.html"name="2] <tt>Siman</tt> Module
+# === {}[link:index.html"name="2.1] Singleton method
+# ---
+# * GSL::Siman.solve(rng, x0_p, efunc, stepper, metric, printer, params)
+#
+#   This performs a simulated annealing search through a given space. 
+#   The space is specified by providing the functions <tt>efunc</tt> and <tt>metric</tt>. 
+#   The simulated annealing steps are generated using the random number generator 
+#   <tt>rng</tt> and the function <tt>stepper</tt>. The starting configuration of the 
+#   system should be given by a <tt>Vector</tt> object <tt>x0_p</tt>.
+#   
+#   The parameter <tt>params</tt> controls the run by providing the temperature 
+#   schedule and other tunable parameters to the algorithm.
+#
+#   On exit the best result achieved during the search is placed in <tt>x0_p</tt>. 
+#   If the annealing process has been successful this should be a good approximation 
+#   to the optimal point in the space.
+#
+#   If the function <tt>printer</tt> is not <tt>nil</tt>, a debugging log will be printed 
+#   to stdout with the following columns:
+#       number_of_iterations   temperature    x    x-(x0_p)   efunc(x)
+#   and the output of <tt>printer</tt> itself. If <tt>printer</tt> is <tt>nil</tt> 
+#   then no information is printed.
+#
+# == {}[link:index.html"name="3] Example
+#
+#      #!/usr/bin/env ruby
+#      require("gsl")
+#      include GSL::Siman
+#
+#      N_TRIES = 200
+#      ITERS_FIXED_T = 10
+#      STEP_SIZE = 10
+#      K = 1.0
+#      T_INITIAL = 0.002
+#      MU_T = 1.005
+#      T_MIN = 2.0e-6
+#
+#      params = Siman::Params.alloc(N_TRIES, ITERS_FIXED_T, STEP_SIZE, K, T_INITIAL,
+#                                 MU_T, T_MIN)
+#
+#      efunc = Efunc.alloc { |vx|
+#        x = vx[0]
+#        s = (x - 1.0)
+#        Math::exp(-s*s)*Math::sin(8*x)
+#      }
+#
+#      metric = Metric.alloc { |vx, vy|
+#        (x[0] - y[0]).abs
+#      }
+#
+#      step = Step.alloc { |rng, vx, step_size|
+#        r = rng.uniform
+#        old_x = vx[0]
+#        a =  r * 2 * step_size - step_size + old_x
+#        vx[0] = a
+#      }
+#
+#      simanprint = Print.alloc { |vx|
+#        printf("%12g", vx[0])
+#      }
+#
+#      x = Vector.alloc([15.5])
+#      Rng.env_setup()
+#      rng = Rng.alloc()
+#
+#      #Siman::solve(rng, x, efunc, step, metric, simanprint, params)
+#      Siman::solve(rng, x, efunc, step, metric, nil, params)
+#      p x
+#
+# {prev}[link:files/rdoc/monte_rdoc.html]
+# {next}[link:files/rdoc/odeiv_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#

data/rdoc/sort.rdoc

@@ -0,0 +1,94 @@
+#
+# = Sorting
+# Contents:
+# 1. {Heapsort of vectors}[link:files/rdoc/sort_rdoc.html#1]
+# 1. {Sorting vectors}[link:files/rdoc/sort_rdoc.html#2]
+# 1. {Selecting the k smallest or largest elements}[link:files/rdoc/sort_rdoc.html#3]
+#
+# == {}[link:index.html"name="1] Heapsort
+#
+# ---
+# * GSL::Vector#heapsort
+# * GSL::Vector::Complex#heapsort
+# * GSL.heapsort(v)
+#
+#   These method sort the elements of the vector <tt>self</tt> 
+#   using the comparison function given by a block, and return the result
+#   as a new vector object. The vector <tt>self</tt> is not changed.
+#
+#   Example: Sorting a complex vector in ascending order by magnitudes.
+#
+#       p v.heapsort { |a, b|
+#         a.abs <=> b.abs
+#       }
+#
+# ---
+# * GSL::Vector#heapsort!
+# * GSL::Vector::Complex#heapsort!
+# * GSL.heapsort!(v)
+#
+#   These method sort the elements of the vector <tt>self</tt> in-place.
+#
+# ---
+# * GSL::Vector#heapsort_index
+# * GSL::Vector::Complex#heapsort_index
+# * GSL.heapsort_index(v)
+#
+#   These method indirectly sort the elements of the vector <tt>self</tt> 
+#   using the comparison 
+#   function given by a block, and return the result
+#   as a permutation object. The vector itself is not changed.
+#   
+# == {}[link:index.html"name="2] Sorting vectors
+# ---
+# * GSL::Vector#sort!
+#
+#   This method sorts the elements of the vector <tt>self</tt> into 
+#   ascending numerical order. The vector itself is changed.
+#
+# ---
+# * GSL::Vector#sort
+#
+#   This returns a new vector whose elements are sorted into ascending 
+#   numerical order. The vector <tt>self</tt> is not changed.
+#
+# ---
+# * GSL::Vector#sort_index
+#
+#   This method indirectly sorts the elements of the vector <tt>self</tt> 
+#   into ascending order, 
+#   and returns the result as a <tt>GSL::Permutation</tt> object. 
+#   The elements of the returned permutation give the index of the vector 
+#   element which would
+#   have been stored in that position if the vector had been sorted in place. 
+#   The first element of the permutation gives the index of the least element 
+#   in <tt>self</tt>,  and the last element of the permutation gives the index 
+#   of the greatest element in 
+#   <tt>self</tt>. The vector <tt>self</tt> is not changed.
+#
+# == {}[link:index.html"name="3] Selecting the k smallest or largest elements
+# ---
+# * GSL::Vector#sort_smallest(k)
+# * GSL::Vector#sort_largest(k)
+#
+#   These functions return a new vector of the <tt>k</tt> smallest or 
+#   largest elements  of the vector <tt>self</tt>. 
+#   The argument <tt>k</tt> must be less than or equal to the length 
+#   of the vector <tt>self</tt>. 
+#
+# ---
+# * GSL::Vector#sort_smallest_index(k)
+# * GSL::Vector#sort_largest_index(k)
+#
+#   These functions return a new <tt>GSL::Permutation</tt> object of the indices of the 
+#   <tt>k</tt> smallest or largest elements of the vector <tt>self</tt>. 
+#   <tt>k</tt> must be less than or equal to the length of the vector.
+#
+#
+# {prev}[link:files/rdoc/multiset_rdoc.html]
+# {next}[link:files/rdoc/blas_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#

data/rdoc/start.rdoc

@@ -0,0 +1,16 @@
+#
+# = Getting started
+#
+# 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.
+#
+# The {Ruby/GSL}[http://rubyforge.org/projects/rb-gsl/"target="_top] is Ruby 
+# bidings for GSL. This provides higher-level interfaces to the GSL functions.
+# See {here}[link:files/rdoc/use_rdoc.html] for installation. To use the library , just put at the head of your scripts <tt>require("gsl")</tt>, or type it from the command line of <tt>irb</tt>.
+#
+#
+#

data/rdoc/stats.rdoc

@@ -0,0 +1,219 @@
+#
+# = Statistics
+# 1. {Mean, Standard Deviation and Variance}[link:files/rdoc/stats_rdoc.html#1]
+# 1. {Absolute deviation}[link:files/rdoc/stats_rdoc.html#2]
+# 1. {Higher moments (skewness and kurtosis)}[link:files/rdoc/stats_rdoc.html#3]
+# 1. {Autocorrelation}[link:files/rdoc/stats_rdoc.html#4]
+# 1. {Covariance}[link:files/rdoc/stats_rdoc.html#5]
+# 1. {Correlation}[link:files/rdoc/stats_rdoc.html#6]
+# 1. {Weighted samples}[link:files/rdoc/stats_rdoc.html#7]
+# 1. {Maximum and minimum values}[link:files/rdoc/stats_rdoc.html#8]
+# 1. {Median and percentiles}[link:files/rdoc/stats_rdoc.html#9]
+# 1. {Examples}[link:files/rdoc/stats_rdoc.html#10]
+#
+# == {}[link:index.html"name="1] Mean, Standard Deviation and Variance
+#
+# ---
+# * GSL::Stats::mean(v)
+# * GSL::Vector#mean
+#
+#   Arithmetic mean.
+#
+#   * Ex:
+#        >> require("gsl")
+#        => true
+#        >> v = Vector[1..7]
+#        => GSL::Vector: 
+#        [ 1.000e+00 2.000e+00 3.000e+00 4.000e+00 5.000e+00 6.000e+00 7.000e+00 ]
+#        >> v.mean
+#        => 4.0
+#        >> Stats::mean(v)
+#        => 4.0
+#
+# ---
+# * GSL::Vector#tss
+#
+#   Returns the total sum of squares about <tt>self.mean</tt>.
+#   (Requires GSL 1.11)
+# ---
+# * GSL::Vector#tss_m(mean)
+#
+#   Returns the total sum of squares about <tt>mean</tt>.
+#   (Requires GSL 1.11)
+#
+# ---
+# * GSL::Stats::variance_m(v[, mean])
+# * GSL::Vector#variance_m([mean])
+#
+#   Variance of <tt>v</tt> relative to the given value of <tt>mean</tt>.
+#
+# ---
+# * GSL::Stats::sd(v[, mean])
+# * GSL::Vector#sd([mean])
+#
+#   Standard deviation.
+#
+# ---
+# * GSL::Stats::tss(v[, mean])
+# * GSL::Vector#tss([mean])
+#
+#   (GSL-1.11 or later) These methods return the total sum of squares (TSS) of data about the mean.	
+#
+# ---
+# * GSL::Stats::variance_with_fixed_mean(v, mean)
+# * GSL::Vector#variance_with_fixed_mean(mean)
+#
+#   Unbiased estimate of the variance of <tt>v</tt> when the population mean 
+#   <tt>mean</tt> of the underlying distribution is known <tt>a priori</tt>.
+#
+# ---
+# * GSL::Stats::variance_with_fixed_mean(v, mean)
+# * GSL::Vector#variance_with_fixed_mean(mean)
+# * GSL::Stats::sd_with_fixed_mean(v, mean)
+# * GSL::Vector#sd_with_fixed_mean(mean)
+#
+#   Unbiased estimate of the variance of <tt>v</tt> when the population mean 
+#   <tt>mean</tt> of the underlying distribution is known <tt>a priori</tt>.
+#
+# == {}[link:index.html"name="2] Absolute deviation 
+# ---
+# * GSL::Stats::absdev(v[, mean])
+# * GSL::Vector#absdev([mean])
+#
+#   Compute the absolute deviation (from the mean <tt>mean</tt> if given).
+#
+# == {}[link:index.html"name="3] Higher moments (skewness and kurtosis) 
+#
+# ---
+# * GSL::Stats::skew(v[, mean, sd])
+# * GSL::Vector#skew([mean, sd])
+#
+#   Skewness
+#
+# ---
+# * GSL::Stats::kurtosis(v[, mean, sd])
+# * GSL::Vector#kurtosis([mean, sd])
+#
+#   Kurtosis
+#
+# == {}[link:index.html"name="4] Autocorrelation
+# ---
+# * GSL::Stats::lag1_autocorrelation(v[, mean])
+# * GSL::Vector#lag1_autocorrelation([mean])
+#
+#   The lag-1 autocorrelation
+#
+# == {}[link:index.html"name="5] Covariance
+# ---
+# * GSL::Stats::covariance(v1, v2)
+# * GSL::Stats::covariance_m(v1, v2, mean1, mean2)
+#
+#   Covariance of vectors <tt>v1, v2</tt>.
+#
+# == {}[link:index.html"name="6] Correlation
+# ---
+# * GSL::Stats::correlation(v1, v2)
+#
+#   This efficiently computes the Pearson correlation coefficient between the vectors <tt>v1, v2</tt>. (>= GSL-1.10)
+#
+# == {}[link:index.html"name="7] Weighted samples
+# ---
+# * GSL::Vector#wmean(w)
+# * GSL::Vector#wvariance(w)
+# * GSL::Vector#wsd(w)
+# * GSL::Vector#wabsdev(w)
+# * GSL::Vector#wskew(w)
+# * GSL::Vector#wkurtosis(w)
+#
+#
+# == {}[link:index.html"name="8] Maximum and Minimum values 
+# ---
+# * GSL::Stats::max(data)
+# * GSL::Vector#max
+#
+#   Return the maximum value in data.
+#
+# ---
+# * GSL::Stats::min(data)
+# * GSL::Vector#min
+#
+#   Return the minimum value in data.
+#
+# ---
+# * GSL::Stats::minmax(data)
+# * GSL::Vectorminmax
+#
+#   Find both the minimum and maximum values in <tt>data</tt> and returns them.
+#
+# ---
+# * GSL::Stats::max_index(data)
+# * GSL::Vector#max_index
+#
+#   Return the index of the maximum value in <tt>data</tt>. 
+#   The maximum value is defined as the value of the element x_i 
+#   which satisfies x_i >= x_j for all j. 
+#   When there are several equal maximum elements then the first one is chosen. 
+# ---
+# * GSL::Stats::min_index(data)
+# * GSL::Vector#min_index
+#
+#   Returns the index of the minimum value in <tt>data</tt>. 
+#   The minimum value is defined as the value of the element x_i 
+#   which satisfies x_i >= x_j for all j. 
+#   When there are several equal minimum elements then the first one is 
+#   chosen. 
+#
+# ---
+# * GSL::Stats::minmax_index(data)
+# * GSL::Vector#minmax_index
+#
+#   Return the indexes of the minimum and maximum values in <tt>data</tt> 
+#   in a single pass. 
+#
+#
+# == {}[link:index.html"name="9] Median and Percentiles 
+#
+# ---
+# * GSL::Stats::median_from_sorted_data(v)
+# * GSL::Vector#median_from_sorted_data
+#
+#   Return the median value. The elements of the data must be 
+#   in ascending numerical order. There are no checks to see whether 
+#   the data are sorted, so the method <tt>GSL::Vector#sort</tt> 
+#   should always be used first.
+#
+# ---
+# * GSL::Stats::quantile_from_sorted_data(v)
+# * GSL::Vector#quantile_from_sorted_data
+#
+#   Return the quantile value. The elements of the data must be 
+#   in ascending numerical order. There are no checks to see whether 
+#   the data are sorted, so the method <tt>GSL::Vector#sort</tt> 
+#   should always be used first.
+#
+# == {}[link:index.html"name="10] Example
+#
+#      #!/usr/bin/env ruby
+#      require 'gsl'
+#
+#      ary =  [17.2, 18.1, 16.5, 18.3, 12.6]
+#      data = Vector.alloc(ary)
+#      mean     = data.mean()
+#      variance = data.stats_variance()
+#      largest  = data.stats_max()
+#      smallest = data.stats_min()
+#
+#      printf("The dataset is %g, %g, %g, %g, %g\n",
+#             data[0], data[1], data[2], data[3], data[4]);
+#
+#      printf("The sample mean is %g\n", mean);
+#      printf("The estimated variance is %g\n", variance);
+#      printf("The largest value is %g\n", largest);
+#      printf("The smallest value is %g\n", smallest);
+#
+# {prev}[link:files/rdoc/randist_rdoc.html]
+# {next}[link:files/rdoc/hist_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#

data/rdoc/sum.rdoc

@@ -0,0 +1,65 @@
+#
+# = Series Acceleration
+# In Ruby/GSL, series acceleration functions are provided as singleton methods
+# for the <tt>GSL::Sum::Levin_u, Levin_utrunc</tt> classes, and methods of
+# an object of the {GSL::Vector}[link:files/rdoc/vector_rdoc.html] class.
+#
+# == {}[link:index.html"name="1] Modules and classes
+# * GSL
+#   * Sum (Module)
+#     * Levin_u (Class)
+#     * Levin_utrunc (Class)
+#
+# == {}[link:index.html"name="2] Methods
+#
+# ---
+# * GSL::Sum::Levin_u.alloc(size)
+# * GSL::Sum::Levin_utrunc.alloc(size)
+#
+#
+# ---
+# * GSL::Sum::Levin_u.accel(v)
+#
+#   This method takes the terms of a series in vector <tt>v</tt> and computes 
+#   the extrapolated limit of the series using a Levin u-transform. This returns
+#   an array of <tt>[sum, abserr, sum_plain, terms_used]</tt>,
+#   where <tt>sum</tt> is the extrapolated sum, <tt>abserr</tt> is an estimate of the 
+#   absolute error, and <tt>sum_plain</tt> is the actual term-by-term sum.
+#
+# ---
+# * GSL::Sum::Levin_utrunc.accel(v)
+#
+#   This method takes the terms of a series in vector <tt>v</tt> and computes 
+#   the extrapolated limit of the series using a Levin u-transform. This returns
+#   an array of <tt>[sum, abserr_trunc, sum_plain, terms_used]</tt>.
+#
+# ---
+# * GSL::Sum::Levin_u#accel(v)
+# * GSL::Sum::Levin_u#sum_plain
+# * GSL::Sum::Levin_u#terms_used
+# * GSL::Sum::Levin_utrunc#accel(v)
+# * GSL::Sum::Levin_utrunc#sum_plain
+# * GSL::Sum::Levin_utrunc#terms_used
+#
+#
+# ---
+# * GSL::Vector#accel
+# * GSL::Vector#accel_sum
+# * GSL::Vector#sum_accel
+# * GSL::Vector#sum
+#
+#   These calculate the "extrapolated" sum of the terms contained in a 
+#   GSL::Vector object, using a Levin u-transform. The returned values is a 
+#   Ruby array with 4 elements, as [<tt>sum_accel, err, sum_plain, terms_used</tt>],
+#   where <tt>sum_accel</tt> is the extraplated sum, <tt>err</tt> is the absolute error,
+#   <tt>sum_plain</tt> is the term-by-term sum, and <tt>terms_used</tt> is the number of
+#   terms actually used in the calculation.
+#
+# {prev}[link:files/rdoc/cheb_rdoc.html]
+# {next}[link:files/rdoc/dht_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#
+#