gsl 1.15.3 → 1.16.0.6

data/test/gsl/stats_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+class StatsTest < GSL::TestCase
+
+  def test_stats
+    lew = GSL::Vector.alloc(
+      -213, -564,  -35,  -15,  141,  115, -420, -360,  203, -338, -431,  194,
+      -220, -513,  154, -125, -559,   92,  -21, -579,  -52,   99, -543, -175,
+       162, -457, -346,  204, -300, -474,  164, -107, -572,   -8,   83, -541,
+      -224,  180, -420, -374,  201, -236, -531,   83,   27, -564, -112,  131,
+      -507, -254,  199, -311, -495,  143,  -46, -579,  -90,  136, -472, -338,
+       202, -287, -477,  169, -124, -568,   17,   48, -568, -135,  162, -430,
+      -422,  172,  -74, -577,  -13,   92, -534, -243,  194, -355, -465,  156,
+       -81, -578,  -64,  139, -449, -384,  193, -198, -538,  110,  -44, -577,
+        -6,   66, -552, -164,  161, -460, -344,  205, -281, -504,  134,  -28,
+      -576, -118,  156, -437, -381,  200, -220, -540,   83,   11, -568, -160,
+       172, -414, -408,  188, -125, -572,  -32,  139, -492, -321,  205, -262,
+      -504,  142,  -83, -574,    0,   48, -571, -106,  137, -501, -266,  190,
+      -391, -406,  194, -186, -553,   83,  -13, -577,  -49,  103, -515, -280,
+       201,  300, -506,  131,  -45, -578,  -80,  138, -462, -361,  201, -211,
+      -554,   32,   74, -533, -235,  187, -372, -442,  182, -147, -566,   25,
+        68, -535, -244,  194, -351, -463,  174, -125, -570,   15,   72, -550,
+      -190,  172, -424, -385,  198, -218, -536,   96
+    )
+
+    mean = lew.mean
+    sd   = lew.sd
+    lag1 = lew.lag1_autocorrelation
+
+    assert_rel mean, -177.435000000000,    1e-15, 'lew gsl_stats_mean'
+    assert_rel sd,    277.332168044316,    1e-15, 'lew gsl_stats_sd'
+    assert_rel lag1,   -0.307304800605679, 1e-14, 'lew autocorrelation'
+
+    rel = 1e-10
+
+    rawa = GSL::Vector.alloc(
+      0.0421, 0.0941, 0.1064, 0.0242, 0.1331,
+      0.0773, 0.0243, 0.0815, 0.1186, 0.0356,
+      0.0728, 0.0999, 0.0614, 0.0479
+    )
+
+    rawb = GSL::Vector.alloc(
+      0.1081, 0.0986, 0.1566, 0.1961, 0.1125,
+      0.1942, 0.1079, 0.1021, 0.1583, 0.1673,
+      0.1675, 0.1856, 0.1688, 0.1512
+    )
+
+    raww = GSL::Vector.alloc(
+      0.0000, 0.0000, 0.0000, 3.000, 0.0000,
+      1.0000, 1.0000, 1.0000, 0.000, 0.5000,
+      7.0000, 5.0000, 4.0000, 0.123
+    )
+
+    assert_rel mean = rawa.mean, 0.0728, rel, 'gsl_stats_mean'
+
+    assert_rel rawa.variance_with_fixed_mean(mean), 0.00113837428571429,
+      rel, 'gsl_stats_variance_with_fixed_mean'
+
+    assert_rel rawa.sd_with_fixed_mean(mean), 0.0337398026922845,
+      rel, 'gsl_stats_sd_with_fixed_mean'
+
+    assert_rel rawb.variance,         0.00124956615384615,  rel, 'gsl_stats_variance'
+    assert_rel rawa.sd,               0.0350134479659107,   rel, 'gsl_stats_sd'
+    assert_rel rawa.absdev,           0.0287571428571429,   rel, 'gsl_stats_absdev'
+    assert_rel rawa.skew,             0.0954642051479004,   rel, 'gsl_stats_skew'
+    assert_rel rawa.kurtosis,        -1.38583851548909,     rel, 'gsl_stats_kurtosis'
+    assert_rel rawa.wmean(raww),      0.0678111523670601,   rel, 'gsl_stats_wmean'
+    assert_rel rawa.wvariance(raww),  0.000769562962860317, rel, 'gsl_stats_wvariance'
+    assert_rel rawa.wsd(raww),        0.0277409978706664,   rel, 'gsl_stats_wsd'
+    assert_rel rawa.wabsdev(raww),    0.0193205027504008,   rel, 'gsl_stats_wabsdev'
+    assert_rel rawa.wskew(raww),     -0.373631000307076,    rel, 'gsl_stats_wskew'
+    assert_rel rawa.wkurtosis(raww), -1.48114233353963,     rel, 'gsl_stats_wkurtosis'
+
+    assert_rel GSL::Stats.covariance(rawa, rawb), -0.000139021538461539, rel, 'gsl_stats_covariance'
+
+    if GSL::GSL_VERSION >= '1.9.90'
+      assert_rel GSL::Stats.correlation(rawa, rawb), -0.112322712666074171, rel, 'gsl_stats_correlation'
+      assert_rel GSL::Stats.pvariance(rawa, rawb),    0.00123775384615385,  rel, 'gsl_stats_pvariance'
+      assert_rel GSL::Stats.ttest(rawa, rawb),       -5.67026326985851,     rel, 'gsl_stats_ttest'
+    end
+
+    assert_rel rawa.max, 0.1331, rel, 'gsl_stats_max'
+    assert_rel rawa.min, 0.0242, rel, 'gsl_stats_min'
+
+    min, max = rawa.minmax
+    assert_rel max, 0.1331, rel, 'gsl_stats_minmax: max'
+    assert_rel min, 0.0242, rel, 'gsl_stats_minmax: min'
+
+    assert rawa.max_index == 4, 'gsl_stats_max_index'
+    assert rawa.min_index == 3, 'gsl_stats_min_index'
+
+    min_index, max_index = rawa.minmax_index
+    assert max_index == 4, 'gsl_stats_minmax_index: max'
+    assert min_index == 3, 'gsl_stats_minmax_index: min'
+
+    rawa.sort!
+
+    assert_rel rawa.median_from_sorted_data, 0.07505,
+      rel, 'gsl_stats_median_from_sorted_data'
+
+    assert_rel rawa.subvector(0, rawa.size - 1).median_from_sorted_data, 0.0728,
+      rel, 'gsl_stats_median_from_sorted_data'
+
+    assert_rel rawa.quantile_from_sorted_data(0.0), 0.0242,
+      rel, 'gsl_stats_quantile_from_sorted_data'
+
+    assert_rel rawa.quantile_from_sorted_data(1.0), 0.1331,
+      rel, 'gsl_stats_quantile_from_sorted_data (100)'
+
+    assert_rel rawa.quantile_from_sorted_data(0.5), 0.07505,
+      rel, 'gsl_stats_quantile_from_sorted_data (50even)'
+
+    assert_rel rawa.subvector(0, rawa.size-1).quantile_from_sorted_data(0.5), 0.0728,
+      rel, 'gsl_stats_quantile_from_sorted_data (50odd)'
+  end
+
+  def test_variance_with_fixed_mean
+    v = GSL::Vector[1..8]
+    assert_raises(ArgumentError, 'check for no args') { v.variance_with_fixed_mean }
+  end
+
+end

data/test/gsl/sum_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class SumTest < GSL::TestCase
+
+  N = 50
+
+  def setup
+    @t = GSL::Vector.alloc(N)
+    N.times { |n| @t[n] = 1.0 / (n + 1.0) ** 2 }
+  end
+
+  def _fill_vector(x = 1.0)
+    @t[0] = x
+    1.upto(N - 1) { |n| @t[n] = yield n, @t[n - 1] }
+  end
+
+  def _test_sum(expected, desc)
+    sum_accel, _ = GSL::Sum::Levin_utrunc.alloc(N).accel(@t)
+    assert_rel sum_accel, expected, 1e-8, 'trunc result, %s' % desc
+
+    sum_accel, err_est, = GSL::Sum::Levin_u.alloc(N).accel(@t)
+    assert_rel sum_accel, expected, 1e-8, 'full result, %s' % desc
+
+    sd_est = -Math.log10(err_est / sum_accel.abs)
+    sd_actual = -Math.log10(GSL::DBL_EPSILON + ((sum_accel - expected) / expected).abs)
+
+    refute sd_est > sd_actual + 1.0,
+      'full significant digits, %s (%g vs %g)' % [desc, sd_est, sd_actual]
+  end
+
+  def test_zeta_2
+    _test_sum(GSL::M_PI ** 2 / 6.0, 'zeta(2)')
+  end
+
+  def test_exp_10(x = 10.0)
+    _fill_vector { |n, t| t * (x / n) }
+    _test_sum(Math.exp(x), 'exp(%d)' % x)
+  end
+
+  def test_exp_neg_10
+    test_exp_10(-10.0)
+  end
+
+  def test_log(x = 0.5)
+    _fill_vector(x) { |n, t| t * (x * n) / (n + 1.0) }
+    _test_sum(-Math.log(1 - x), "-log(#{1 - x})")
+  end
+
+  def test_log2
+    test_log(-1.0)
+  end
+
+  def test_asymptotic_series
+    m = GSL::M_PI ** 2
+    _fill_vector(3.0 / m) { |n, t| -t * (4.0 * (n + 1.0) - 1.0) / m }
+    _test_sum(0.192594048773, 'asymptotic series')
+  end
+
+  def test_eulers_constant
+    _fill_vector { |n, _| 1 / (n + 1.0) + Math.log(n / (n + 1.0)) }
+    _test_sum(0.5772156649015328606065120900824, "Euler's constant")
+  end
+
+  def test_eta
+    N.times { |n| @t[n] = (n % 2 == 1 ? -1 : 1) * 1.0 / GSL.sqrt(n + 1.0) }
+    _test_sum(0.6048986434216305, 'eta(1/2)')
+  end
+
+end

data/test/gsl/tensor_test.rb

@@ -0,0 +1,396 @@
+require 'test_helper'
+
+class TensorTest < GSL::TestCase
+
+  RANK = 3
+  DIMENSION = 5
+
+  def test_tensor
+    return unless GSL.const_defined?(:Tensor)
+
+    t = GSL::Tensor.alloc(RANK, DIMENSION)
+
+    assert t.rank == RANK, "#{t.class}.alloc returns valid rank"
+    assert t.dimension == DIMENSION, "#{t.class}_alloc returns valid dimension"
+
+    counter = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          counter += 1
+          t.set(i, j, k, counter)
+    #      t[i, j, k] = counter
+        end
+      end
+    end
+
+    status = 0
+    counter = 0
+    data = t.data    # GSL::Vector::View
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          counter += 1
+          if data[DIMENSION * DIMENSION * i + DIMENSION * j + k] != counter
+            status += 1
+          end
+        end
+      end
+    end
+
+    assert status.zero?, "#{t.class}#set writes into array"
+
+    status = 0
+    counter = 0
+    data = t.data
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          counter += 1
+    #      if t.get(i, j, k) != counter
+          if t[i, j, k] != counter
+            status += 1
+          end
+        end
+      end
+    end
+
+    assert status.zero?, "#{t.class}#get reads from array"
+
+    t = GSL::Tensor.calloc(RANK, DIMENSION)
+
+    counter = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          counter += 1
+          t.set(i, j, k, counter)
+        end
+      end
+    end
+
+    exp_max = t[0, 0, 0]
+    exp_min = t[0, 0, 0]
+    exp_imax = exp_jmax = exp_kmax = 0
+    exp_imin = exp_jmin = exp_kmin = 0
+
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          value = t[i, j, k]
+          if value > exp_max
+            exp_max = value
+            exp_imax = i; exp_jmax = j; exp_kmax = k
+          end
+          if value < exp_min
+            exp_min = t[i, j, k]
+            exp_imin = i; exp_jmin = j; exp_kmin = k
+          end
+        end
+      end
+    end
+
+    max = t.max
+    assert max == exp_max, "#{t.class}#max returns correct maximum value"
+    min = t.min
+    assert min == exp_min, "#{t.class}#min returns correct minimum value"
+
+    min, max = t.minmax
+    assert max == exp_max, "#{t.class}#minmax returns correct maximum value"
+    assert min == exp_min, "#{t.class}#minmax returns correct minimum value"
+
+    imax = t.max_index
+    status = 0
+    if imax[0] != exp_imax; status += 1; end
+    if imax[1] != exp_jmax; status += 1; end
+    if imax[2] != exp_kmax; status += 1; end
+    assert status.zero?, "#{t.class}#max_index returns correct maximum indices"
+
+    imin = t.min_index
+    status = 0
+    if imin[0] != exp_imin; status += 1; end
+    if imin[1] != exp_jmin; status += 1; end
+    if imin[2] != exp_kmin; status += 1; end
+    assert status.zero?, "#{t.class}#min_index returns correct minimum indices"
+
+
+    imin, imax = t.minmax_index
+    status = 0
+    if imin[0] != exp_imin; status += 1; end
+    if imin[1] != exp_jmin; status += 1; end
+    if imin[2] != exp_kmin; status += 1; end
+    if imax[0] != exp_imax; status += 1; end
+    if imax[1] != exp_jmax; status += 1; end
+    if imax[2] != exp_kmax; status += 1; end
+    assert status.zero?, "#{t.class}#minmax_index returns correct indices"
+
+    ##### Operations
+    a = GSL::Tensor.new(RANK, DIMENSION)
+    b = GSL::Tensor.new(RANK, DIMENSION)
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          a[i, j, k] = 3 + i + 5 * j + 2 * k
+          b[i, j, k] = 3 + 2 * i + 4 * j + k
+        end
+      end
+    end
+
+    # Addition
+    c = a + b
+    #c = a.add(b)
+    status = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          r = c[i, j, k]
+          x = a[i, j, k]
+          y = b[i, j, k]
+          z = x + y
+          status += 1 if r != z
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#add tensor addition"
+
+    # Subtraction
+    c = a - b
+    # c = a.sub(b)
+    status = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          r = c[i, j, k]
+          x = a[i, j, k]
+          y = b[i, j, k]
+          z = x - y
+          status += 1 if r != z
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#sub tensor subtraction"
+
+    # Element multiplication
+     c = a.mul_elements(b)
+    status = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          r = c[i, j, k]
+          x = a[i, j, k]
+          y = b[i, j, k]
+          z = x * y
+          status += 1 if r != z
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#mul_elements element multiplication"
+
+    # Element division
+    c = a.div_elements(b)
+    status = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          r = c[i, j, k]
+          x = a[i, j, k]
+          y = b[i, j, k]
+          z = x / y
+          if (r - z).abs > 2 * GSL::FLT_EPSILON * z.abs; status += 1; end
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#div_elements element division"
+
+    ### Tensor product
+    c = a * b
+    status = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          for l in 0...DIMENSION do
+            for m in 0...DIMENSION do
+              for n in 0...DIMENSION do
+                r = c[i, j, k, l, m, n]
+                x = a[i, j, k]
+                y = b[l, m, n]
+                z = x * y
+                if r != z; status += 1; end
+              end
+            end
+          end
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#product tensorial product"
+
+    ### Index contraction
+    tt = a.contract(0, 1)
+    assert tt.rank == RANK - 2, "#{t.class}.contract returns valid rank"
+    assert tt.dimension == DIMENSION, "#{t.class}_contract returns valid dimension"
+
+    ### Swap indices
+    a_102 = a.swap_indices(0, 1)
+    a_210 = a.swap_indices(0, 2)
+    a_021 = a.swap_indices(1, 2)
+    status = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          x = a[i, j, k]
+          x_102 = a_102[j, i, k]
+          x_210 = a_210[k, j, i]
+          x_021 = a_021[i, k, j]
+          if x != x_102 or x != x_210 or x != x_021; status += 1; end
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#swap_indices swap indices"
+
+    ### Test text IO
+    file = 'tensor_test.txt'
+
+    t = GSL::Tensor.alloc(RANK, DIMENSION)
+    counter = 0
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          counter += 1
+          t[i, j, k] = counter
+        end
+      end
+    end
+
+    t.fprintf(file, '%g')
+    tt = GSL::Tensor.alloc(RANK, DIMENSION)
+    status = 0
+    tt.fscanf(file)
+    counter = 0
+    data = tt.data
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          counter += 1
+          if data[DIMENSION * DIMENSION * i + DIMENSION * j + k] != counter
+            status += 1
+          end
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#fprintf and fscanf"
+    File.delete(file)
+
+    ### Test binary IO
+    file = 'tensor_test.dat'
+    t.fwrite(file)
+    tt = GSL::Tensor.alloc(RANK, DIMENSION)
+    status = 0
+    tt.fread(file)
+    counter = 0
+    data = tt.data
+    for i in 0...DIMENSION do
+      for j in 0...DIMENSION do
+        for k in 0...DIMENSION do
+          counter += 1
+          if data[DIMENSION * DIMENSION * i + DIMENSION * j + k] != counter
+            status += 1
+          end
+        end
+      end
+    end
+    assert status.zero?, "#{t.class}#fwrite and fread"
+    File.delete(file)
+
+    ### Trap
+    i = j = k = 0
+    t = GSL::Tensor.calloc(RANK, DIMENSION)
+    assert_nothing_raised("#{t.class}#set traps 1st index above upper bound") {
+      t[DIMENSION + 1, 0, 0] = 1.2
+    }
+
+    assert_nothing_raised("#{t.class}#set traps 2nd index above upper bound") {
+      t[0, DIMENSION + 1, 0] = 1.2
+    }
+
+    assert_nothing_raised("#{t.class}#set traps 3rd index above upper bound") {
+      t[0, 0, DIMENSION + 1] = 1.2
+    }
+
+    assert_nothing_raised("#{t.class}#set traps 2nd index at upper bound") {
+      t[0, DIMENSION, 0] = 1.2
+    }
+
+    assert_nothing_raised("#{t.class}#set traps 2nd index below lower bound") {
+      t[0, i - 1, 0] = 1.2
+    }
+
+    assert_nothing_raised("#{t.class}#get traps 1st index above upper bound") {
+      t[DIMENSION + 1, 0, 0]
+    }
+
+    assert_nothing_raised("#{t.class}#get traps 2nd index above upper bound") {
+      t[0, DIMENSION + 1, 0]
+    }
+
+    assert_nothing_raised("#{t.class}#get traps 3rd index above upper bound") {
+      t[0, 0, DIMENSION + 1]
+    }
+
+    assert_nothing_raised("#{t.class}#get traps 2nd index at upper bound") {
+      t[0, DIMENSION, 0]
+    }
+
+    assert_nothing_raised("#{t.class}#get traps 2nd index below lower bound") {
+      t[0, i - 1, 0]
+    }
+
+    #####
+    # Vector and Tensor, subtensors
+    #v = GSL::Vector.new(0...125)
+    v = GSL::Vector.indgen(125)
+    t = v.to_tensor(3, 5)
+    assert t.rank == RANK, "#{v.class}.to_tensor(#{RANK}, #{DIMENSION}) returns valid rank"
+    assert t.dimension == DIMENSION, "#{v.class}.to_tensor(#{RANK}, #{DIMENSION}) returns valid dimension"
+
+    m0_exp = GSL::Matrix[0...25, 5, 5]
+    m1_exp = GSL::Matrix[25...50, 5, 5]
+    m2_exp = GSL::Matrix[50...75, 5, 5]
+    m3_exp = GSL::Matrix[75...100, 5, 5]
+    m4_exp = GSL::Matrix[100...125, 5, 5]
+
+    # Create tensors of rank 2
+    t0 = t.subtensor(0)
+    t1 = t[1]
+    t2 = t.subtensor(2)
+    t3 = t[3]
+    t4 = t.subtensor(4)
+
+    # 2-tensors can be compared directly with matrices
+    assert t0 == m0_exp, "#{t.class}#subtensor(0) returns valid tensor"
+    assert t1 == m1_exp, "#{t.class}#subtensor(1) returns valid tensor"
+    assert t2 == m2_exp, "#{t.class}#subtensor(2) returns valid tensor"
+    assert t3 == m3_exp, "#{t.class}#subtensor(3) returns valid tensor"
+    assert t4 == m4_exp, "#{t.class}#subtensor(4) returns valid tensor"
+
+    v0_exp = GSL::Vector[100...105]
+    v1_exp = GSL::Vector[105...110]
+    v2_exp = GSL::Vector[110...115]
+    v3_exp = GSL::Vector[115...120]
+    v4_exp = GSL::Vector[120...125]
+
+    # Create tensors of rank1
+    v0 = t[4, 0]
+    v1 = t[4][1]
+    v2 = t.subtensor(4, 2)
+    v3 = t4[3]
+    v4 = t4.subtensor(4)
+
+    # 1-tensors can be compared directly with vectors
+    assert v0 == v0_exp, "#{t.class}#subtensor(4,0) returns valid tensor"
+    assert v1 == v1_exp, "#{t.class}#subtensor(4,1) returns valid tensor"
+    assert v2 == v2_exp, "#{t.class}#subtensor(4,2) returns valid tensor"
+    assert v3 == v3_exp, "#{t.class}#subtensor(4,3) returns valid tensor"
+    assert v4 == v4_exp, "#{t.class}#subtensor(4,4) returns valid tensor"
+  end
+
+end