gsl 1.15.3 → 1.16.0.6

data/rdoc/vector_complex.rdoc

@@ -1,7 +1,7 @@
 #
 # = GSL::Vector::Complex
 #
-# == {}[link:index.html"name="1] Class methods
+# == Class methods
 # ---
 # * GSL::Vector::Complex.alloc(size)
 # * GSL::Vector::Complex.alloc(re, im)
@@ -24,14 +24,14 @@
 # ---
 # * GSL::Vector::Complex.calloc(n)
 #
-#   Creates a complex vector of length <tt>n</tt> and initializes all 
+#   Creates a complex vector of length <tt>n</tt> and initializes all
 #   the elements of the vector to zero.
 #
-# == {}[link:index.html"name="2] Instance methods
-# === {}[link:index.html"name="2.1] Accessing vector elements
+# == Instance methods
+# === Accessing vector elements
 # ---
 # * GSL::Vector::Complex#get(args)
-# * GSL::Vector::Complex#[args]
+# * \GSL::Vector::Complex#[args]
 #
 #   Returns elements(s) of the complex vector <tt>self</tt> if <tt>args</tt> is a
 #   single Fixnum, a single Array of Fixnums, or a single GSL::Permutation (or
@@ -54,7 +54,7 @@
 #
 # ---
 # * GSL::Vector::Complex#set(args, val)
-# * GSL::Vector::Complex#[args]=val
+# * \GSL::Vector::Complex#[args]=val
 #
 #   If <tt>args</tt> is empty, behaves as <tt>#set_all</tt> and <tt>val</tt> must be a
 #   <tt>[re,im]</tt> <tt>Array</tt>, <tt>Float</tt>, <tt>Integer</tt>, or
@@ -73,9 +73,9 @@
 #   NOTE: GSL does not provide a vector copy function that properly copies data
 #   across overlapping memory regions, so watch out if assigning to part of a
 #   Vector from another part of itself (see <tt>#set</tt> example of
-#   {GSL::Vector}[link:files/rdoc/vector_rdoc.html]).
+#   {GSL::Vector}[link:rdoc/vector_rdoc.html]).
 #
-# === {}[link:index.html"name="2.2] Initializing vector elements
+# === Initializing vector elements
 # ---
 # * GSL::Vector::Complex#set_all(z)
 #
@@ -101,7 +101,7 @@
 #   <tt>x</tt>.  Currently, <tt>x</tt> must be a scalar, but a future Ruby GSL
 #   version could accept a GSL::Vector.
 #
-# === {}[link:index.html"name="2.3] Vector Properties
+# === Vector Properties
 # ---
 # * GSL::Vector::Complex#size
 # * GSL::Vector::Complex#len
@@ -114,7 +114,7 @@
 #
 #   Return the vector stride.
 #
-# === {}[link:index.html"name="2.4] Iterators
+# === Iterators
 # ---
 # * GSL::Vector::Complex#each
 # * GSL::Vector::Complex#each_index
@@ -124,13 +124,13 @@
 # * GSL::Vector::Complex#map!
 #
 #
-# === {}[link:index.html"name="2.5] Reordering Elements
+# === Reordering Elements
 # <tt>GSL::Vector::Complex</tt> provides four methods for shifting the frequency
-# domain data between <b>FFT order</b>, shown in the table in the ((<Overview of
-# complex data FFTs|URL:fft.html#2.1>)), and <b>natural order</b>, which has the
-# most negative freqeuncy component first, the zero frequency component in the
+# domain data between <b>FFT order</b>, shown in the table in the {Overview of
+# complex data FFTs}[link:rdoc/fft_rdoc.html#label-Overview+of+complex+data+FFTs], and <b>natural order</b>, which has
+# the most negative freqeuncy component first, the zero frequency component in the
 # middle, and the most positive frequency component last.  For more information
-# on Ruby/GSL and FFTs, see {Fast Fourier Transforms}[link:files/rdoc/fft_rdoc.html].
+# on Ruby/GSL and FFTs, see {Fast Fourier Transforms}[link:rdoc/fft_rdoc.html].
 #
 # ---
 # * GSL::Vector::Complex#fftshift
@@ -154,7 +154,7 @@
 #   <tt>self</tt>.  Note that <tt>#fftshift</tt> and <tt>#ifftshift</tt> are equivalent
 #   for even lengths, but not for odd lengths.
 #
-# === {}[link:index.html"name="2.6] Arithmetic
+# === Arithmetic
 # ---
 # * GSL::Vector::Complex#+(other)
 # * GSL::Vector::Complex#-(other)
@@ -168,7 +168,7 @@
 #   Returns a new <tt>GSL::Vector::Complex</tt> instance containing the result of
 #   the appropriate arithmetic operation on <tt>self</tt> and <tt>other</tt>.  The
 #   inputs are unchanged.  The <tt>other</tt> parameter may be a scalar,
-#   <tt>{GSL::Vector}[link:files/rdoc/vector_rdoc.html]</tt>, or <tt>GSL::Vector::Complex</tt>.
+#   <tt>{GSL::Vector}[link:rdoc/vector_rdoc.html]</tt>, or <tt>GSL::Vector::Complex</tt>.
 #
 # ---
 # * GSL::Vector::Complex#+=(other)
@@ -182,10 +182,10 @@
 #
 #   Modifies <tt>self</tt> in place to contain the result of the appropriate
 #   arithmetic operation on <tt>self</tt> and <tt>other</tt>.  The <tt>other</tt>
-#   parameter may be a scalar, <tt>{GSL::Vector}[link:files/rdoc/vector_rdoc.html]</tt>, or
+#   parameter may be a scalar, <tt>{GSL::Vector}[link:rdoc/vector_rdoc.html]</tt>, or
 #   <tt>GSL::Vector::Complex</tt>.
 #
-# === {}[link:index.html"name="2.7] Reading and writing vectors
+# === Reading and writing vectors
 # ---
 # * GSL::Vector::Complex#fwite(io)
 # * GSL::Vector::Complex#fread(io)
@@ -193,7 +193,7 @@
 # * GSL::Vector::Complex#fscanf(io)
 #
 #
-# === {}[link:index.html"name="2.8] Functions
+# === Functions
 # ---
 # * GSL::Vector::Complex#conj
 # * GSL::Vector::Complex#conjugate
@@ -272,7 +272,7 @@
 # * GSL::Vector::Complex#arccoth
 #
 #
-# === {}[link:index.html"name="2.9] Statistics
+# === Statistics
 # ---
 # * GSL::Vector::Complex#sum
 #
@@ -324,7 +324,7 @@
 #   Returns the standard deviation of <tt>self</tt> around the fixed mean
 #   <tt>mean</tt>.  This is a real number, i.e. a <tt>Float</tt>.
 #
-# == {}[link:index.html"name="3] Data Conversions
+# == Data Conversions
 # ---
 # * GSL::Vector#to_complex
 # * GSL::Vector#to_complex2
@@ -341,7 +341,7 @@
 #     [ [1.000e+00 2.000e+00] [3.000e+00 4.000e+00] ]
 #     => #<GSL::Vector::Complex:0x6d6424>
 #
-# {Reference index}[link:files/rdoc/ref_rdoc.html]
-# {top}[link:files/rdoc/index_rdoc.html]
+# {Reference index}[link:rdoc/ref_rdoc.html]
+# {top}[link:index.html]
 #
 #

data/rdoc/wavelet.rdoc

@@ -1,41 +1,41 @@
 #
 # = Discrete Wavelet Transforms
-# This chapter describes functions for performing Discrete Wavelet Transforms 
-# (DWTs). 
-# The library includes wavelets for real data in both one and two dimensions. 
+# This chapter describes functions for performing Discrete Wavelet Transforms
+# (DWTs).
+# The library includes wavelets for real data in both one and two dimensions.
 #
 # Contents:
-# 1. {Definitions}[link:files/rdoc/rdoc/wavelet_rdoc.html#1]
-# 1. {Initialization}[link:files/rdoc/rdoc/wavelet_rdoc.html#2]
-# 1. {Transform methods}[link:files/rdoc/rdoc/wavelet_rdoc.html#3]
-#    1. {Wavelet transforms in one dimension}[link:files/rdoc/rdoc/wavelet_rdoc.html#3.1]
-#    1. {Wavelet transforms in two dimension}[link:files/rdoc/rdoc/wavelet_rdoc.html#3.2]
-# 1. {Examples}[link:files/rdoc/rdoc/wavelet_rdoc.html#4]
+# 1. {Definitions}[link:rdoc/wavelet_rdoc.html#label-Definitions]
+# 1. {Initialization}[link:rdoc/wavelet_rdoc.html#label-Initialization]
+# 1. {Transform methods}[link:rdoc/wavelet_rdoc.html#label-Transform+Methods]
+#    1. {Wavelet transforms in one dimension}[link:rdoc/wavelet_rdoc.html#label-Wavelet+transforms+in+one+dimension]
+#    1. {Wavelet transforms in two dimension}[link:rdoc/wavelet_rdoc.html#label-Wavelet+transforms+in+two+dimension]
+# 1. {Examples}[link:rdoc/wavelet_rdoc.html#label-Example]
 #
-# == {}[link:index.html"name="1] Definitions
+# == Definitions
 #
 # The continuous wavelet transform and its inverse are defined by the relations,
 # and,
-# where the basis functionspsi_{s,tau} are obtained by scaling and translation 
+# where the basis functionspsi_{s,tau} are obtained by scaling and translation
 # from a single function, referred to as the mother wavelet.
 #
-# The discrete version of the wavelet transform acts on evenly sampled data, 
-# with fixed scaling and translation steps (s, tau). The frequency and time 
-# axes are sampled dyadically on scales of 2^j through a level parameter j. 
-# The resulting family of functions {psi_{j,n}} constitutes an orthonormal 
+# The discrete version of the wavelet transform acts on evenly sampled data,
+# with fixed scaling and translation steps (s, tau). The frequency and time
+# axes are sampled dyadically on scales of 2^j through a level parameter j.
+# The resulting family of functions {psi_{j,n}} constitutes an orthonormal
 # basis for square-integrable signals.
 #
-# The discrete wavelet transform is an O(N) algorithm, and is also referred to as 
+# The discrete wavelet transform is an O(N) algorithm, and is also referred to as
 # the fast wavelet transform.
 #
-# == {}[link:index.html"name="2] Initialization
+# == Initialization
 #
 # ---
 # * GSL::Wavelet.alloc(type, k)
 # * GSL::Wavelet.alloc(type, k)
 #
-#   This function allocates and initializes a wavelet object of type <tt>type</tt>. 
-#   The parameter <tt>k</tt> selects the specific member of the wavelet family. 
+#   This function allocates and initializes a wavelet object of type <tt>type</tt>.
+#   The parameter <tt>k</tt> selects the specific member of the wavelet family.
 #
 #   The wavelet types are given by a constant (Fixnum) or a string as followings.
 #
@@ -46,8 +46,8 @@
 #   * <tt>GSL::Wavelet::BSPLINE</tt>, or <tt>"bspline"</tt>
 #   * <tt>GSL::Wavelet::BSPLINE_CENTERED</tt>, or <tt>"bspline_centered"</tt>
 #
-#   The centered forms of the wavelets align the coefficients of the various 
-#   sub-bands on edges. Thus the resulting visualization of the coefficients 
+#   The centered forms of the wavelets align the coefficients of the various
+#   sub-bands on edges. Thus the resulting visualization of the coefficients
 #   of the wavelet transform in the phase plane is easier to understand.
 #
 # ---
@@ -58,16 +58,16 @@
 # ---
 # * GSL::Wavelet::Workspace.alloc(n)
 #
-#   The GSL::Wavelet::Workspace object contains scratch space of the same size as 
+#   The GSL::Wavelet::Workspace object contains scratch space of the same size as
 #   the input data, for holding intermediate results during the transform.
-#   This method allocates a workspace for the discrete wavelet transform. 
-#   To perform a one-dimensional transform on <tt>n</tt> elements, a workspace of 
-#   size <tt>n</tt> must be provided. For two-dimensional transforms of n-by-n 
-#   matrices it is sufficient to allocate a workspace of size <tt>n</tt>, 
+#   This method allocates a workspace for the discrete wavelet transform.
+#   To perform a one-dimensional transform on <tt>n</tt> elements, a workspace of
+#   size <tt>n</tt> must be provided. For two-dimensional transforms of n-by-n
+#   matrices it is sufficient to allocate a workspace of size <tt>n</tt>,
 #   since the transform operates on individual rows and columns.
 #
-# == {}[link:index.html"name="3] Transform Methods
-# === {}[link:index.html"name="3.1] Wavelet transforms in one dimension
+# == Transform Methods
+# === Wavelet transforms in one dimension
 #
 # ---
 # * GSL::Wavelet.transform(w, v, dir = GSL::Wavelet::FORWARD, work)
@@ -90,24 +90,24 @@
 # * GSL::Vector#wavelet_transform_forward(w, ...)
 # * GSL::Vector#wavelet_transform_inverse(w, ...)
 #
-#   These methods compute forward and inverse discrete wavelet transforms 
-#   of the vector <tt>v</tt>. The length of the transform is restricted to powers 
-#   of two. For the transform version of the function the argument dir can be 
-#   either GSL::Wavelet::FORWARD (+1) or GSL::Wavelet::BACKWARD (-1). 
+#   These methods compute forward and inverse discrete wavelet transforms
+#   of the vector <tt>v</tt>. The length of the transform is restricted to powers
+#   of two. For the transform version of the function the argument dir can be
+#   either GSL::Wavelet::FORWARD (+1) or GSL::Wavelet::BACKWARD (-1).
 #   A workspace <tt>work</tt> can be omitted.
-#   
+#
 #   If <tt>v</tt> is a <tt>GSL::Matrix</tt> object, methods for 2d-transforms
 #   are called.
 #
-#   For the forward transform, the elements of the original vector are replaced by 
-#   the discrete wavelet transform f_i -> w_{j,k} in a packed triangular storage 
-#   layout, where j is the index of the level j = 0 ... J-1 and k is the index of 
-#   the coefficient within each level, k = 0 ... (2^j)-1. The total number of 
-#   levels is J = log_2(n). 
+#   For the forward transform, the elements of the original vector are replaced by
+#   the discrete wavelet transform f_i -> w_{j,k} in a packed triangular storage
+#   layout, where j is the index of the level j = 0 ... J-1 and k is the index of
+#   the coefficient within each level, k = 0 ... (2^j)-1. The total number of
+#   levels is J = log_2(n).
 #
 #   These methods return a transformed data, and the input vector is not changed.
 #
-# === {}[link:index.html"name="3.2] Wavelet transforms in two dimension
+# === Wavelet transforms in two dimension
 # ---
 # * GSL::Wavelet.transform(same as the methods for one dimensional transforms)
 # * GSL::Wavelet.transform_matrix()
@@ -162,13 +162,13 @@
 # * GSL::Wavelet2d#nstransform_inverse()
 #
 #
-# == {}[link:index.html"name="4] Example
+# == Example
 #   #!/usr/bin/env ruby
 #   require("gsl")
 #
 #   n = 256
 #   nc = 20
-#  
+#
 #   data = Vector.alloc(n)
 #   data.fscanf("ecg.dat")
 #
@@ -194,7 +194,7 @@
 #   i = 0
 #   while (i + nc) < n
 #     data2[perm[i]] = 0.0
-#     i += 1  
+#     i += 1
 #   end
 #
 #   #data3 = w.transform(data2, Wavelet::BACKWARD, work)
@@ -210,9 +210,9 @@
 #
 #   #If you have GNU graph utility...
 #   GSL::graph(nil, data, data3, "-T X -C -g 3")
-#   
-# {prev}[link:files/rdoc/rdoc/fft_rdoc.html]
-# {next}[link:files/rdoc/rdoc/integration_rdoc.html]
 #
-# {back}[link:files/rdoc/rdoc/index_rdoc.html]
+# {prev}[link:rdoc/fft_rdoc.html]
+# {next}[link:rdoc/integration_rdoc.html]
+#
+# {back}[link:index.html]
 #

data/test/gsl/blas_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class BlasTest < GSL::TestCase
+
+  DBLEPS = 1e-6
+
+  def test_amax
+    v = GSL::Vector.alloc(0.537, 0.826)
+    assert_int v.idamax, 1, 'damax'
+
+    vz = GSL::Vector::Complex.alloc([0.913, -0.436], [-0.134, 0.129])
+    assert_int vz.izamax, 0, 'zmax'
+  end
+
+  def test_asum
+    v = GSL::Vector.alloc(0.271, -0.012)
+    assert_rel v.dasum, 0.283, DBLEPS, 'dasum'
+
+    vz = GSL::Vector::Complex.alloc([-0.046, -0.671], [-0.323, 0.785])
+    assert_rel vz.dzasum, 1.825, DBLEPS, 'dzasum'
+  end
+
+  def test_axpy
+    x = GSL::Vector.alloc(0.029)
+    y = GSL::Vector.alloc(-0.992)
+    e = GSL::Vector.alloc(-1.0007)
+
+    y2 = GSL::Blas.daxpy(-0.3, x, y)
+
+    assert_rel y2[0], e[0], DBLEPS, 'daxpy'
+
+    x = GSL::Vector::Complex.alloc([[0.776, -0.671]])
+    y = GSL::Vector::Complex.alloc([[0.39, 0.404]])
+    e = GSL::Vector::Complex.alloc([[1.061, 1.18]])
+
+    y2 = GSL::Blas.zaxpy(GSL::Complex.alloc(0, 1), x, y)
+
+    assert_rel y2[0].re, e[0].re, DBLEPS, 'zaxpy real'
+    assert_rel y2[0].im, e[0].im, DBLEPS, 'zaxpy imag'
+  end
+
+  def test_copy
+    x = GSL::Vector.alloc(0.002)
+    y = GSL::Vector.alloc(-0.921)
+    e = GSL::Vector.alloc(0.002)
+
+    GSL::Blas.dcopy(x, y)
+
+    assert_rel y[0], e[0], DBLEPS, 'dcopy'
+
+    x = GSL::Vector::Complex.alloc([[ 0.315, -0.324]])
+    y = GSL::Vector::Complex.alloc([[-0.312, -0.748]])
+    e = GSL::Vector::Complex.alloc([[0.315, -0.324]])
+
+    GSL::Blas.zcopy(x, y)
+
+    assert_rel y[0].re, e[0].re, DBLEPS, 'zcopy real'
+    assert_rel y[0].im, e[0].im, DBLEPS, 'zcopy imag'
+  end
+
+  def test_dnrm2
+    return unless GSL.have_narray?
+
+    e = Math.sqrt((0..4).inject { |m, x| m + x * x })
+
+    v = GSL::Vector.indgen(5)
+    v_dnrm2 = GSL::Blas.dnrm2(v)
+
+    assert_rel v_dnrm2, e, DBLEPS, 'GSL::Blas.dnrm2(GSL::Vector)'
+
+    na = NArray.float(5).indgen!
+    na_dnrm2 = GSL::Blas.dnrm2(na)
+
+    assert_rel na_dnrm2, e, DBLEPS, 'GSL::Blas.dnrm2(NArray)'
+
+    assert_rel na_dnrm2, v_dnrm2, 0, 'GSL::Blas.dnrm2(NArray) == GSL::Blas.dnrm2(GSL::Vector)'
+  end
+
+end

data/test/gsl/bspline_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class BsplineTest < GSL::TestCase
+
+  N = 100
+
+  NMAX = 10
+  BMAX = 10  # 100
+
+  def _test_bspline(bw)
+    ncoeffs, order = bw.ncoeffs, bw.order
+
+    a = bw.breakpoint(0)
+    b = bw.breakpoint(bw.nbreak - 1)
+
+    N.times { |i|
+      xi, sum = a + (b - a) * (i / (N - 1)), 0.0
+
+      bb = bw.eval(xi)
+
+      ncoeffs.times { |j|
+        bj = bb[j]
+        refute bj < 0 || bj > 1,
+          "basis-spline coefficient #{j} is in range [0,1] for x=#{xi}"
+
+        sum += bj
+      }
+
+      assert_rel sum, 1.0, order * GSL::DBL_EPSILON,
+        "basis-spline coefficient #{order} is in range [0,1] for x=#{xi}"
+    }
+  end
+
+  def test_bspline_knots_uniform
+    1.upto(NMAX) { |order|
+      2.upto(BMAX) { |breakpoints|
+        bw = GSL::BSpline.alloc(order, breakpoints)
+        bw.knots_uniform(-1.23 * order, 45.6 * order)
+        _test_bspline(bw)
+      }
+    }
+  end
+
+  def test_bspline_knots
+    1.upto(NMAX) { |order|
+      2.upto(BMAX) { |breakpoints|
+        a, b = -1.23 * order, 45.6 * order
+
+        bw = GSL::BSpline.alloc(order, breakpoints)
+        k = GSL::Vector.alloc(breakpoints)
+
+        breakpoints.times { |i|
+          f = GSL.sqrt(i.to_f / (breakpoints - 1.0))
+          k[i] = (1 - f) * a + f * b
+        }
+
+        bw.knots(k)
+        _test_bspline(bw)
+      }
+    }
+  end
+
+end