rb-gsl 1.16.0.5 → 1.16.0.6

data/test/gsl/stats_test.rb

@@ -1,122 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,396 +0,0 @@
-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