statsample 0.10.0 → 0.11.0

data/lib/statsample/anova/twoway.rb

@@ -0,0 +1,211 @@
+module Statsample
+  module Anova
+    # = Generic Anova two-way.
+    # You could enter the sum of squares or the mean squares for a, b, axb and within. 
+    # You should enter the degrees of freedom for a,b and within, because df_axb=df_a*df_b
+    # == Usage
+    #  anova=Statsample::Anova::TwoWay(:ss_a=>10,:ss_b=>20,:ss_axb=>10, :ss_within=>20, :df_a=>2, :df_b=>3,df_within=100 @name=>"ANOVA for....")
+    class TwoWay
+      include Summarizable
+      attr_reader :df_a, :df_b, :df_axb, :df_within, :df_total
+      attr_reader :ss_a, :ss_b, :ss_axb, :ss_within, :ss_total
+      attr_reader :ms_a, :ms_b, :ms_axb, :ms_within, :ms_total
+      # Name of ANOVA Analisys
+      attr_accessor :name
+      # Name of a factor
+      attr_accessor :name_a
+      # Name of b factor
+      attr_accessor :name_b
+      # Name of within factor
+      attr_accessor :name_within
+      
+      attr_reader :f_a_object, :f_b_object, :f_axb_object
+      def initialize(opts=Hash.new)
+        # First see if sum of squares or mean squares are entered
+        raise ArgumentError, "You should set all d.f." unless [:df_a, :df_b, :df_within].all? {|v| opts.has_key? v}
+        
+        @df_a=opts.delete :df_a
+        @df_b=opts.delete :df_b
+        @df_axb=@df_a*@df_b
+        @df_within=opts.delete :df_within
+        @df_total=@df_a+@df_b+@df_axb+@df_within
+        
+        if [:ss_a, :ss_b, :ss_axb, :ss_within].all? {|v| opts.has_key? v}
+          @ss_a = opts.delete :ss_a
+          @ss_b = opts.delete :ss_b
+          @ss_axb = opts.delete :ss_axb
+          @ss_within = opts.delete :ss_within
+          
+          @ms_a =@ss_a.quo(@df_a)
+          @ms_b =@ss_b.quo(@df_b) 
+          @ms_axb =@ss_axb.quo(@df_axb)
+          @ms_within =@ss_within.quo(@df_within) 
+
+        elsif [:ms_a, :ms_b, :ms_axb, :ms_within].all? {|v| opts.has_key? v}
+          @ms_a = opts.delete :ms_a
+          @ms_b = opts.delete :ms_b
+          @ms_axb = opts.delete :ms_axb
+          @ms_within = opts.delete :ms_within
+          
+          @ss_a =@ms_a*@df_a
+          @ss_b =@ms_b*@df_b 
+          @ss_axb =@ms_axb*@df_axb
+          @ss_within =@ms_within*@df_within
+        else
+          raise "You should set all ss or ss"
+        end
+        @ss_total=@ss_a+@ss_b+@ss_axb+@ss_within
+        @ms_total=@ms_a+@ms_b+@ms_axb+@ms_within
+        opts_default={:name=>_("ANOVA Two-Way"),
+                      :name_a=>_("A"),
+                      :name_b=>_("B"),
+                      :name_within=>_("Within")                      
+        }
+        @opts=opts_default.merge(opts)
+        opts_default.keys.each {|k|
+          send("#{k}=", @opts[k])
+        }
+        @f_a_object=Statsample::Test::F.new(@ms_a,@ms_within,@df_a,@df_within)
+        @f_b_object=Statsample::Test::F.new(@ms_b,@ms_within,@df_b,@df_within)
+        @f_axb_object=Statsample::Test::F.new(@ms_axb,@ms_within,@df_axb,@df_within)
+      end
+      def f_a
+        @f_a_object.f
+      end
+      def f_b
+        @f_b_object.f
+      end
+      def f_axb
+        @f_axb_object.f
+      end
+      def f_a_probability
+        @f_a_object.probability
+      end
+      def f_b_probability
+        @f_b_object.probability
+      end
+      def f_axb_probability
+        @f_axb_object.probability
+      end
+            
+
+      def report_building(builder) #:nodoc:
+        builder.section(:name=>@name) do |b|
+          report_building_table(b)
+        end
+      end
+      def report_building_table(builder) #:nodoc:
+        builder.table(:name=>_("%s Table") % @name, :header=>%w{source ss df ms f p}.map {|v| _(v)}) do |t|
+          t.row([@name_a, "%0.3f" % @ss_a,   @df_a, "%0.3f" % @ms_a , "%0.3f" % f_a, "%0.4f" % f_a_probability] )
+          t.row([@name_b, "%0.3f" % @ss_b,   @df_b, "%0.3f" % @ms_b , "%0.3f" % f_b, "%0.4f" % f_b_probability] )
+          t.row(["%s X %s" % [@name_a, @name_b], "%0.3f" % @ss_axb,   @df_axb, "%0.3f" % @ms_axb , "%0.3f" % f_axb, "%0.4f" % f_axb_probability] )          
+          t.row([@name_within, "%0.3f" % @ss_within,   @df_within, nil,nil,nil] )
+          t.row([_("Total"), "%0.3f" % @ss_total,   @df_total, nil,nil,nil] )          
+        end
+      end
+    end
+    
+    # Two Way Anova with vectors
+    # Example:
+    #   v1=[2,3,4,5,6].to_scale
+    #   v2=[3,3,4,5,6].to_scale
+    #   v3=[5,3,1,5,6].to_scale
+    #   anova=Statsample::Anova::OneWayWithVectors.new([v1,v2,v3])
+    #   anova.f
+    #   => 0.0243902439024391
+    #   anova.probability
+    #   => 0.975953044203438
+    #   anova.sst 
+    #   => 32.9333333333333
+    #
+    class TwoWayWithVectors < TwoWay
+       # Show summary Levene test
+      attr_accessor :summary_levene
+      # Show summary descriptives for variables (means)
+      attr_accessor :summary_descriptives
+      attr_reader :a_var, :b_var, :dep_var
+      # For now, only equal sample cells allowed
+      def initialize(opts=Hash.new)
+        raise "You should insert at least :a, :b and :dependent" unless  [:a, :b, :dependent].all? {|v| opts.has_key? v}
+        @a_var='a'
+        @b_var='b'
+        @dep_var='dependent'
+        @a_vector, @b_vector, @dep_vector=Statsample.only_valid_clone opts[:a], opts[:b], opts[:dependent]
+        
+        ds={@a_var=>@a_vector, @b_var=>@b_vector, @dep_var=>@dep_vector}.to_dataset
+        @ds=ds.clone_only_valid
+        _p=@a_vector.factors.size
+        _q=@b_vector.factors.size
+        @x_general=@dep_vector.mean
+        @axb_means={}
+        @axb_sd={}
+        @vectors=[]
+        n=nil
+        @ds.to_multiset_by_split(a_var,b_var).each_vector(dep_var) {|k,v|
+          @axb_means[k]=v.mean
+          @axb_sd[k]=v.sd
+          @vectors << v
+          n||=v.size
+          raise "All cell sizes should be equal" if n!=v.size
+        }
+
+        @a_means={}
+        @ds.to_multiset_by_split(a_var).each_vector(dep_var) {|k,v|
+          @a_means[k]=v.mean
+        }
+        @b_means={}
+        @ds.to_multiset_by_split(b_var).each_vector(dep_var) {|k,v|
+          @b_means[k]=v.mean
+        }
+        ss_a=n*_q*@ds[a_var].factors.inject(0) {|ac,v|
+          ac+(@a_means[v]-@x_general)**2
+        }
+        ss_b=n*_p*@ds[b_var].factors.inject(0) {|ac,v|
+          ac+(@b_means[v]-@x_general)**2
+        }
+        ss_within=@ds.collect {|row|
+          (row[dep_var]-@axb_means[[row[a_var],row[b_var]]])**2
+        }.sum
+        ss_axb=n*@axb_means.inject(0) {|ac,v|
+          j,k=v[0]
+          xjk=v[1]
+          ac+(xjk-@a_means[j]-@b_means[k]+@x_general)**2
+        }
+        df_a=_p-1
+        df_b=_q-1
+        df_within=(_p*_q)*(n-1)
+        
+        opts_default={:name=>_("Anova Two-Way on #{@ds[dep_var].name}"), 
+          :name_a=>@ds[a_var].name,
+            :name_b=>@ds[b_var].name,
+            :summary_descriptives=>true,
+            :summary_levene=>false}
+            
+        @opts=opts_default.merge(opts).merge({: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})
+        
+        
+        super(@opts)
+      end
+      def levene
+        Statsample::Test.levene(@vectors, :name=>_("Test of Homogeneity of variances (Levene)"))
+      end      
+      def report_building(builder) #:nodoc:#
+        builder.section(:name=>@name) do |s|
+          if summary_descriptives
+            s.table(:header =>['']+@ds[a_var].factors.map {|a| @ds[a_var].labeling(a)}+[_("%s Mean") % @name_b]) do |t|
+              @ds[b_var].factors.each do |b|
+                t.row([@ds[b_var].labeling(b)]+@ds[a_var].factors.map {|a| "%0.3f" % @axb_means[[a,b]] } + ["%0.3f" % @b_means[b]])
+              end
+              t.row([_("%s Mean") % @name_a]+@ds[a_var].factors.map {|a| "%0.3f" % @a_means[a]}+ ["%0.3f" % @x_general])
+            end
+          end
+          if summary_levene
+            s.parse_element(levene)
+          end
+          report_building_table(s)
+
+        end
+      end
+    end
+  end
+end

data/lib/statsample/bivariate.rb

@@ -57,6 +57,7 @@ module Statsample
         t.quo(v2s.size-1)
 =end
       end
+      alias :correlation :pearson
       # Retrieves the value for t test for a pearson correlation
       # between two vectors to test the null hipothesis of r=0
       def t_pearson(v1,v2)

data/lib/statsample/dataset.rb

@@ -186,6 +186,17 @@ module Statsample
       }
       Dataset.new(vectors,fields)
     end
+    def clone_only_valid(*fields_to_include)
+      if fields_to_include.size==1 and fields_to_include[0].is_a? Array
+        fields_to_include=fields_to_include[0]
+      end
+      fields_to_include=@fields.dup if fields_to_include.size==0
+      if fields_to_include.any? {|v| @vectors[v].has_missing_data?}
+        dup_only_valid(fields_to_include)
+      else
+        clone(fields_to_include)
+      end
+    end
     # Returns a shallow copy of Dataset.
     # Object id will be distinct, but @vectors will be the same.
     def clone(*fields_to_include)
@@ -199,6 +210,7 @@ module Statsample
         ds[f]=@vectors[f]
       }
       ds.fields=fields_to_include
+      ds.update_valid_data
       ds
     end
     # Creates a copy of the given dataset, without data on vectors
@@ -643,8 +655,10 @@ module Statsample
         end
       end
       ms=Multiset.new_empty_vectors(@fields,factors_total)
+
       p1=eval "Proc.new {|c| ms[["+fields.collect{|f| "c['#{f}']"}.join(",")+"]].add_case(c,false) }"
       each{|c| p1.call(c)}
+      
       ms.datasets.each do |k,ds|
         ds.update_valid_data
         ds.vectors.each{|k1,v1| v1.type=@vectors[k1].type }
@@ -792,8 +806,8 @@ module Statsample
 		def report_building(b)
       b.section(:name=>@name) do |g|
         g.text _"Cases: %d"  % cases
-        
         @fields.each do |f|
+          g.text "Element:[#{f}]"
           g.parse_element(@vectors[f])
         end
       end

data/lib/statsample/dominanceanalysis.rb

@@ -57,8 +57,7 @@ module Statsample
   # * Azen, R. & Budescu, D.V. (2006). Comparing predictors in Multivariate Regression Models: An extension of Dominance Analysis. <em>Journal of Educational and Behavioral Statistics, 31</em>(2), 157-180.
   #
   class DominanceAnalysis
-    include GetText
-    bindtextdomain("statsample")
+	include Summarizable
     # Class to generate the regressions. Default to Statsample::Regression::Multiple::MatrixEngine
     attr_accessor :regression_class
     # Name of analysis
@@ -312,14 +311,12 @@ module Statsample
 
     def report_building(g)
       compute if @models.nil?
-      
       g.section(:name=>@name) do |generator|
         header=["","r2",_("sign")]+@predictors.collect {|c| DominanceAnalysis.predictor_name(c) }
         
         generator.table(:name=>_("Dominance Analysis result"), :header=>header) do |t|
-          
           row=[_("Model 0"),"",""]+@predictors.collect{|f|
-            sprintf("%0.3f", md([f]).r2)
+            sprintf("%0.3f",md([f]).r2)
           }
           
           t.row(row)
@@ -349,15 +346,15 @@ module Statsample
                     sprintf("%0.3f",g[f])
           }
           t.row(row)
-        end        
+        end
         
         td=total_dominance
         cd=conditional_dominance
         gd=general_dominance
         generator.table(:name=>_("Pairwise dominance"), :header=>[_("Pairs"),_("Total"),_("Conditional"),_("General")]) do |t|
-          pairs.each{|p|
-            name=p.join(" - ")
-            row=[name, sprintf("%0.1f",td[p]), sprintf("%0.1f",cd[p]), sprintf("%0.1f",gd[p])]
+          pairs.each{|pair|
+            name=pair.map{|v| v.is_a?(Array) ? "("+v.join("-")+")" : v}.join(" - ")
+            row=[name, sprintf("%0.1f",td[pair]), sprintf("%0.1f",cd[pair]), sprintf("%0.1f",gd[pair])]
             t.row(row)
           }
         end
@@ -394,10 +391,10 @@ module Statsample
         }.join("*")
       end
       def add_table_row
-        begin
-          sign=sprintf("%0.3f", @lr.significance)
-        rescue RuntimeError
-          sign="???"
+        if @cases
+          sign=sprintf("%0.3f", @lr.probability)
+		else
+		sign="???"
         end
       
         [name, sprintf("%0.3f",r2), sign] + @predictors.collect{|k|

data/lib/statsample/factor/parallelanalysis.rb

@@ -100,10 +100,12 @@ class ParallelAnalysis
       if bootstrap_method==:parameter
         rng = GSL::Rng.alloc()
       end
-      
       @fields.each do |f|
+
         if bootstrap_method==:parameter
-          ds_bootstrap[f]=@n_cases.times.map {|c| rng.gaussian( @ds[f].sd)+@ds[f].mean}.to_scale
+          sd=@ds[f].sd
+          mean=@ds[f].mean
+          ds_bootstrap[f]=@n_cases.times.map {|c| rng.gaussian(sd)+mean}.to_scale
         elsif bootstrap_method==:raw_data
           ds_bootstrap[f]=ds[f].sample_with_replacement(@n_cases).to_scale
         end

data/lib/statsample/multiset.rb

@@ -43,6 +43,12 @@ module Statsample
         yield k, v[field]
       }
     end
+    
+    def each_vector(field)
+      @datasets.each {|k,v|
+        yield k, v[field]
+      }
+    end
     def[](i)
       @datasets[i]
     end

data/lib/statsample/regression/multiple/baseengine.rb

@@ -185,7 +185,7 @@ module Statsample
             sc=standarized_coeffs
             cse=coeffs_se
             g.table(:name=>_("Beta coefficients"), :header=>%w{coeff b beta se t}.collect{|field| _(field)} ) do |t|
-              t.row([_("Constant"), sprintf("%0.3f", constant), "-", sprintf("%0.3f", constant_se), sprintf("%0.3f", constant_t)])
+				t.row([_("Constant"), sprintf("%0.3f", constant), "-", constant_se.nil? ? "": sprintf("%0.3f", constant_se), constant_t.nil? ? "" : sprintf("%0.3f", constant_t)])
               @fields.each do |f|
                 t.row([f, sprintf("%0.3f", c[f]), sprintf("%0.3f", sc[f]), sprintf("%0.3f", cse[f]), sprintf("%0.3f", c[f].quo(cse[f]))])
               end  

data/lib/statsample/reliability.rb

@@ -6,10 +6,10 @@ module Statsample
       def cronbach_alpha(ods)
         ds=ods.dup_only_valid
         n_items=ds.fields.size
-        sum_var_items=ds.vectors.inject(0) {|ac,v|
+        s2_items=ds.vectors.inject(0) {|ac,v|
         ac+v[1].variance }
         total=ds.vector_sum
-        (n_items.quo(n_items-1)) * (1-(sum_var_items.quo(total.variance)))
+        (n_items.quo(n_items-1)) * (1-(s2_items.quo(total.variance)))
       end
       # Calculate Chonbach's alpha for a given dataset
       # using standarized values for every vector.
@@ -21,6 +21,24 @@ module Statsample
         }.to_dataset
         cronbach_alpha(ds)
       end
+      # First derivative for alfa
+      # Parameters
+      # <tt>n</tt>: Number of items
+      # <tt>sx</tt>: mean of variances 
+      # <tt>sxy</tt>: mean of covariances
+      
+      def alfa_first_derivative(n,sx,sxy)
+        (sxy*(sx-sxy)).quo(((sxy*(n-1))+sx)**2)
+      end
+      # Second derivative for alfa
+      # Parameters
+      # <tt>n</tt>: Number of items
+      # <tt>sx</tt>: mean of variances 
+      # <tt>sxy</tt>: mean of covariances
+      
+      def alfa_second_derivative(n,sx,sxy)
+        (2*(sxy**2)*(sxy-sx)).quo(((sxy*(n-1))+sx)**3)
+      end
     end
     class ItemCharacteristicCurve
       attr_reader :totals, :counts, :vector_total
@@ -60,10 +78,11 @@ module Statsample
       end
     end
     class ItemAnalysis
-      attr_reader :mean, :sd,:valid_n, :alpha , :alpha_standarized
+      attr_reader :mean, :sd,:valid_n, :alpha , :alpha_standarized, :variances_mean, :covariances_mean
       attr_accessor :name
       def initialize(ds,opts=Hash.new)
         @ds=ds.dup_only_valid
+        @k=@ds.fields.size
         @total=@ds.vector_sum
         @item_mean=@ds.vector_mean.mean
         @mean=@total.mean
@@ -71,11 +90,15 @@ module Statsample
         @skew=@total.skew
         @kurtosis=@total.kurtosis
         @sd = @total.sd
+        @variance=@total.variance
         @valid_n = @total.size
         opts_default={:name=>"Reliability Analisis"}
         @opts=opts_default.merge(opts)
         @name=@opts[:name]
-        
+        # Mean for covariances and variances
+        @variances=@ds.fields.map {|f| @ds[f].variance}.to_scale
+        @variances_mean=@variances.mean
+        @covariances_mean=(@variance-@variances.sum).quo(@k**2-@k)
         begin
           @alpha = Statsample::Reliability.cronbach_alpha(ds)
           @alpha_standarized = Statsample::Reliability.cronbach_alpha_standarized(ds)
@@ -215,15 +238,19 @@ module Statsample
           s.table(:name=>"Summary") do |t|
             t.row ["Items", @ds.fields.size]
             t.row ["Total Mean", @mean]
+            t.row ["Total S.D.", @sd]
+            t.row ["Total Variance", @variance]
             t.row ["Item Mean", @item_mean]
-            t.row ["S.D.", @sd]
             t.row ["Median", @median]
             t.row ["Skewness", "%0.4f" % @skew]
             t.row ["Kurtosis", "%0.4f" % @kurtosis]
             t.row ["Valid n", @valid_n]
             t.row ["Cronbach's alpha", "%0.4f" % @alpha]
             t.row ["Standarized Cronbach's alpha", "%0.4f" % @alpha_standarized]
+            t.row ["Variances mean",  "%g" % @variances_mean]
+            t.row ["Covariances mean" , "%g" % @covariances_mean]
           end
+          
           itc=item_total_correlation
           sid=stats_if_deleted
           is=item_statistics