statsample-ekatena 2.0.2

data/test/test_regression.rb

@@ -0,0 +1,231 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+
+class StatsampleRegressionTestCase < Minitest::Test
+  context 'Example with missing data' do
+    setup do
+      @x = Daru::Vector.new([0.285714285714286, 0.114285714285714, 0.314285714285714, 0.2, 0.2, 0.228571428571429, 0.2, 0.4, 0.714285714285714, 0.285714285714286, 0.285714285714286, 0.228571428571429, 0.485714285714286, 0.457142857142857, 0.257142857142857, 0.228571428571429, 0.285714285714286, 0.285714285714286, 0.285714285714286, 0.142857142857143, 0.285714285714286, 0.514285714285714, 0.485714285714286, 0.228571428571429, 0.285714285714286, 0.342857142857143, 0.285714285714286, 0.0857142857142857])
+
+      @y = Daru::Vector.new([nil, 0.233333333333333, nil, 0.266666666666667, 0.366666666666667, nil, 0.333333333333333, 0.3, 0.666666666666667, 0.0333333333333333, 0.333333333333333, nil, nil, 0.533333333333333, 0.433333333333333, 0.4, 0.4, 0.5, 0.4, 0.266666666666667, 0.166666666666667, 0.666666666666667, 0.433333333333333, 0.166666666666667, nil, 0.4, 0.366666666666667, nil])
+      @ds = Daru::DataFrame.new({ :x => @x, :y => @y })
+      @lr = Statsample::Regression::Multiple::RubyEngine.new(@ds, :y)
+    end
+    should 'have correct values' do
+      assert_in_delta(0.455, @lr.r2, 0.001)
+      assert_in_delta(0.427, @lr.r2_adjusted, 0.001)
+      assert_in_delta(0.1165, @lr.se_estimate, 0.001)
+      assert_in_delta(15.925, @lr.f, 0.0001)
+      assert_in_delta(0.675, @lr.standarized_coeffs[:x], 0.001)
+      assert_in_delta(0.778, @lr.coeffs[:x], 0.001, 'coeff x')
+      assert_in_delta(0.132, @lr.constant, 0.001, 'constant')
+      assert_in_delta(0.195, @lr.coeffs_se[:x], 0.001, 'coeff x se')
+      assert_in_delta(0.064, @lr.constant_se, 0.001, 'constant se')
+    end
+  end
+  should 'return an error if data is linearly dependent' do
+    samples = 100
+
+    a, b = rand, rand
+
+    x1 = Daru::Vector.new(samples.times.map { rand })
+    x2 = Daru::Vector.new(samples.times.map { rand })
+    x3 = Daru::Vector.new(samples.times.map { |i| x1[i] * (1 + a) + x2[i] * (1 + b) })
+    y  = Daru::Vector.new(samples.times.map { |i| x1[i] + x2[i] + x3[i] + rand })
+
+    ds = Daru::DataFrame.new({ :x1 => x1, :x2 => x2, :x3 => x3, :y => y })
+
+    assert_raise(Statsample::Regression::LinearDependency) {
+      Statsample::Regression::Multiple::RubyEngine.new(ds, :y)
+    }
+  end
+  def test_parameters
+    @x =Daru::Vector.new([13, 20, 10, 33, 15])
+    @y =Daru::Vector.new([23, 18, 35, 10, 27])
+    reg = Statsample::Regression::Simple.new_from_vectors(@x, @y)
+    _test_simple_regression(reg)
+    ds = Daru::DataFrame.new({ :x => @x, :y => @y })
+    reg = Statsample::Regression::Simple.new_from_dataset(ds, :x, :y)
+    _test_simple_regression(reg)
+    reg = Statsample::Regression.simple(@x, @y)
+    _test_simple_regression(reg)
+  end
+
+  def _test_simple_regression(reg)
+    assert_in_delta(40.009, reg.a, 0.001)
+    assert_in_delta(-0.957, reg.b, 0.001)
+    assert_in_delta(4.248, reg.standard_error, 0.002)
+    assert(reg.summary)
+  end
+
+  def test_summaries
+    a = Daru::Vector.new(10.times.map { rand(100) })
+    b = Daru::Vector.new(10.times.map { rand(100) })
+    y = Daru::Vector.new(10.times.map { rand(100) })
+    ds = Daru::DataFrame.new({ :a => a, :b => b, :y => y })
+    lr = Statsample::Regression::Multiple::RubyEngine.new(ds, :y)
+    assert(lr.summary.size > 0)
+  end
+
+  def test_multiple_dependent
+    complete = Matrix[
+      [1, 0.53, 0.62, 0.19, -0.09, 0.08, 0.02, -0.12, 0.08],
+      [0.53, 1, 0.61, 0.23, 0.1, 0.18, 0.02, -0.1, 0.15],
+      [0.62, 0.61, 1, 0.03, 0.1, 0.12, 0.03, -0.06, 0.12],
+      [0.19, 0.23, 0.03, 1, -0.02, 0.02, 0, -0.02, -0.02],
+      [-0.09, 0.1, 0.1, -0.02, 1, 0.05, 0.06, 0.18, 0.02],
+      [0.08, 0.18, 0.12, 0.02, 0.05, 1, 0.22, -0.07, 0.36],
+      [0.02, 0.02, 0.03, 0, 0.06, 0.22, 1, -0.01, -0.05],
+      [-0.12, -0.1, -0.06, -0.02, 0.18, -0.07, -0.01, 1, -0.03],
+      [0.08, 0.15, 0.12, -0.02, 0.02, 0.36, -0.05, -0.03, 1]]
+    complete.extend Statsample::CovariateMatrix
+    complete.fields = %w(adhd cd odd sex age monly mwork mage poverty)
+
+    lr = Statsample::Regression::Multiple::MultipleDependent.new(complete, %w(adhd cd odd))
+
+    assert_in_delta(0.197, lr.r2yx, 0.001)
+    assert_in_delta(0.197, lr.r2yx_covariance, 0.001)
+    assert_in_delta(0.07, lr.p2yx, 0.001)
+  end
+
+  def test_multiple_regression_pairwise_2
+    @a =Daru::Vector.new( [1, 3, 2, 4, 3, 5, 4, 6, 5, 7, 3, nil, 3, nil, 3])
+    @b =Daru::Vector.new( [3, 3, 4, 4, 5, 5, 6, 6, 4, 4, 2, 2, nil, 6, 2])
+    @c =Daru::Vector.new( [11, 22, 30, 40, 50, 65, 78, 79, 99, 100, nil, 3, 7, nil, 7])
+    @y =Daru::Vector.new( [3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 30, 40, nil, 50, nil])
+    ds = Daru::DataFrame.new({ :a => @a, :b => @b, :c => @c, :y => @y })
+    lr = Statsample::Regression::Multiple::RubyEngine.new(ds, :y)
+    assert_in_delta(2407.436, lr.sst, 0.001)
+    assert_in_delta(0.752, lr.r, 0.001, 'pairwise r')
+    assert_in_delta(0.565, lr.r2, 0.001)
+    assert_in_delta(1361.130, lr.ssr, 0.001)
+    assert_in_delta(1046.306, lr.sse, 0.001)
+    assert_in_delta(3.035, lr.f, 0.001)
+  end
+
+  def test_multiple_regression_gsl
+    if Statsample.has_gsl?
+      @a =Daru::Vector.new( [1, 3, 2, 4, 3, 5, 4, 6, 5, 7])
+      @b =Daru::Vector.new( [3, 3, 4, 4, 5, 5, 6, 6, 4, 4])
+      @c =Daru::Vector.new( [11, 22, 30, 40, 50, 65, 78, 79, 99, 100])
+      @y =Daru::Vector.new( [3, 4, 5, 6, 7, 8, 9, 10, 20, 30])
+      ds = Daru::DataFrame.new({ :a => @a, :b => @b, :c => @c, :y => @y })
+      lr = Statsample::Regression::Multiple::GslEngine.new(ds, :y)
+      assert(lr.summary.size > 0)
+      model_test(lr, 'gsl')
+      predicted = [1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
+      c_predicted = lr.predicted
+      predicted.each_index{|i|
+        assert_in_delta(predicted[i], c_predicted[i], 0.001)
+      }
+      residuals = [1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
+      c_residuals = lr.residuals
+      residuals.each_index{|i|
+        assert_in_delta(residuals[i], c_residuals[i], 0.001)
+      }
+    else
+      skip 'Regression::Multiple::GslEngine not tested (no Gsl)'
+    end
+  end
+
+  def model_test_matrix(lr, name = 'undefined')
+    stan_coeffs = { :a => 0.151, :b => -0.547, :c => 0.997 }
+    unstan_coeffs = { :a => 0.695, :b => -4.286, :c => 0.266 }
+
+    unstan_coeffs.each_key{|k|
+      assert_in_delta(unstan_coeffs[k], lr.coeffs[k], 0.001, "b coeffs - #{name}")
+    }
+
+    stan_coeffs.each_key{|k|
+      assert_in_delta(stan_coeffs[k], lr.standarized_coeffs[k], 0.001, "beta coeffs - #{name}")
+    }
+
+    assert_in_delta(11.027, lr.constant, 0.001)
+
+    assert_in_delta(0.955, lr.r, 0.001)
+    assert_in_delta(0.913, lr.r2, 0.001)
+
+    assert_in_delta(20.908, lr.f, 0.001)
+    assert_in_delta(0.001, lr.probability, 0.001)
+    assert_in_delta(0.226, lr.tolerance(:a), 0.001)
+
+    coeffs_se = { :a => 1.171, :b => 1.129, :c => 0.072 }
+
+    ccoeffs_se = lr.coeffs_se
+    coeffs_se.each_key{|k|
+      assert_in_delta(coeffs_se[k], ccoeffs_se[k], 0.001)
+    }
+    coeffs_t = { :a => 0.594, :b => -3.796, :c => 3.703 }
+    ccoeffs_t = lr.coeffs_t
+    coeffs_t.each_key{|k|
+      assert_in_delta(coeffs_t[k], ccoeffs_t[k], 0.001)
+    }
+
+    assert_in_delta(639.6, lr.sst, 0.001)
+    assert_in_delta(583.76, lr.ssr, 0.001)
+    assert_in_delta(55.840, lr.sse, 0.001)
+    assert(lr.summary.size > 0, "#{name} without summary")
+  end
+
+  def model_test(lr, name = 'undefined')
+    model_test_matrix(lr, name)
+    assert_in_delta(4.559, lr.constant_se, 0.001)
+    assert_in_delta(2.419, lr.constant_t, 0.001)
+
+    assert_in_delta(1.785, lr.process([1, 3, 11]), 0.001)
+  end
+
+  def test_regression_matrix
+    @a = Daru::Vector.new([1, 3, 2, 4, 3, 5, 4, 6, 5, 7])
+    @b = Daru::Vector.new([3, 3, 4, 4, 5, 5, 6, 6, 4, 4])
+    @c = Daru::Vector.new([11, 22, 30, 40, 50, 65, 78, 79, 99, 100])
+    @y = Daru::Vector.new([3, 4, 5, 6, 7, 8, 9, 10, 20, 30])
+    ds = Daru::DataFrame.new({ :a => @a, :b => @b, :c => @c, :y => @y })
+    cor = Statsample::Bivariate.correlation_matrix(ds)
+
+    lr = Statsample::Regression::Multiple::MatrixEngine.new(
+      cor, :y, y_mean: @y.mean, 
+      x_mean: { :a => ds[:a].mean, :b => ds[:b].mean, :c => ds[:c].mean }, 
+      cases: @a.size, y_sd: @y.sd, x_sd: { :a => @a.sd, :b => @b.sd, :c => @c.sd })
+    assert_nil(lr.constant_se)
+    assert_nil(lr.constant_t)
+    model_test_matrix(lr, 'correlation matrix')
+
+    covariance = Statsample::Bivariate.covariance_matrix(ds)
+    lr = Statsample::Regression::Multiple::MatrixEngine.new(
+      covariance, :y, y_mean: @y.mean, 
+      x_mean: { :a => ds[:a].mean, :b => ds[:b].mean, :c => ds[:c].mean }, cases: @a.size)
+    assert(lr.summary.size > 0)
+
+    model_test(lr, 'covariance matrix')
+  end
+
+  def test_regression_rubyengine
+    @a = Daru::Vector.new([nil, 1, 3, 2, 4, 3, 5, 4, 6, 5, 7])
+    @b = Daru::Vector.new([nil, 3, 3, 4, 4, 5, 5, 6, 6, 4, 4])
+    @c = Daru::Vector.new([nil, 11, 22, 30, 40, 50, 65, 78, 79, 99, 100])
+    @y = Daru::Vector.new([nil, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30])
+    ds = Daru::DataFrame.new({ :a => @a, :b => @b, :c => @c, :y => @y })
+    lr = Statsample::Regression::Multiple::RubyEngine.new(ds, :y)
+    assert_equal(11, lr.total_cases)
+    assert_equal(10, lr.valid_cases)
+    model_test(lr, 'rubyengine with missing data')
+
+    predicted = [nil, 1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
+    c_predicted = lr.predicted
+    predicted.each_index do |i|
+      if c_predicted[i].nil?
+        assert(predicted[i].nil?, "Actual #{i} is nil, but expected #{predicted[i]}")
+      else
+        assert_in_delta(predicted[i], c_predicted[i], 0.001)
+      end
+    end
+    residuals = [nil, 1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
+    c_residuals = lr.residuals
+    residuals.each_index do |i|
+      if c_residuals[i].nil?
+        assert(residuals[i].nil?)
+      else
+        assert_in_delta(residuals[i], c_residuals[i], 0.001)
+      end
+    end
+  end
+end

data/test/test_reliability.rb

@@ -0,0 +1,223 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleReliabilityTestCase < Minitest::Test
+  context Statsample::Reliability do
+    should 'return correct r according to Spearman-Brown prophecy' do
+      r = 0.6849
+      n = 62.quo(15)
+      assert_in_delta(0.9, Statsample::Reliability.sbp(r, n), 0.001)
+    end
+    should 'return correct n for desired realiability' do
+      r = 0.6849
+      r_d = 0.9
+      assert_in_delta(62, Statsample::Reliability.n_for_desired_reliability(r, r_d, 15), 0.5)
+    end
+    context "Cronbach's alpha" do
+      setup do
+        @samples = 40
+        @n_variables = rand(10) + 2
+        @ds = Daru::DataFrame.new({}, index: @samples)
+        base = Daru::Vector.new(@samples.times.collect { |_a| rand })
+        @n_variables.times do |i|
+          @ds[i] = Daru::Vector.new(base.collect { |v| v + rand })
+        end
+
+        @k = @ds.ncols
+        @cm = Statsample::Bivariate.covariance_matrix(@ds)
+        @dse = @ds.dup
+        @dse.vectors.each do |f|
+          @dse[f] = @dse[f].standardize
+        end
+        @cme = Statsample::Bivariate.covariance_matrix(@dse)
+        @a = Statsample::Reliability.cronbach_alpha(@ds)
+        @as = Statsample::Reliability.cronbach_alpha_standarized(@ds)
+      end
+      should 'alpha will be equal to sum of matrix covariance less the individual variances' do
+        total_sum = @cm.total_sum
+        ind_var = @ds.vectors.to_a.inject(0) { |ac, v| ac + @ds[v].variance }
+        expected = @k.quo(@k - 1) * (1 - (ind_var.quo(total_sum)))
+        assert_in_delta(expected, @a, 1e-10)
+      end
+      should 'method cronbach_alpha_from_n_s2_cov return correct values' do
+        sa = Statsample::Reliability::ScaleAnalysis.new(@ds)
+        vm, cm = sa.variances_mean, sa.covariances_mean
+        assert_in_delta(sa.alpha, Statsample::Reliability.cronbach_alpha_from_n_s2_cov(@n_variables, vm, cm), 1e-10)
+      end
+      should 'method cronbach_alpha_from_covariance_matrix returns correct value' do
+        cov = Statsample::Bivariate.covariance_matrix(@ds)
+        assert_in_delta(@a, Statsample::Reliability.cronbach_alpha_from_covariance_matrix(cov), 0.0000001)
+      end
+      should 'return correct n for desired alpha, covariance and variance' do
+        sa = Statsample::Reliability::ScaleAnalysis.new(@ds)
+        vm, cm = sa.variances_mean, sa.covariances_mean
+        n_obtained = Statsample::Reliability.n_for_desired_alpha(@a, vm, cm)
+        # p n_obtained
+        assert_in_delta(Statsample::Reliability.cronbach_alpha_from_n_s2_cov(n_obtained, vm, cm), @a, 0.001)
+      end
+
+      should 'standarized alpha will be equal to sum of matrix covariance less the individual variances on standarized values' do
+        total_sum = @cme.total_sum
+        ind_var = @dse.vectors.to_a.inject(0) { |ac, v| ac + @dse[v].variance }
+        expected = @k.quo(@k - 1) * (1 - (ind_var.quo(total_sum)))
+        assert_in_delta(expected, @as, 1e-10)
+      end
+    end
+    context Statsample::Reliability::ItemCharacteristicCurve do
+      setup do
+        @samples = 100
+        @points = rand(10) + 3
+        @max_point = (@points - 1) * 3
+        @x1 = Daru::Vector.new(@samples.times.map { rand(@points) })
+        @x2 = Daru::Vector.new(@samples.times.map { rand(@points) })
+        @x3 = Daru::Vector.new(@samples.times.map { rand(@points) })
+        @ds = Daru::DataFrame.new({ :a => @x1, :b => @x2, :c => @x3 })
+        @icc = Statsample::Reliability::ItemCharacteristicCurve.new(@ds)
+      end
+      should 'have a correct automatic vector_total' do
+        assert_equal(@ds.vector_sum, @icc.vector_total)
+      end
+      should 'have a correct different vector_total' do
+        x2 = Daru::Vector.new(@samples.times.map { rand(10) })
+        @icc = Statsample::Reliability::ItemCharacteristicCurve.new(@ds, x2)
+        assert_equal(x2, @icc.vector_total)
+        assert_raises(ArgumentError) do
+          inc = Daru::Vector.new((@samples + 10).times.map { rand(10) })
+          @icc = Statsample::Reliability::ItemCharacteristicCurve.new(@ds, inc)
+        end
+      end
+      should 'have 0% for 0 points on maximum value values' do
+        max = @icc.curve_field(:a, 0)[@max_point.to_f]
+        max ||= 0
+        assert_in_delta(0, max)
+      end
+      should 'have 0 for max value on minimum value' do
+        max = @icc.curve_field(:a, @max_point)[0.0]
+        max ||= 0
+        assert_in_delta(0, max)
+      end
+      should 'have correct values of % for any value' do
+        sum = @icc.vector_total
+        total = {}
+        total_g = sum.frequencies
+        index = rand(@points)
+        @x1.each_with_index do |v, i|
+          total[sum[i]] ||= 0
+          total[sum[i]] += 1 if v == index
+        end
+        expected = total.each {|k, v|
+          total[k] = v.quo(total_g[k])
+        }
+        assert_equal(expected, @icc.curve_field(:a, index))
+      end
+    end
+
+    context Statsample::Reliability::MultiScaleAnalysis do
+      setup do
+        size = 100
+        @scales = 3
+        @items_per_scale = 10
+        h = {}
+        @scales.times {|s|
+          @items_per_scale.times {|i|
+            h["#{s}_#{i}".to_sym] = Daru::Vector.new((size.times.map { (s * 2) + rand }))
+          }
+        }
+        @ds = Daru::DataFrame.new(h)
+        @msa = Statsample::Reliability::MultiScaleAnalysis.new(name: 'Multiple Analysis') do |m|
+          m.scale 'complete', @ds
+          @scales.times {|s|
+            m.scale "scale_#{s}", @ds.clone(*@items_per_scale.times.map { |i| "#{s}_#{i}".to_sym }), name: "Scale #{s}"
+          }
+        end
+      end
+
+      should 'Retrieve correct ScaleAnalysis for whole scale' do
+        sa = Statsample::Reliability::ScaleAnalysis.new(@ds, name: 'Scale complete')
+        assert_equal(sa.variances_mean, @msa.scale('complete').variances_mean)
+      end
+      should 'Retrieve correct ScaleAnalysis for each scale' do
+        @scales.times {|s|
+          sa = Statsample::Reliability::ScaleAnalysis.new(@ds.dup(@items_per_scale.times.map { |i| "#{s}_#{i}".to_sym }), name: "Scale #{s}")
+          assert_equal(sa.variances_mean, @msa.scale("scale_#{s}").variances_mean)
+        }
+      end
+      should 'retrieve correct correlation matrix for each scale' do
+        vectors = { :complete => @ds.vector_sum }
+        @scales.times {|s|
+          vectors["scale_#{s}".to_sym] = @ds.dup(@items_per_scale.times.map { |i| "#{s}_#{i}".to_sym }).vector_sum
+        }
+        ds2 = Daru::DataFrame.new(vectors)
+        assert_equal(Statsample::Bivariate.correlation_matrix(ds2), @msa.correlation_matrix)
+      end
+      should 'delete scale using delete_scale' do
+        @msa.delete_scale('complete')
+        assert_equal(@msa.scales.keys.sort, @scales.times.map { |s| "scale_#{s}" })
+      end
+      should 'retrieve pca for scales' do
+        @msa.delete_scale('complete')
+        vectors = {}
+        @scales.times {|s|
+          vectors["scale_#{s}".to_sym] = @ds.dup(@items_per_scale.times.map { |i| "#{s}_#{i}".to_sym }).vector_sum
+        }
+        ds2 = Daru::DataFrame.new(vectors)
+        cor_matrix = Statsample::Bivariate.correlation_matrix(ds2)
+        m = 3
+        pca = Statsample::Factor::PCA.new(cor_matrix, m: m)
+        assert_equal(pca.component_matrix, @msa.pca(m: m).component_matrix)
+      end
+      should 'retrieve acceptable summary' do
+        @msa.delete_scale('scale_0')
+        @msa.delete_scale('scale_1')
+        @msa.delete_scale('scale_2')
+
+        # @msa.summary_correlation_matrix=true
+        # @msa.summary_pca=true
+
+        assert(@msa.summary.size > 0)
+      end
+    end
+    context Statsample::Reliability::ScaleAnalysis do
+      setup do
+        @x1 = Daru::Vector.new([1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 30])
+        @x2 = Daru::Vector.new([1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 50])
+        @x3 = Daru::Vector.new([2, 2, 1, 1, 1, 2, 2, 2, 3, 4, 5, 40])
+        @x4 = Daru::Vector.new([1, 2, 3, 4, 4, 4, 4, 3, 4, 4, 5, 30])
+        @ds = Daru::DataFrame.new({ :x1 => @x1, :x2 => @x2, :x3 => @x3, :x4 => @x4 })
+        @ia = Statsample::Reliability::ScaleAnalysis.new(@ds)
+        @cov_matrix = @ia.cov_m
+      end
+      should 'return correct values for item analysis' do
+        assert_in_delta(0.980, @ia.alpha, 0.001)
+        assert_in_delta(0.999, @ia.alpha_standarized, 0.001)
+        var_mean = Daru::Vector.new(4.times.map { |m| @cov_matrix[m, m] }).mean
+        assert_in_delta(var_mean, @ia.variances_mean)
+        assert_equal(@x1.mean, @ia.item_statistics[:x1][:mean])
+        assert_equal(@x4.mean, @ia.item_statistics[:x4][:mean])
+        assert_in_delta(@x1.sds, @ia.item_statistics[:x1][:sds], 1e-14)
+        assert_in_delta(@x4.sds, @ia.item_statistics[:x4][:sds], 1e-14)
+        ds2 = @ds.clone
+        ds2.delete_vector(:x1)
+        vector_sum = ds2.vector_sum
+        assert_equal(vector_sum.mean, @ia.stats_if_deleted[:x1][:mean])
+        assert_equal(vector_sum.sds, @ia.stats_if_deleted[:x1][:sds])
+        assert_in_delta(vector_sum.variance, @ia.stats_if_deleted[:x1][:variance_sample], 1e-10)
+
+        assert_equal(Statsample::Reliability.cronbach_alpha(ds2), @ia.stats_if_deleted[:x1][:alpha])
+
+        covariances = []
+        4.times.each {|i|
+          4.times.each {|j|
+            if i != j
+              covariances.push(@cov_matrix[i, j])
+            end
+          }
+        }
+        assert_in_delta(Daru::Vector.new(covariances).mean, @ia.covariances_mean)
+        assert_in_delta(0.999, @ia.item_total_correlation[:x1], 0.001)
+        assert_in_delta(1050.455, @ia.stats_if_deleted[:x1][:variance_sample], 0.001)
+      end
+      should 'return a summary' do
+        assert(@ia.summary.size > 0)
+      end
+    end
+  end
+end