statsample-ekatena 2.0.2

data/test/helpers_tests.rb

@@ -0,0 +1,83 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib/'))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/'))
+
+require 'minitest'
+require 'minitest/unit'
+require 'mocha/setup'
+require 'tempfile'
+require 'tmpdir'
+require 'shoulda'
+require 'shoulda-context'
+require 'fixtures/correlation_matrix'
+
+require 'statsample'
+
+module Minitest
+  class Test
+    include Shoulda::Context::Assertions
+    include Shoulda::Context::InstanceMethods
+    extend Shoulda::Context::ClassMethods
+
+    def self.should_with_gsl(name, &block)
+      should(name) do
+        if Statsample.has_gsl?
+          instance_eval(&block)
+        else
+          skip('Requires GSL')
+        end
+      end
+    end
+  end
+
+  module Assertions
+    def assert_vectors_from_formula(formula, names)
+      model = Statsample::FitModel.new formula, @df
+  
+      model.df_for_regression.vectors.to_a.sort
+        .must_equal names.sort    
+    end
+
+    def assert_similar_vector(exp, obs, delta = 1e-10, msg = nil)
+      msg ||= "Different vectors #{exp} - #{obs}"
+      assert_equal(exp.size, obs.size)
+      exp.to_a.each_with_index {|v, i|
+        assert_in_delta(v, obs[i], delta)
+      }
+    end
+
+    def assert_equal_vector(exp, obs, delta = 1e-10, msg = nil)
+      assert_equal(exp.size, obs.size, "Different size.#{msg}")
+      exp.size.times {|i|
+        assert_in_delta(exp[i], obs[i], delta, "Different element #{i}. \nExpected:\n#{exp}\nObserved:\n#{obs}.#{msg}")
+      }
+    end
+
+    def assert_equal_matrix(exp, obs, delta = 1e-10, msg = nil)
+      assert_equal(exp.row_size, obs.row_size, "Different row size.#{msg}")
+      assert_equal(exp.column_size, obs.column_size, "Different column size.#{msg}")
+      exp.row_size.times {|i|
+        exp.column_size.times {|j|
+          assert_in_delta(exp[i, j], obs[i, j], delta, "Different element #{i},#{j}\nExpected:\n#{exp}\nObserved:\n#{obs}.#{msg}")
+        }
+      }
+    end
+    alias_method :assert_raise, :assert_raises unless method_defined? :assert_raise
+    alias_method :assert_not_equal, :refute_equal unless method_defined? :assert_not_equal
+    alias_method :assert_not_same, :refute_same unless method_defined? :assert_not_same
+    unless method_defined? :assert_nothing_raised
+      def assert_nothing_raised(msg = nil)
+        msg ||= 'Nothing should be raised, but raised %s'
+        begin
+          yield
+          not_raised = true
+        rescue Exception => e
+          not_raised = false
+          msg = sprintf(msg, e)
+        end
+        assert(not_raised, msg)
+      end
+    end
+  end
+end
+
+MiniTest.autorun

data/test/test_analysis.rb

@@ -0,0 +1,176 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+
+class StatsampleAnalysisTestCase < Minitest::Test
+  context(Statsample::Analysis) do
+    setup do
+      Statsample::Analysis.clear_analysis
+    end
+    should 'store() should create and store Statsample::Analysis::Suite' do
+      Statsample::Analysis.store(:first) do
+        a = 1
+      end
+      assert(Statsample::Analysis.stored_analysis[:first])
+      assert(Statsample::Analysis.stored_analysis[:first].is_a? Statsample::Analysis::Suite)
+    end
+
+    should 'ss_analysis should create an Statsample::Analysis' do
+      ss_analysis(:first) { a = 1 }
+    end
+    should 'store last created analysis' do
+      an = Statsample::Analysis.store(:first) do
+        a = 1
+      end
+      assert_equal(an, Statsample::Analysis.last)
+    end
+
+    should 'add_to_reportbuilder() add sections to reportbuilder object' do
+      rb = mock
+      rb.expects(:add).with { |value| value.is_a? ReportBuilder::Section and value.name == :first }
+      rb.expects(:add).with { |value| value.is_a? ReportBuilder::Section and value.name == :second }
+
+      Statsample::Analysis.store(:first) do
+        echo 'first', 'second'
+      end
+      Statsample::Analysis.store(:second) do
+        echo 'third'
+      end
+      Statsample::Analysis.add_to_reportbuilder(rb, :first, :second)
+    end
+    should 'to_text returns the same as a normal ReportBuilder object' do
+      rb = ReportBuilder.new(name: :test)
+      section = ReportBuilder::Section.new(name: 'first')
+      a = Daru::Vector.new([1, 2, 3])
+      section.add('first')
+      section.add(a)
+      rb.add(section)
+      exp = rb.to_text
+      an = ss_analysis(:first) {
+        echo 'first'
+        summary(a)
+      }
+      obs = Statsample::Analysis.to_text(:first)
+
+      assert_equal(exp.split("\n")[1, exp.size], obs.split("\n")[1, obs.size])
+    end
+
+    should 'run() execute all analysis by default' do
+      m1 = mock
+      m1.expects(:run).once
+      m1.expects(:hide).once
+
+      Statsample::Analysis.store(:first) do
+        m1.run
+      end
+      Statsample::Analysis.store(:second) do
+        m1.hide
+      end
+
+      # Should run all test
+      Statsample::Analysis.run
+    end
+
+    should 'run() execute blocks specificed on parameters' do
+      m1 = mock
+      m1.expects(:run).once
+      m1.expects(:hide).never
+      Statsample::Analysis.store(:first) do
+        m1.run
+      end
+      Statsample::Analysis.store(:second) do
+        m1.hide
+      end
+      # Should run all test
+      Statsample::Analysis.run(:first)
+    end
+
+    context(Statsample::Analysis::Suite) do
+      should 'echo() uses output#puts with same arguments' do
+        an = Statsample::Analysis::Suite.new(:output)
+        obj = mock
+        obj.expects(:puts).with(:first, :second).once
+        an.output = obj
+        an.echo(:first, :second)
+      end
+      should 'summary() should call object.summary' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        obj = stub('summarizable', summary: 'summary')
+        assert_equal(obj.summary, an.summary(obj))
+      end
+      should 'attach() allows to call objects on objects which respond to fields' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds = { :x => stub(mean: 10), :y => stub(mean: 12) }
+        ds.expects(:vectors).returns([:x, :y]).at_least_once
+        an.attach(ds)
+        assert_equal(10, an.x.mean)
+        assert_equal(12, an.y.mean)
+        assert_raise(RuntimeError) {
+          an.z
+        }
+      end
+      should 'attached objects should be called LIFO' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds1 = { :x => stub(mean: 100), :y => stub(mean: 120), :z => stub(mean: 13) }
+        ds1.expects(:vectors).returns([:x, :y, :z]).at_least_once
+        ds2 = { :x => stub(mean: 10), :y => stub(mean: 12) }
+        ds2.expects(:vectors).returns([:x, :y]).at_least_once
+        an.attach(ds1)
+        an.attach(ds2)
+        assert_equal(10, an.x.mean)
+        assert_equal(12, an.y.mean)
+        assert_equal(13, an.z.mean)
+      end
+
+      should 'detach() without arguments drop latest object' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds1 = { :x => stub(mean: 100), :y => stub(mean: 120), :z => stub(mean: 13) }
+        ds1.expects(:vectors).returns([:x, :y, :z]).at_least_once
+        ds2 = { :x => stub(mean: 10), :y => stub(mean: 12) }
+        ds2.expects(:vectors).returns([:x, :y]).at_least_once
+        an.attach(ds1)
+        an.attach(ds2)
+        assert_equal(10, an.x.mean)
+        an.detach
+        assert_equal(100, an.x.mean)
+      end
+      should 'detach() with argument drop select object' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds1 = { :x => 1 }
+        ds1.expects(:vectors).returns([:x]).at_least_once
+        ds2 = { :x => 2, :y => 3 }
+        ds2.expects(:vectors).returns([:x, :y]).at_least_once
+        ds3 = { :y => 4 }
+        ds3.expects(:vectors).returns([:y]).at_least_once
+
+        an.attach(ds3)
+        an.attach(ds2)
+        an.attach(ds1)
+        assert_equal(1, an.x)
+        assert_equal(3, an.y)
+        an.detach(ds2)
+        assert_equal(4, an.y)
+      end
+      should 'perform a simple analysis' do
+        output = mock
+        output.expects(:puts).with(5.5)
+        an = Statsample::Analysis.store(:simple, output: output) do
+          ds = data_frame(x: vector(1..10), y: vector(1..10))
+          attach(ds)
+          echo x.mean
+        end
+        an.run
+      end
+    end
+    context(Statsample::Analysis::SuiteReportBuilder) do
+      should 'echo() use add on rb object' do
+        an = Statsample::Analysis::SuiteReportBuilder.new(:puts_to_add)
+        an.rb.expects(:add).with(:first).twice
+        an.echo(:first, :first)
+      end
+      should 'summary() uses add on rb object' do
+        an = Statsample::Analysis::SuiteReportBuilder.new(:summary_to_add)
+        an.rb.expects(:add).with(:first).once
+        an.summary(:first)
+      end
+    end
+  end
+end

data/test/test_anova_contrast.rb

@@ -0,0 +1,36 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleAnovaContrastTestCase < Minitest::Test
+  context(Statsample::Anova::Contrast) do
+    setup do
+      constant   = Daru::Vector.new([12, 13, 11, 12, 12])
+      frequent   = Daru::Vector.new([9, 10, 9, 13, 14])
+      infrequent = Daru::Vector.new([15, 16, 17, 16, 16])
+      never      = Daru::Vector.new([17, 18, 12, 18, 20])
+      @vectors   = [constant, frequent, infrequent, never]
+      @c         = Statsample::Anova::Contrast.new(vectors: @vectors)
+    end
+    should 'return correct value using c' do
+      @c.c([1, -1.quo(3), -1.quo(3), -1.quo(3)])
+      # @c.c([1,-0.333,-0.333,-0.333])
+      assert_in_delta(-2.6667, @c.psi, 0.0001)
+      assert_in_delta(1.0165, @c.se, 0.0001)
+      assert_in_delta(-2.623, @c.t, 0.001)
+      assert_in_delta(-4.82, @c.confidence_interval[0], 0.01)
+      assert_in_delta(-0.51, @c.confidence_interval[1], 0.01)
+      assert(@c.summary.size > 0)
+    end
+    should 'return correct values using c_by_index' do
+      @c.c_by_index([0], [1, 2, 3])
+      assert_in_delta(-2.6667, @c.psi, 0.0001)
+      assert_in_delta(1.0165, @c.se, 0.0001)
+      assert_in_delta(-2.623, @c.t, 0.001)
+    end
+    should 'return correct values using incomplete c_by_index' do
+      c1 = Statsample::Anova::Contrast.new(vectors: @vectors, c: [0.5, 0.5, -1, 0])
+      c2 = Statsample::Anova::Contrast.new(vectors: @vectors, c1: [0, 1], c2: [2])
+      assert_equal(c1.psi, c2.psi)
+      assert_equal(c1.se, c2.se)
+      assert_equal(c1.t, c2.t)
+    end
+  end
+end

data/test/test_anovaoneway.rb

@@ -0,0 +1,26 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleAnovaOneWayTestCase < Minitest::Test
+  context(Statsample::Anova::OneWay) do
+    setup do
+      @ss_num = 30.08
+      @ss_den = 87.88
+      @df_num = 2
+      @df_den = 21
+      @anova = Statsample::Anova::OneWay.new(ss_num: @ss_num, ss_den: @ss_den, df_num: @df_num, df_den: @df_den)
+    end
+    should 'Statsample::Anova.oneway respond to #oneway' do
+      assert(Statsample::Anova.respond_to? :oneway)
+    end
+    should 'return correct value for ms_num and ms_den' do
+      assert_in_delta(15.04, @anova.ms_num, 0.01)
+      assert_in_delta(4.18, @anova.ms_den, 0.01)
+    end
+    should 'return correct value for f' do
+      assert_in_delta(3.59, @anova.f, 0.01)
+    end
+    should 'respond to summary' do
+      assert(@anova.respond_to? :summary)
+      assert(@anova.summary.size > 0)
+    end
+  end
+end

data/test/test_anovatwoway.rb

@@ -0,0 +1,37 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleAnovaTwoWayTestCase < Minitest::Test
+  context(Statsample::Anova::TwoWay) do
+    setup do
+      @ss_a = 192.2
+      @ss_b = 57.8
+      @ss_axb = 168.2
+      @ss_within = 75.6
+      @df_a = @df_b = 1
+      @df_within = 16
+      @anova = Statsample::Anova::TwoWay.new(ss_a: @ss_a, ss_b: @ss_b, ss_axb: @ss_axb, ss_within: @ss_within, df_a: @df_a, df_b: @df_b, df_within: @df_within)
+    end
+    should 'Statsample::Anova.twoway respond to #twoway' do
+      assert(Statsample::Anova.respond_to? :twoway)
+    end
+    should 'return correct value for ms_a, ms_b and ms_axb' do
+      assert_in_delta(192.2, @anova.ms_a, 0.01)
+      assert_in_delta(57.8, @anova.ms_b, 0.01)
+      assert_in_delta(168.2, @anova.ms_axb, 0.01)
+    end
+    should 'return correct value for f ' do
+      assert_in_delta(40.68, @anova.f_a, 0.01)
+      assert_in_delta(12.23, @anova.f_b, 0.01)
+      assert_in_delta(35.60, @anova.f_axb, 0.01)
+    end
+    should 'return correct value for probability for f ' do
+      assert(@anova.f_a_probability < 0.05)
+      assert(@anova.f_b_probability < 0.05)
+      assert(@anova.f_axb_probability < 0.05)
+    end
+
+    should 'respond to summary' do
+      assert(@anova.respond_to? :summary)
+      assert(@anova.summary.size > 0)
+    end
+  end
+end

data/test/test_anovatwowaywithdataset.rb

@@ -0,0 +1,47 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+# Reference:
+# * http://www.uwsp.edu/psych/Stat/13/anova-2w.htm#III
+class StatsampleAnovaTwoWayWithVectorsTestCase < Minitest::Test
+  context(Statsample::Anova::TwoWayWithVectors) do
+    setup do
+      @pa = Daru::Vector.new [5, 4, 3, 4, 2, 18, 19, 14, 12, 15, 6, 7, 5, 8, 4, 6, 9, 5, 9, 3]
+      @pa.rename 'Passive Avoidance'
+      @a = Daru::Vector.new [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
+      # @a.labels = { 0 => '0%', 1 => '35%' }
+      @a.rename 'Diet'
+      @b = Daru::Vector.new [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+      # @b.labels = { 0 => 'Young', 1 => 'Older' }
+      @b.rename 'Age'
+      @anova = Statsample::Anova::TwoWayWithVectors.new(a: @a, b: @b, dependent: @pa)
+    end
+    should 'Statsample::Anova respond to #twoway_with_vectors' do
+      assert(Statsample::Anova.respond_to? :twoway_with_vectors)
+    end
+    should '#new returns the same as Statsample::Anova.twoway_with_vectors' do
+      @anova2 = Statsample::Anova.twoway_with_vectors(a: @a, b: @b, dependent: @pa)
+      assert_equal(@anova.summary, @anova2.summary)
+    end
+    should 'return correct value for ms_a, ms_b and ms_axb' do
+      assert_in_delta(192.2, @anova.ms_a, 0.01)
+      assert_in_delta(57.8, @anova.ms_b, 0.01)
+      assert_in_delta(168.2, @anova.ms_axb, 0.01)
+    end
+    should 'return correct value for f ' do
+      assert_in_delta(40.68, @anova.f_a, 0.01)
+      assert_in_delta(12.23, @anova.f_b, 0.01)
+      assert_in_delta(35.60, @anova.f_axb, 0.01)
+    end
+    should 'return correct value for probability for f ' do
+      assert(@anova.f_a_probability < 0.05)
+      assert(@anova.f_b_probability < 0.05)
+      assert(@anova.f_axb_probability < 0.05)
+    end
+
+    should 'respond to summary' do
+      @anova.summary_descriptives = true
+      @anova.summary_levene = true
+      assert(@anova.respond_to? :summary)
+      assert(@anova.summary.size > 0)
+    end
+  end
+end

data/test/test_anovawithvectors.rb

@@ -0,0 +1,102 @@
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
+class StatsampleAnovaOneWayWithVectorsTestCase < Minitest::Test
+  context(Statsample::Anova::OneWayWithVectors) do
+    context('when initializing') do
+      setup do
+        @v1 = Daru::Vector.new(10.times.map { rand(100) })
+        @v2 = Daru::Vector.new(10.times.map { rand(100) })
+        @v3 = Daru::Vector.new(10.times.map { rand(100) })
+      end
+      should 'be the same using [] or args*' do
+        a1 = Statsample::Anova::OneWayWithVectors.new(@v1, @v2, @v3)
+        a2 = Statsample::Anova::OneWayWithVectors.new([@v1, @v2, @v3])
+        assert_equal(a1.f, a2.f)
+      end
+      should 'be the same using module method or object instantiation' do
+        a1 = Statsample::Anova::OneWayWithVectors.new(@v1, @v2, @v3)
+        a2 = Statsample::Anova.oneway_with_vectors(@v1, @v2, @v3)
+        assert_equal(a1.f, a2.f)
+      end
+      should 'detect optional hash' do
+        a1 = Statsample::Anova::OneWayWithVectors.new(@v1, @v2, @v3, name: 'aaa')
+        assert_equal('aaa', a1.name)
+      end
+      should 'omit incorrect arguments' do
+        a1 = Statsample::Anova::OneWayWithVectors.new(@v1, @v2, @v3, name: 'aaa')
+        a2 = Statsample::Anova::OneWayWithVectors.new(@v1, nil, nil, @v2, @v3, name: 'aaa')
+        assert_equal(a1.f, a2.f)
+      end
+    end
+    setup do
+      @v1 = Daru::Vector.new([3, 3, 2, 3, 6])
+      @v2 = Daru::Vector.new([7, 6, 5, 6, 7])
+      @v3 = Daru::Vector.new([9, 8, 9, 7, 8])
+      @name = 'Anova testing'
+      @anova = Statsample::Anova::OneWayWithVectors.new(@v1, @v2, @v3, name: @name)
+    end
+    should 'store correctly contrasts' do
+      c1 = Statsample::Anova::Contrast.new(vectors: [@v1, @v2, @v3], c: [1, -0.5, -0.5])
+
+      c2 = @anova.contrast(c: [1, -0.5, -0.5])
+      assert_equal(c1.t, c2.t)
+    end
+    should 'respond to #summary' do
+      assert(@anova.respond_to? :summary)
+    end
+    should 'have correct name of analysis on #summary' do
+      assert_match(/#{@name}/, @anova.summary)
+    end
+    should 'returns same levene values as direct Levene creation' do
+      assert_equal(@anova.levene.f, Statsample::Test.levene([@v1, @v2, @v3]).f)
+    end
+    should 'have correct value for levene' do
+      assert_in_delta(0.604, @anova.levene.f, 0.001)
+      assert_in_delta(0.562, @anova.levene.probability, 0.001)
+    end
+    should 'have correct value for sst' do
+      assert_in_delta(72.933, @anova.sst, 0.001)
+    end
+    should 'have correct value for sswg' do
+      assert_in_delta(14.8, @anova.sswg, 0.001)
+    end
+    should 'have correct value for ssb' do
+      assert_in_delta(58.133, @anova.ssbg, 0.001)
+    end
+    should 'sst=sswg+ssbg' do
+      assert_in_delta(@anova.sst, @anova.sswg + @anova.ssbg, 0.00001)
+    end
+    should 'df total equal to number of n-1' do
+      assert_equal(@v1.size + @v2.size + @v3.size - 1, @anova.df_total)
+    end
+    should 'df wg equal to number of n-k' do
+      assert_equal(@v1.size + @v2.size + @v3.size - 3, @anova.df_wg)
+    end
+    should 'df bg equal to number of k-1' do
+      assert_equal(2, @anova.df_bg)
+    end
+    should 'f=(ssbg/df_bg)/(sswt/df_wt)' do
+      assert_in_delta((@anova.ssbg.quo(@anova.df_bg)).quo(@anova.sswg.quo(@anova.df_wg)), @anova.f, 0.001)
+    end
+    should 'p be correct' do
+      assert(@anova.probability < 0.01)
+    end
+    should 'be correct using different test values' do
+      anova2 = Statsample::Anova::OneWayWithVectors.new([@v1, @v1, @v1, @v1, @v2])
+      assert_in_delta(3.960, anova2.f, 0.001)
+      assert_in_delta(0.016, anova2.probability, 0.001)
+    end
+    context 'with extra information on summary' do
+      setup do
+        @anova.summary_descriptives = true
+        @anova.summary_levene = true
+        @summary = @anova.summary
+      end
+      should 'have section with levene statistics' do
+        assert_match(/Levene/, @summary)
+      end
+      should 'have section with descriptives' do
+        assert_match(/Min/, @summary)
+      end
+    end
+  end
+end