statsample-ekatena 2.0.2

data/lib/statsample-ekatena/srs.rb

@@ -0,0 +1,169 @@
+module Statsample
+	# Several methods to estimate parameters for simple random sampling
+  # == Reference: 
+  # * Cochran, W.(1972). Sampling Techniques [spanish edition].
+  # * http://stattrek.com/Lesson6/SRS.aspx
+  
+	module SRS
+
+		class << self
+      ########################
+      #
+      # :SECTION: Proportion estimation
+      #
+      # Function for estimation of proportions
+      ########################
+      
+      #
+      # Finite population correction (over variance)
+      # Source: Cochran(1972)
+      def fpc_var(sam,pop)
+          (pop - sam).quo(pop - 1)
+      end
+      # Finite population correction (over standard deviation)
+      def fpc(sam,pop)
+          Math::sqrt((pop-sam).quo(pop-1))
+      end
+      
+      # Non sample fraction.
+      #
+      # 1 - sample fraction
+      def qf(sam , pop)
+          1-(sam.quo(pop))
+      end
+      # Sample size estimation for proportions, infinite poblation
+      def estimation_n0(d,prop,margin=0.95)
+          t=Distribution::Normal.p_value(1-(1-margin).quo(2))
+          var=prop*(1-prop)
+          t**2*var.quo(d**2)
+      end
+      # Sample size estimation for proportions, finite poblation.
+      def estimation_n(d,prop,n_pobl,margin=0.95)
+          n0=estimation_n0(d,prop,margin)
+          n0.quo( 1 + ((n0 - 1).quo(n_pobl)))
+      end
+      
+      
+      # Proportion confidence interval with t values
+      # Uses estimated proportion, sample without replacement.
+      
+      def proportion_confidence_interval_t(prop, n_sample, n_population, margin=0.95)
+          t = Distribution::T.p_value(1-((1-margin).quo(2)) , n_sample-1)
+          proportion_confidence_interval(prop,n_sample,n_population, t)
+      end
+      
+      # Proportion confidence interval with z values
+      # Uses estimated proportion, sample without replacement.
+      def proportion_confidence_interval_z(p, n_sample, n_population, margin=0.95)
+          z=Distribution::Normal.p_value(1-((1-margin).quo(2)))
+          proportion_confidence_interval(p,n_sample,n_population, z)
+      end
+      # Proportion confidence interval with x value
+      # Uses estimated proportion, sample without replacement
+      
+      def proportion_confidence_interval(p, sam,pop , x)
+          #f=sam.quo(pop)
+          one_range=x * Math::sqrt((qf(sam, pop) * p * (1-p)).quo(sam-1)) + (1.quo(sam * 2.0))
+          [p-one_range, p+one_range]
+      end
+      # Standard deviation for sample distribution of a proportion
+      # Know proportion, sample with replacement.
+      # Based on http://stattrek.com/Lesson6/SRS.aspx
+      def proportion_sd_kp_wr(p, n_sample)
+          Math::sqrt(p*(1-p).quo(n_sample))
+      end
+      # Standard deviation for sample distribution of a proportion
+      # Know proportion, sample without replacement.
+      #
+      # Sources: 
+      # * Cochran(1972)
+      def proportion_sd_kp_wor(p, sam, pop)
+          fpc(sam,pop)*Math::sqrt(p*(1-p).quo(sam))
+      end
+      # Standard deviation for sample distribution of a proportion
+      # Estimated proportion, sample with replacement
+      # Based on http://stattrek.com/Lesson6/SRS.aspx.
+      def proportion_sd_ep_wr(p, n_sample)
+          Math::sqrt(p*(1-p).quo(n_sample-1))
+      end                                       
+      # Standard deviation for sample distribution of a proportion.
+      # Estimated proportion, sample without replacement.
+      # Reference: 
+      # * Cochran, 1972, Técnicas de muestreo
+      def proportion_sd_ep_wor(p, sam,pop)
+          fsc=(pop-sam).quo((sam-1)*pop)
+          Math::sqrt(fsc*p*(1-p))
+      end
+      
+      # Total estimation sd based on sample. 
+      # Known proportion, sample without replacement
+      # Reference: 
+      # * Cochran(1972)
+      def proportion_total_sd_kp_wor(prop, sam, pop)
+          pob * proportion_sd_kp_wor(p, sam, pop)
+      end
+      # Total estimation sd based on sample. 
+      # Estimated proportion, sample without replacement
+      # Source: Cochran(1972)
+      def proportion_total_sd_ep_wor(prop, sam, pop)
+          fsc=((pop - sam).to_f / ( sam - 1))
+          Math::sqrt(fsc*pop*prop*(1-prop))
+      end 
+      
+      ########################
+      #
+      # :SECTION:  Mean stimation
+      #
+      ########################
+
+      
+      # Standard error. Known variance, sample with replacement.
+      def standard_error_ksd_wr(s, sam, pop)
+          s.quo(Math::sqrt(sam)) * Math::sqrt((pop-1).quo(pop))
+      end
+      
+      # Standard error of the mean. Known variance, sample w/o replacement
+      def standard_error_ksd_wor(s,sam,pop)
+          s.quo(Math::sqrt(sam)) * Math::sqrt(qf(sam,pop)) 
+      end
+      
+      alias_method :standard_error_esd_wr, :standard_error_ksd_wr
+      
+      # Standard error of the mean. 
+      # Estimated variance, without replacement
+      # Cochran (1972) p.47
+      def standard_error_esd_wor(s,sam,pop)
+          s.quo(Math::sqrt(sam)) * Math::sqrt(qf(sam,pop))
+      end
+      
+      alias_method :standard_error, :standard_error_esd_wor
+      alias_method :se, :standard_error_esd_wor
+
+      # Standard error of total estimation
+      
+      def standard_error_total(s,sam,pop)
+          pop*se(s,sam,pop)
+      end
+
+      # Confidence Interval using T-Student
+      # Use with n < 60
+      def mean_confidence_interval_t(mean,s,n_sample,n_population,margin=0.95)
+          t=Distribution::T.p_value(1-((1-margin) / 2),n_sample-1)
+          mean_confidence_interval(mean,s,n_sample,n_population,t)
+      end
+      # Confidente Interval using Z
+      # Use with n > 60
+      def mean_confidence_interval_z(mean,s,n_sample,n_population,margin=0.95)
+          z=Distribution::Normal.p_value(1-((1-margin) / 2))
+          mean_confidence_interval(mean,s,n_sample,n_population, z)
+      end
+      # Confidente interval using X.
+      #
+      # Better use mean_confidence_interval_z or mean_confidence_interval_t
+      def mean_confidence_interval(mean,s,n_sample,n_population,x)
+          range=x*se(s,n_sample,n_population)
+          [mean-range,mean+range]
+      end
+		end
+	end
+end

data/lib/statsample-ekatena/test.rb

@@ -0,0 +1,82 @@
+module Statsample
+  # Module for several statistical tests
+  
+  module Test
+    autoload(:UMannWhitney, 'statsample/test/umannwhitney')
+    autoload(:Levene, 'statsample/test/levene')
+    autoload(:T, 'statsample/test/t')
+    autoload(:F, 'statsample/test/f')
+    autoload(:ChiSquare, 'statsample/test/chisquare')
+    autoload(:BartlettSphericity, 'statsample/test/bartlettsphericity')
+    autoload(:KolmogorovSmirnov, 'statsample/test/kolmogorovsmirnov')
+    autoload(:WilcoxonSignedRank, 'statsample/test/wilcoxonsignedrank')
+    
+    
+    # Returns probability of getting a value lower or higher
+    # than sample, using cdf and number of tails.
+    # 
+    # * <tt>:left</tt> : For one tail left, return the cdf
+    # * <tt>:right</tt> : For one tail right, return 1-cdf
+    # * <tt>:both</tt> : For both tails, returns 2*right_tail(cdf.abs)
+    def p_using_cdf(cdf, tails=:both)
+      tails=:both if tails==2 or tails==:two
+      tails=:right if tails==1 or tails==:positive
+      tails=:left if tails==:negative
+      case tails
+        when :left then cdf
+        when :right then 1-cdf
+        when :both 
+          if cdf>=0.5
+            cdf=1-cdf
+          end
+          2*cdf
+      end
+    end
+    # Get critical t to create confidence interval 
+    def t_critical(confidence_level, df)
+      -Distribution::T.p_value((1-confidence_level) / 2.0, df)
+    end
+    # Get critical z to create confidence interval 
+    def z_critical(confidence_level)
+      -Distribution::Z.p_value((1-confidence_level) / 2.0)
+    end
+    
+    extend self
+    # Calculate chi square for two Matrix
+    class << self
+      def chi_square(observed, expected=nil)
+        case observed
+          when Vector
+            ChiSquare::WithVector.new(observed,expected)
+          when Matrix
+            ChiSquare::WithMatrix.new(observed,expected)
+          else
+            raise "Not implemented for #{observed.class}"
+        end
+      end
+      # Shorthand for Statsample::Test::UMannWhitney.new
+      # 
+      # * <tt>v1</tt> and <tt>v2</tt> should be Statsample::Vector.
+      def u_mannwhitney(v1, v2)
+        Statsample::Test::UMannWhitney.new(v1,v2)
+      end
+      # Shorthand for Statsample::Test::T::OneSample.new
+      def t_one_sample(vector, opts=Hash.new)
+        Statsample::Test::T::OneSample.new(vector,opts)
+      end
+      # Shorthand for Statsample::Test::T::TwoSamplesIndependent.new
+      def t_two_samples_independent(v1,v2, opts=Hash.new)
+        Statsample::Test::T::TwoSamplesIndependent.new(v1,v2,opts)
+      end
+      # Shorthand for Statsample::Test::WilcoxonSignedRank.new
+	  def wilcoxon_signed_rank(v1,v2,opts=Hash.new)
+		Statsample::Test::WilcoxonSignedRank.new(v1,v2,opts)
+	  end
+      # Shorthand for Statsample::Test::Levene.new
+      def levene(input, opts=Hash.new)
+        Statsample::Test::Levene.new(input,opts)
+      end
+      
+    end
+  end
+end

data/lib/statsample-ekatena/test/bartlettsphericity.rb

@@ -0,0 +1,45 @@
+module Statsample
+  module Test
+    # == Bartlett's test of Sphericity.
+    # Test the hyphotesis that the sample correlation matrix
+    # comes from a multivariate normal population where variables
+    # are independent. In other words, the population correlation
+    # matrix is the identity matrix.
+    # == Reference
+    # * Dziuban, C., & Shirkey E. (1974). When is a correlation matrix appropriate for factor analysis? Some decision rules. Psychological Bulletin, 81(6), 358-361.
+    class BartlettSphericity
+      include Statsample::Test
+      include Summarizable
+      attr_accessor :name
+      attr_reader :ncases
+      attr_reader :nvars
+      attr_reader :value
+      attr_reader :df
+      # Args
+      # * _matrix_: correlation matrix
+      # * _ncases_: number of cases
+      def initialize(matrix,ncases)
+        @matrix=matrix
+        @ncases=ncases
+        @nvars=@matrix.row_size
+        @name=_("Bartlett's test of sphericity")
+        compute
+      end
+      # Uses SPSS formula.
+      # On Dziuban & Shirkey, the minus between the first and second
+      # statement is a *!!!
+      # 
+      def compute
+        @value=-((@ncases-1)-(2*@nvars+5).quo(6))*Math::log(@matrix.determinant)
+        @df=(@nvars*(@nvars-1)) / 2
+      end
+      def probability
+        1-Distribution::ChiSquare.cdf(@value,@df)
+      end
+      def report_building(builder) # :nodoc:
+        builder.text "%s : X(%d) = %0.4f , p = %0.4f" % [@name, @df, @value, probability]
+      end
+      
+    end
+  end
+end

data/lib/statsample-ekatena/test/chisquare.rb

@@ -0,0 +1,73 @@
+module Statsample
+  module Test
+    module ChiSquare
+      module Shared
+        attr_reader :df
+        attr_reader :value
+
+        def to_f
+          @value
+        end
+
+        def chi_square
+          @value
+        end
+
+        def probability
+          1-Distribution::ChiSquare.cdf(@value.to_f,@df)
+        end
+      end
+
+      class WithMatrix
+        include Statsample::Test::ChiSquare::Shared
+
+        def initialize(observed, expected=nil)
+          @observed=observed
+          @expected=expected or calculate_expected
+          raise "Observed size!=expected size" if @observed.row_size!=@expected.row_size or @observed.column_size!=@expected.column_size
+          @df=(@observed.row_size-1)*(@observed.column_size-1)
+          @value=compute_chi
+        end
+
+        def calculate_expected
+          sum=@observed.total_sum
+          @expected=Matrix.rows( @observed.row_size.times.map {|i|
+            @observed.column_size.times.map {|j|
+              (@observed.row_sum[i].quo(sum) * @observed.column_sum[j].quo(sum))*sum
+            }
+          })
+        end
+
+        def compute_chi
+          sum=0
+          (0...@observed.row_size).each {|i|
+            (0...@observed.column_size).each {|j|
+              sum+=((@observed[i, j] - @expected[i,j])**2).quo(@expected[i,j])
+            }
+          }
+          sum
+        end
+      end
+
+      class WithVector
+        include Statsample::Test::ChiSquare::Shared
+
+        def initialize(observed, expected)
+          @observed = observed
+          @expected = expected
+          raise "Observed size!=expected size" if @observed.size!=@expected.size
+          @df = @observed.size - 1
+          @value = compute_chi
+        end
+
+        def compute_chi
+          sum=0
+          (0...@observed.size).each {|i|
+            sum+=((@observed[i] - @expected[i])**2).quo(@expected[i])
+          }
+          sum
+        end
+      end
+    end
+  end
+end

data/lib/statsample-ekatena/test/f.rb

@@ -0,0 +1,52 @@
+module Statsample
+  module Test
+    # From Wikipedia:
+    # An F-test is any statistical test in which the test statistic has an F-distribution under the null hypothesis. It is most often used when comparing statistical models that have been fit to a data set, in order to identify the model that best fits the population from which the data were sampled.
+    class F
+      include Statsample::Test
+      include Summarizable
+      attr_reader :var_num, :var_den, :df_num, :df_den, :var_total, :df_total
+      # Tails for probability (:both, :left or :right)
+      attr_accessor :tails
+      # Name of F analysis
+      attr_accessor :name
+
+      # Parameters:
+      # * var_num: variance numerator
+      # * var_den: variance denominator
+      # * df_num: degrees of freedom numerator
+      # * df_den: degrees of freedom denominator
+      def initialize(var_num, var_den, df_num, df_den, opts=Hash.new)
+        @var_num=var_num
+        @var_den=var_den
+        @df_num=df_num
+        @df_den=df_den
+        @var_total=var_num+var_den
+        @df_total=df_num+df_den
+        opts_default={:tails=>:right, :name=>_("F Test")}
+        @opts=opts_default.merge(opts)
+        raise "Tails should be right or left, not both" if @opts[:tails]==:both
+        opts_default.keys.each {|k|
+          send("#{k}=", @opts[k])
+        }
+      end
+      def f
+        @var_num.quo(@var_den)
+      end
+      def to_f
+        f
+      end
+      # probability
+      def probability
+        p_using_cdf(Distribution::F.cdf(f, @df_num, @df_den), tails)
+      end
+      def report_building(builder) #:nodoc:
+        if @df_num.is_a? Integer and @df_den.is_a? Integer
+          builder.text "%s : F(%d, %d) = %0.4f , p = %0.4f" % [@name, @df_num, @df_den, f, probability]
+        else
+          builder.text "%s : F(%0.2f, %0.2f) = %0.4f , p = %0.4f" % [@name, @df_num, @df_den, f, probability]
+        end
+      end
+    end
+  end
+end

data/lib/statsample-ekatena/test/kolmogorovsmirnov.rb

@@ -0,0 +1,63 @@
+module Statsample
+  module Test
+    # == Kolmogorov-Smirnov's test of equality of distributions.
+    class KolmogorovSmirnov
+      
+      attr_reader :d
+      include Statsample::Test
+      include Summarizable
+      # Creates a new Kolmogorov-Smirnov test
+      # d1 should have each method
+      # d2 could be a Distribution class, with a cdf method,
+      # a vector or a lambda
+      def initialize(d1,d2)
+        raise "First argument should have each method" unless d1.respond_to? :each
+        @d1=make_cdf(d1)
+        if d2.respond_to? :cdf or d2.is_a? Proc
+          @d2=d2
+        elsif d2.respond_to? :each
+          @d2=make_cdf(d2)
+        else
+           raise "Second argument should respond to cdf or each"    
+         end
+         calculate
+      end
+      
+      def calculate
+         d=0
+        @d1.each {|x|
+        v1=@d1.cdf(x);
+        v2=@d2.is_a?(Proc) ? @d2.call(x) : @d2.cdf(x)
+        d=(v1-v2).to_f.abs if (v1-v2).abs>d
+        }
+        @d=d
+      end
+
+      # Make a wrapper EmpiricDistribution to any method which implements
+      # each on Statsample::Vector, only uses non-missing data.
+      def make_cdf(v)
+        v.is_a?(Daru::Vector) ? EmpiricDistribution.new(v.only_valid.to_a) : EmpiricDistribution.new(v)
+      end
+
+      class EmpiricDistribution
+        def initialize(data)
+          @min=data.min
+          @max=data.max
+          @data=data.sort
+          @n=data.size
+        end
+        def each
+          @data.each {|x|
+            yield x
+          }
+        end
+        def cdf(x)
+          return 0 if x<@min
+          return 1 if x>=@max
+          v=@data.index{|v1| v1>=x}
+          v.nil? ? 0 : (v+(x==@data[v]? 1 : 0)).quo(@n)
+        end
+      end # End EmpiricDistribution
+    end
+  end
+end