rb-gsl 1.16.0.5 → 1.16.0.6

data/rdoc/siman.rdoc

@@ -1,89 +0,0 @@
-#
-# = Simulated Annealing
-# === Library
-#
-# == Module and classes
-# * GSL::
-#   * Siman::  (Module)
-#     * Params (Class)
-#     * Efunc (Class)
-#     * Step (Class)
-#     * Metric (Class)
-#     * Print (Class)
-#
-# == <tt>Siman</tt> Module
-# === 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.
-#
-# == 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:rdoc/monte_rdoc.html]
-# {next}[link:rdoc/odeiv_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#

data/rdoc/sort.rdoc

@@ -1,94 +0,0 @@
-#
-# = Sorting
-# Contents:
-# 1. {Heapsort of vectors}[link:rdoc/sort_rdoc.html#label-Heapsort]
-# 1. {Sorting vectors}[link:rdoc/sort_rdoc.html#label-Sorting+vectors]
-# 1. {Selecting the k smallest or largest elements}[link:rdoc/sort_rdoc.html#label-Selecting+the+k+smallest+or+largest+elements]
-#
-# == 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.
-#
-# == 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.
-#
-# == 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:rdoc/combi_rdoc.html]
-# {next}[link:rdoc/blas_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#

data/rdoc/start.rdoc

@@ -1,16 +0,0 @@
-#
-# = Getting started
-#
-# 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.
-#
-# The {Ruby/GSL}[https://sciruby.github.com/rb-gsl] is Ruby
-# bindings for GSL. This provides higher-level interfaces to the GSL functions.
-# See {here}[link: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

@@ -1,219 +0,0 @@
-#
-# = Statistics
-# 1. {Mean, Standard Deviation and Variance}[link:rdoc/stats_rdoc.html#label-Mean%2C+Standard+Deviation+and+Variance]
-# 1. {Absolute deviation}[link:rdoc/stats_rdoc.html#label-Absolute+deviation]
-# 1. {Higher moments (skewness and kurtosis)}[link:rdoc/stats_rdoc.html#label-Higher+moments+%28skewness+and+kurtosis%29]
-# 1. {Autocorrelation}[link:rdoc/stats_rdoc.html#label-Autocorrelation]
-# 1. {Covariance}[link:rdoc/stats_rdoc.html#label-Covariance]
-# 1. {Correlation}[link:rdoc/stats_rdoc.html#label-Correlation]
-# 1. {Weighted samples}[link:rdoc/stats_rdoc.html#label-Weighted+samples]
-# 1. {Maximum and minimum values}[link:rdoc/stats_rdoc.html#label-Maximum+and+Minimum+values]
-# 1. {Median and percentiles}[link:rdoc/stats_rdoc.html#label-Median+and+Percentiles]
-# 1. {Examples}[link:rdoc/stats_rdoc.html#label-Example]
-#
-# == 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>.
-#
-# == Absolute deviation
-# ---
-# * GSL::Stats::absdev(v[, mean])
-# * \GSL::Vector#absdev([mean])
-#
-#   Compute the absolute deviation (from the mean <tt>mean</tt> if given).
-#
-# == 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
-#
-# == Autocorrelation
-# ---
-# * GSL::Stats::lag1_autocorrelation(v[, mean])
-# * \GSL::Vector#lag1_autocorrelation([mean])
-#
-#   The lag-1 autocorrelation
-#
-# == Covariance
-# ---
-# * GSL::Stats::covariance(v1, v2)
-# * GSL::Stats::covariance_m(v1, v2, mean1, mean2)
-#
-#   Covariance of vectors <tt>v1, v2</tt>.
-#
-# == Correlation
-# ---
-# * GSL::Stats::correlation(v1, v2)
-#
-#   This efficiently computes the Pearson correlation coefficient between the vectors <tt>v1, v2</tt>. (>= GSL-1.10)
-#
-# == 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)
-#
-#
-# == 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.
-#
-#
-# == 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.
-#
-# == 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:rdoc/randist_rdoc.html]
-# {next}[link:rdoc/hist_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#

data/rdoc/sum.rdoc

@@ -1,65 +0,0 @@
-#
-# = 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:rdoc/vector_rdoc.html] class.
-#
-# == Modules and classes
-# * GSL
-#   * Sum (Module)
-#     * Levin_u (Class)
-#     * Levin_utrunc (Class)
-#
-# == 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:rdoc/cheb_rdoc.html]
-# {next}[link:rdoc/dht_rdoc.html]
-#
-# {Reference index}[link:rdoc/ref_rdoc.html]
-# {top}[link:index.html]
-#
-#
-#