gsl 1.16.0.6 → 2.1.0

data/ext/gsl_native/tamu_anova.c

@@ -32,7 +32,7 @@ VALUE rb_tamu_anova_alloc(int argc, VALUE *argv, VALUE klass)
 VALUE rb_tamu_anova_printtable(VALUE *vTable)
 {
   struct tamu_anova_table *table;
-  Data_Get_Struct(vTable, struct tamu_anova_table, table);
+  Data_Get_Struct(*vTable, struct tamu_anova_table, table);
   tamu_anova_printtable(*table);
   return Qtrue;
 }

data/gsl.gemspec

@@ -21,9 +21,16 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.3'
   s.requirements = ['GSL (http://www.gnu.org/software/gsl/)']
 
-  s.post_install_message = "#{s.name} can be installed with or without narray support. Please install narray before and reinstall #{s.name} if it is missing."
+  s.post_install_message = %{
+    #{s.name} can be installed with or without narray support. Please install
+    narray before and reinstall #{s.name} if it is missing.
+
+    #{s.name} is also now compatible with NMatrix. Please install nmatrix before
+    installing #{s.name}.
+  }
 
   s.add_development_dependency 'rake-compiler', '>= 0'
   s.add_development_dependency 'rake', '>= 0'
   s.add_development_dependency 'test-unit', '>= 0'
+  s.add_development_dependency 'bundler', '~> 1.11'
 end

data/lib/gsl.rb

@@ -3,6 +3,11 @@ begin
 rescue LoadError
 end
 
+begin
+  require 'nmatrix/nmatrix'
+rescue LoadError
+end
+
 require 'gsl_native'
 require 'gsl/version'
 require 'gsl/oper'

data/lib/gsl/version.rb

@@ -1,3 +1,3 @@
 module GSL
-  RUBY_GSL_VERSION = RB_GSL_VERSION = '1.16.0.6'
+  RUBY_GSL_VERSION = RB_GSL_VERSION = '2.1.0'
 end

data/rdoc/nmatrix.rdoc

@@ -0,0 +1,129 @@
+#
+# = NMatrix compatibilities
+# === Contents:
+# 1. {Data type conversions}[link:rdoc/nmatrix_rdoc.html#label-Data+type+conversions]
+# 1. {Methods which accepts NArray}[link:rdoc/narray_rdoc.html#label-Methods+which+accepts+NArray]
+#
+# == Data type conversions
+# === GSL to NMatrix
+#
+# ---
+# * GSL::Vector#to_nm
+# * GSL::Vector::Complex#to_nm
+# * GSL::Vector::Int#to_nm
+# * GSL::Matrix#to_nm
+# * GSL::Matrix::Complex#to_nm
+# * GSL::Matrix::Int#to_nm
+#
+#   Convert GSL objects to NMatrix. The data contained by the GSL objects
+#   are copied to a newly allocated memory block of the NMatrix objects created.
+#
+# === NMatrix to GSL
+# ---
+# * NMatrix#to_gslv
+# * NMatrix#to_gslm
+#
+#   <tt>NMatrix#to_gslv</tt> converts NMatrix objects to <tt>GSL::Vector</tt>,
+#   <tt>GSL::Vector::Complex</tt> or <tt>GSL::Vector::Int</tt>.  
+#   <tt>NMatrix#to_gslm</tt> converts NMatrix objects to <tt>GSL::Matrix</tt>,
+#   <tt>GSL::Matrix::Int</tt> or <tt>GSL::Matrix::Complex</tt>.
+#
+#   The data contained by the NMatrix objects are copied to a newly allocated
+#   memory block of the GSL objects created.
+#
+# == Methods which accepts NMatrix
+# === <tt>GSL</tt> module
+# ---
+# * GSL::graph()
+# * GSL::log1p(x)
+# * GSL::expm1(x)
+# * GSL::hypot(x, y)
+# * GSL::acosh(x)
+# * GSL::asinh(x)
+# * GSL::atanh(x)
+# * GSL::pow(x, a)
+# * GSL::pow_int(x, n)
+# * GSL::pow_2(x), ..., GSL::pow_9(x)
+#
+#
+# === <tt>Sf</tt> module
+# ---
+# * {Any}[link:rdoc/sf_rdoc.html]
+#
+# === <tt>Linalg</tt> module
+# ---
+# * GSL::Linalg::LU.decomp(na)
+# * GSL::Linalg::LU.solve(lu, b)
+# * GSL::Linalg::LU.svx(lu, bx)
+# * GSL::Linalg::LU.det(lu, sign)
+# * GSL::Linalg::LU.invert(lu, perm)
+# * GSL::Linalg::QR.decomp(m)
+# * GSL::Linalg::QR.solve(qr, tau, b)
+# * GSL::Linalg::QR.svx(qr, tau, bx)
+# * GSL::Linalg::SV.decomp(m)
+# * GSL::Linalg::SV.solve(u, v, s, b)
+# * GSL::Linalg::SV.svx(u, v, s, bx)
+# * GSL::Linalg::Cholesky.decomp(m)
+# * GSL::Linalg::Cholesky.solve(u, v, s, b)
+# * GSL::Linalg::Cholesky.svx(u, v, s, bx)
+# * GSL::Linalg::HH.solve(m, b)
+# * GSL::Linalg::HH.svx(m, bx)
+#
+#
+# === <tt>Eigen</tt> module
+# ---
+# * GSL::Eigen::symm(na)
+# * GSL::Eigen::symmv(na)
+#
+#
+# === <tt>FFT</tt> module
+# ---
+# * {Many}[link:rdoc/fft_rdoc.html]
+#
+# === <tt>Function</tt> class
+# ---
+# * GSL::Function#eval
+# * GSL::Function#deriv_central(x, h)
+# * GSL::Function#deriv_forward(x, h)
+# * GSL::Function#deriv_backward(x, h)
+# * GSL::Function#diff_central(x, h)
+# * GSL::Function#diff_forward(x, h)
+# * GSL::Function#diff_backward(x, h)
+#
+#
+# === <tt>Ran</tt> and <tt>Cdf</tt> module
+# ---
+# * {Many}[link:rdoc/randist_rdoc.html]
+#
+# === <tt>Stats</tt> module
+# ---
+# * {Any}[link:rdoc/stats_rdoc.html]
+#
+# === <tt>Interp</tt> and <tt>Spline</tt> class
+# ---
+# * GSL::Interp#init
+# * GSL::Interp#eval
+# * GSL::Spline#init
+# * GSL::Spline#eval
+#
+#
+# === <tt>Deriv</tt> and <tt>Diff</tt> module
+# ---
+# TODO
+#
+#
+# === <tt>Cheb</tt> class
+# ---
+# * GSL::Cheb#eval(x)
+# * GSL::Cheb#eval_n(n, x)
+#
+#
+# === <tt>Wavelet</tt> class
+# ---
+# TODO
+#
+# {prev}[link:rdoc/tensor_rdoc.html]
+#
+# {Reference index}[link:rdoc/ref_rdoc.html]
+# {top}[link:index.html]
+#

data/rdoc/ref.rdoc

@@ -84,6 +84,7 @@
 #    1. {NDLINEAR: multi-linear, multi-parameter least squares fitting}[link:rdoc/ndlinear_rdoc.html]
 #    1. {ALF: associated Legendre polynomials}[link:rdoc/alf_rdoc.html]
 # 1. {NArray compatibilities}[link:rdoc/narray_rdoc.html]
+# 1. {NMatrix compatibilities}[link:rdoc/nmatrix_rdoc.html]
 # 1. {Changes since Ruby/GSL 1.10.3}[link:rdoc/changes_rdoc.html]
 # 1. {GNU Free Documentation Licence}[https://gnu.org/software/gsl/manual/html_node/GNU-Free-Documentation-License.html]
 #

data/test.sh

@@ -0,0 +1,21 @@
+#!/bin/bash 
+function compile_and_test {
+  bundle install
+  rake clobber
+  rake compile --silent --quiet
+  rake test  
+}
+echo "Testing without NMATRIX or NARRAY...\n\n"
+unset NMATRIX
+unset NARRAY
+compile_and_test
+
+echo "Testing with NMATRIX=1...\n\n"
+export NMATRIX=1
+compile_and_test
+unset NMATRIX
+
+echo "Testing with NARRAY=1...\n\n"
+export NARRAY=1
+compile_and_test
+unset NARRAY

data/test/gsl/bspline_test.rb

@@ -42,22 +42,23 @@ class BsplineTest < GSL::TestCase
   end
 
   def test_bspline_knots
-    1.upto(NMAX) { |order|
-      2.upto(BMAX) { |breakpoints|
+    1.upto(NMAX) do |order|
+      2.upto(BMAX) do |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)
-      }
-    }
+        test_data = [GSL::Vector.alloc(breakpoints)]
+        test_data << NMatrix.new([breakpoints], dtype: :float64) if ENV['NMATRIX']
+        test_data.each do |k|
+          breakpoints.times do |i|
+            f = GSL.sqrt(i.to_f / (breakpoints - 1.0))
+            k[i] = (1 - f) * a + f * b
+          end
+
+          bw.knots(k)
+          _test_bspline(bw)
+        end
+      end
+    end
   end
-
 end

data/test/gsl/combination_test.rb

@@ -4,14 +4,25 @@ class CombinationTest < GSL::TestCase
 
   def setup
     @c63 = GSL::Matrix.alloc(
-      [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5],
-      [0, 2, 3], [0, 2, 4], [0, 2, 5],
-      [0, 3, 4], [0, 3, 5],
+      [0, 1, 2], 
+      [0, 1, 3], 
+      [0, 1, 4], 
+      [0, 1, 5],
+      [0, 2, 3], 
+      [0, 2, 4],
+      [0, 2, 5],
+      [0, 3, 4], 
+      [0, 3, 5],
       [0, 4, 5],
-      [1, 2, 3], [1, 2, 4], [1, 2, 5],
-      [1, 3, 4], [1, 3, 5],
+      [1, 2, 3], 
+      [1, 2, 4], 
+      [1, 2, 5],
+      [1, 3, 4], 
+      [1, 3, 5],
       [1, 4, 5],
-      [2, 3, 4], [2, 3, 5], [2, 4, 5],
+      [2, 3, 4], 
+      [2, 3, 5], 
+      [2, 4, 5],
       [3, 4, 5]
     )
   end

data/test/gsl/dht_test.rb

@@ -4,26 +4,38 @@ class DhtTest < GSL::TestCase
 
   N = 128
 
+  def test_dht
+    test_data = [GSL::Vector.alloc(N)]
+    test_data << NMatrix.new([N], dtype: :float64) if ENV['NMATRIX']
+    test_data.each do |vin|
+      dht2 vin
+      dht3 vin
+      dht4 vin
+    end
+  end
+  
   def test_dht1
-    vin = GSL::Vector.alloc(1, 2, 3)
-    dht = GSL::Dht.alloc(3, 1.0, 1.0)
+    test_data = [GSL::Vector.alloc(1, 2, 3)]
+    test_data << NMatrix.new([3], [1,2,3], dtype: :float64) if ENV['NMATRIX']
+    test_data.each do |vin|
+      dht = GSL::Dht.alloc(3, 1.0, 1.0)
 
-    vout = dht.apply(vin)
+      vout = dht.apply(vin)
 
-    assert_equal  0.3752546494075203,  vout[0]
-    assert_equal(-0.13350787269556064, vout[1])
-    assert_equal  0.0446799251438404,  vout[2]
+      assert_in_delta  0.3752546494075203,  vout[0], 0.001
+      assert_in_delta(-0.13350787269556064, vout[1], 0.001)
+      assert_in_delta  0.0446799251438404,  vout[2], 0.001
 
-    vin2 = dht.apply(vout)
-    vin2.scale!(13.323691936314223 ** 2)
+      vin2 = dht.apply(vout)
+      vin2 = vin2 * (13.323691936314223 ** 2)
 
-    assert_equal 1.0000119186762644, vin2[0]
-    assert_equal 1.9999790476647084, vin2[1]
-    assert_equal 3.000035803234503,  vin2[2]
+      assert_in_delta 1.0000119186762644, vin2[0], 0.001
+      assert_in_delta 1.9999790476647084, vin2[1], 0.001
+      assert_in_delta 3.000035803234503,  vin2[2], 0.001
+    end
   end
 
-  def test_dht2
-    vin = GSL::Vector.alloc(N)
+  def dht2 vin
     dht = GSL::Dht.alloc(N, 0.0, 100.0)
 
     N.times { |i|
@@ -33,15 +45,14 @@ class DhtTest < GSL::TestCase
 
     vout = dht.apply(vin)
 
-    assert_equal 3.999613382195876,   vout[0]
-    assert_equal 1.8387637474026606,  vout[5]
-    assert_equal 1.2677885358829588,  vout[10]
-    assert_equal 0.3521910403797792,  vout[35]
-    assert_equal 0.02373661279695407, vout[100]
+    assert_in_delta 3.999613382195876,   vout[0], 0.001
+    assert_in_delta 1.8387637474026606,  vout[5], 0.001
+    assert_in_delta 1.2677885358829588,  vout[10], 0.001
+    assert_in_delta 0.3521910403797792,  vout[35], 0.001
+    assert_in_delta 0.02373661279695407, vout[100], 0.001
   end
 
-  def test_dht3
-    vin = GSL::Vector.alloc(N)
+  def dht3 vin
     dht = GSL::Dht.alloc(N, 1.0, 20.0)
 
     N.times { |i|
@@ -51,15 +62,14 @@ class DhtTest < GSL::TestCase
 
     vout = dht.apply(vin)
 
-    assert_equal 0.18148296716239096,   vout[0]
-    assert_equal 0.35680451269699853,   vout[5]
-    assert_equal 0.21101009980456306,   vout[10]
-    assert_equal 0.02892068100516861,   vout[35]
-    assert_equal 0.0022121119664674426, vout[100]
+    assert_in_delta 0.18148296716239096,   vout[0], 0.001
+    assert_in_delta 0.35680451269699853,   vout[5], 0.001
+    assert_in_delta 0.21101009980456306,   vout[10], 0.001
+    assert_in_delta 0.02892068100516861,   vout[35], 0.001
+    assert_in_delta 0.0022121119664674426, vout[100], 0.001
   end
 
-  def test_dht4
-    vin = GSL::Vector.alloc(N)
+  def dht4 vin
     dht = GSL::Dht.alloc(N, 1.0, 1.0)
 
     N.times { |i|
@@ -69,11 +79,10 @@ class DhtTest < GSL::TestCase
 
     vout = dht.apply(vin)
 
-    assert_equal  0.05727421417071144,    vout[0]
-    assert_equal(-0.0001908501261051786,  vout[5])
-    assert_equal  2.434180086051901e-05,  vout[10]
-    assert_equal(-4.0392713194195724e-07, vout[35])
-    assert_equal  8.255662619348403e-09,  vout[100]
+    assert_in_delta  0.05727421417071144,    vout[0], 0.001
+    assert_in_delta -0.0001908501261051786,  vout[5], 0.001
+    assert_in_delta  2.434180086051901e-05,  vout[10], 0.001
+    assert_in_delta -4.0392713194195724e-07, vout[35], 0.001
+    assert_in_delta  8.255662619348403e-09,  vout[100], 0.001
   end
-
 end

data/test/gsl/nmatrix_tests/nmatrix_cheb_test.rb

@@ -0,0 +1,34 @@
+require_relative '../../test_helper'
+
+class NMatrixChebTest < GSL::TestCase
+  def test_eval
+    f = GSL::Function.alloc do |x|
+      if x < 0.5
+        0.25
+      else
+        0.75
+      end
+    end
+
+    n = 1000
+    order = 40
+    cs = GSL::Cheb.alloc(order)
+    x = NMatrix.new([n], GSL::Vector.linspace(0, 1, n).to_a, dtype: :float64)
+
+    ff = f.eval(x)
+
+    assert ff.class == NMatrix
+
+    cs.init(f, 0, 1)
+    r10 = cs.eval_n(10, x)
+    r40 = cs.eval(x)
+
+    assert r10.class == NMatrix
+    assert_rel r10.to_a.last, 0.758879, 0.001, 'test r10.last'
+    assert_rel r10[5]  , 0.247816, 0.001, 'test r10[5]'
+
+    assert r40.class == NMatrix
+    assert_rel r40[5]   , 0.255682, 0.001, 'test r40[5]'
+    assert_rel r40.first, 0.25633 , 0.001, 'test r40.first'
+  end
+end

data/test/gsl/nmatrix_tests/nmatrix_eigen_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class NMatrixEigenTest < GSL::TestCase
+  def setup
+    @nmatrix = NMatrix.new([4,4],
+      [1.0, 1/2.0, 1/3.0, 1/4.0, 
+       1/2.0, 1/3.0, 1/4.0, 1/5.0,
+       1/3.0, 1/4.0, 1/5.0, 1/6.0,
+       1/4.0, 1/5.0, 1/6.0, 1/7.0], dtype: :float64)
+  end
+
+  def test_symm_symmv
+    eigen_values = NMatrix.new([4], 
+      [1.50021, 0.169141, 0.00673827, 9.67023e-05], dtype: :float64)
+    eigen_vectors = NMatrix.new([4,4],
+      [0.792608, 0.582076,-0.179186,-0.0291933, 
+       0.451923,-0.370502, 0.741918, 0.328712 , 
+       0.322416,-0.509579,-0.100228,-0.791411 , 
+       0.252161,-0.514048,-0.638283, 0.514553], dtype: :float64)
+    
+    assert_enum_abs GSL::Eigen.symm(@nmatrix), eigen_values, 0.001, "GSL::Eigen.symm(nmatrix)"
+
+    # val, vec = GSL::Eigen.symmv(@nmatrix)
+
+    # assert_enum_abs val, eigen_values , 0.001, "GSL::Eigen.symmv(nmatrix)"
+    # assert_enum_abs vec, eigen_vectors, 0.001, "GSL::Eigen.symmv(nmatrix)"
+  end
+end