statsample 0.6.3 → 0.6.4

data/lib/statsample/dominanceanalysis/bootstrap.rb

@@ -37,12 +37,20 @@ module Statsample
         @ds=ds
         @y_var=y_var
         @n=ds.cases
-        @fields=ds.fields-[y_var]
-        @samples_ga=@fields.inject({}){|a,v| a[v]=[];a}
+        
         @n_samples=0
         @alpha=ALPHA
         @debug=false
-        @regression_class=Regression::Multiple::RubyEngine
+        if y_var.is_a? Array
+          @fields=ds.fields-y_var
+          @regression_class=Regression::Multiple::MultipleDependent
+          
+        else
+          @fields=ds.fields-[y_var]
+          @regression_class=Regression::Multiple::MatrixEngine
+        end
+        @samples_ga=@fields.inject({}){|a,v| a[v]=[];a}
+
         @name=_("Bootstrap dominance Analysis:  %s over %s") % [ ds.fields.join(",") , @y_var]
         opts.each{|k,v|
           self.send("#{k}=",v) if self.respond_to? k
@@ -52,10 +60,10 @@ module Statsample
       # lr_class deprecated
       alias_method :lr_class, :regression_class
       def da
-          if @da.nil?
-            @da=DominanceAnalysis.new(@ds,@y_var, :regression_class => @regression_class)
-          end
-          @da
+        if @da.nil?
+          @da=DominanceAnalysis.new(@ds,@y_var, :regression_class => @regression_class)
+        end
+        @da
       end
       # Creates n re-samples from original dataset and store result of
       # each sample on @samples_td, @samples_cd, @samples_gd, @samples_ga
@@ -69,6 +77,7 @@ module Statsample
           puts _("Bootstrap %d of %d") % [t+1, number_samples] if @debug
           ds_boot=@ds.bootstrap(n)
           da_1=DominanceAnalysis.new(ds_boot, @y_var, :regression_class => @regression_class)
+          
           da_1.total_dominance.each{|k,v|
             @samples_td[k].push(v)
           }

data/lib/statsample/matrix.rb

@@ -21,22 +21,62 @@ class ::Matrix
     }
     GSL::Matrix[*out]
   end
-
+  
   # Calculate marginal of rows
-  def rows_sum
+  def row_sum
   (0...row_size).collect {|i|
     row(i).to_a.inject(0) {|a,v| a+v}
   }
   end
   # Calculate marginal of columns
-  def cols_sum
+  def column_sum
   (0...column_size).collect {|i|
     column(i).to_a.inject(0) {|a,v| a+v}
   }
   end
+
+  
+  alias :old_par :[]
+  
+  # Select elements and submatrixes
+  # Implement row, column and minor in one method
+  # 
+  # * [i,j]:: Element i,j
+  # * [i,:*]:: Row i
+  # * [:*,j]:: Column j
+  # * [i1..i2,j]:: Row i1 to i2, column j
+  
+  def [](*args)
+    raise ArgumentError if args.size!=2
+    x=args[0]
+    y=args[1]
+    if x.is_a? Integer and y.is_a? Integer
+      @rows[args[0]][args[1]]
+    else
+      # set ranges according to arguments
+      
+      rx=case x
+        when Numeric
+          x..x
+        when :*
+          0..(row_size-1)
+        when Range
+          x
+      end
+      ry=case y
+        when Numeric
+          y..y
+        when :*
+          0..(column_size-1)
+        when Range
+          y
+      end
+      Matrix.rows(rx.collect {|i| ry.collect {|j| @rows[i][j]}})
+    end
+  end
   # Calculate sum of cells
   def total_sum
-    rows_sum.inject(0){|a,v| a+v}
+    row_sum.inject(0){|a,v| a+v}
   end
 end
 
@@ -52,26 +92,118 @@ module GSL
 end
 
 module Statsample
-  attr :labels
-  attr :name
-  module CorrelationMatrix
+  # Method for variance/covariance and correlation matrices
+  module CovariateMatrix
     def summary
       rp=ReportBuilder.new()
       rp.add(self)
       rp.to_text
     end
-    def labels=(v)
-      @labels=v
+    def type=(v)
+      @type=v
+    end
+    def type
+      if row_size.times.find {|i| self[i,i]!=1.0}
+        :covariance
+      else
+        :correlation
+      end
+      
+    end
+    def correlation
+      if(type==:covariance)
+      matrix=Matrix.rows(row_size.times.collect { |i|
+        column_size.times.collect { |j|
+            if i==j
+              1.0
+            else
+              self[i,j].quo(Math::sqrt(self[i,i])*Math::sqrt(self[j,j]))
+            end
+        }
+      })
+      matrix.extend CovariateMatrix 
+      matrix.fields_x=fields_x
+      matrix.fields_y=fields_y
+      matrix.type=:correlation
+      matrix
+      else
+        self
+      end
+    end
+    def fields
+      raise "Should be square" if !square?
+      @fields_x
+    end
+    def fields=(v)
+      raise "Matrix should be square" if !square?
+      @fields_x=v
+      @fields_y=v
+    end
+    def fields_x=(v)
+      raise "Size of fields != row_size" if v.size!=row_size
+      @fields_x=v
+    end
+    def fields_y=(v)
+      raise "Size of fields != column_size" if v.size!=column_size
+      @fields_y=v
+    end
+    def fields_x
+      if @fields_x.nil?
+        @fields_x=row_size.times.collect {|i| i} 
+      end
+      @fields_x
+    end
+    def fields_y
+      if @fields_y.nil?
+        @fields_y=column_size.times.collect {|i| i} 
+      end
+      @fields_y
     end
+    
     def name=(v)
       @name=v
     end
+    def name
+      @name
+    end
+    # Select a submatrix of factors. You could use labels or index to select
+    # the factors.
+    # If you don't specify columns, will be equal to rows
+    # Example:
+    #   a=Matrix[[1.0, 0.3, 0.2], [0.3, 1.0, 0.5], [0.2, 0.5, 1.0]]
+    #   a.extends CovariateMatrix
+    #   a.labels=%w{a b c}
+    #   a.submatrix(%{c a}, %w{b})
+    #   => Matrix[[0.5],[0.3]]
+    #   a.submatrix(%{c a})
+    #   => Matrix[[1.0, 0.2] , [0.2, 1.0]]
+    def submatrix(rows,columns=nil)
+      columns||=rows
+      # Convert all labels on index
+      row_index=rows.collect {|v| 
+        v.is_a?(Numeric) ? v : fields_x.index(v)
+      }
+      column_index=columns.collect {|v| 
+        v.is_a?(Numeric) ? v : fields_y.index(v)
+      }
+      
+      
+      fx=row_index.collect {|v| fields_x[v]}
+      fy=column_index.collect {|v| fields_y[v]}
+        
+      matrix= Matrix.rows(row_index.collect {|i|
+        row=column_index.collect {|j| self[i,j]}})
+      matrix.extend CovariateMatrix 
+      matrix.fields_x=fx
+      matrix.fields_y=fy
+      matrix.type=type
+      matrix
+    end
     def to_reportbuilder(generator)
-      @name||="Correlation Matrix"
-      @labels||=row_size.times.collect {|i| i.to_s} 
-      t=ReportBuilder::Table.new(:name=>@name, :header=>[""]+@labels)
+      @name||= (type==:correlation ? "Correlation":"Covariance")+" Matrix"
+      t=ReportBuilder::Table.new(:name=>@name, :header=>[""]+fields_y)
       row_size.times {|i|
-        t.add_row([@labels[i]]+@rows[i].collect {|i| sprintf("%0.3f",i).gsub("0.",".")})
+        t.add_row([fields_x[i]]+@rows[i].collect {|i1| sprintf("%0.3f",i1).gsub("0.",".")})
       }
       generator.parse_element(t)
     end

data/lib/statsample/multiset.rb

@@ -1,54 +1,54 @@
 module Statsample
-    # Multiset joins multiple dataset with the same fields and vectors
-    # but with different number of cases. 
-    # This is the base class for stratified and cluster sampling estimation
-    class Multiset
-        attr_reader :fields, :datasets
-        # To create a multiset
-        # * Multiset.new(%w{f1 f2 f3}) # define only fields
-        def initialize(fields)
-            @fields=fields
-            @datasets={}
-        end
-        def self.new_empty_vectors(fields,ds_names) 
-            ms=Multiset.new(fields)
-            ds_names.each{|d|
-                ms.add_dataset(d,Dataset.new(fields))
-            }
-            ms
-        end
-        def datasets_names
-            @datasets.keys.sort
-        end
-        def n_datasets
-            @datasets.size
-        end
-        def add_dataset(key,ds)
-            if(ds.fields!=@fields)
-            raise ArgumentError, "Dataset(#{ds.fields.to_s})must have the same fields of the Multiset(#{@fields})"
-            else
-                @datasets[key]=ds
-            end
-        end
-		def sum_field(field)
-			@datasets.inject(0) {|a,da|
-				stratum_name=da[0]
-                vector=da[1][field]
-				val=yield stratum_name,vector
-				a+val
-			}
-		end
-        def collect_vector(field)
-            @datasets.collect {|k,v|
-                yield k, v[field]
-            }
-        end
-        def[](i)
-            @datasets[i]
+  # Multiset joins multiple dataset with the same fields and vectors
+  # but with different number of cases. 
+  # This is the base class for stratified and cluster sampling estimation
+  class Multiset
+    attr_reader :fields, :datasets
+    # To create a multiset
+    # * Multiset.new(%w{f1 f2 f3}) # define only fields
+    def initialize(fields)
+        @fields=fields
+        @datasets={}
+    end
+    def self.new_empty_vectors(fields,ds_names) 
+        ms=Multiset.new(fields)
+        ds_names.each{|d|
+            ms.add_dataset(d,Dataset.new(fields))
+        }
+        ms
+    end
+    def datasets_names
+        @datasets.keys.sort
+    end
+    def n_datasets
+        @datasets.size
+    end
+    def add_dataset(key,ds)
+        if(ds.fields!=@fields)
+        raise ArgumentError, "Dataset(#{ds.fields.to_s})must have the same fields of the Multiset(#{@fields})"
+        else
+            @datasets[key]=ds
         end
     end
+    def sum_field(field)
+    @datasets.inject(0) {|a,da|
+    stratum_name=da[0]
+            vector=da[1][field]
+    val=yield stratum_name,vector
+    a+val
+    }
+    end
+    def collect_vector(field)
+        @datasets.collect {|k,v|
+            yield k, v[field]
+        }
+    end
+    def[](i)
+        @datasets[i]
+    end
+    end
     class StratifiedSample
-		class << self
+      class << self
 			# mean for an array of vectors
 			def mean(*vectors)
 				n_total=0
@@ -59,223 +59,206 @@ module Statsample
 				means.to_f/n_total
 			end
 
-            def standard_error_ksd_wr(es)
-                n_total=0
-                sum=es.inject(0){|a,h|
-                    n_total+=h['N']
-                    a+((h['N']**2 * h['s']**2) / h['n'].to_f)
-                }
-                (1.to_f / n_total)*Math::sqrt(sum)
-            end
-            
-            
-            def variance_ksd_wr(es)
-                standard_error_ksd_wr(es)**2
-            end
-            
-            # Source : Cochran (1972)
-            
-            def variance_ksd_wor(es)
-                n_total=es.inject(0) {|a,h|
-                    a+h['N']
-                }    
-                es.inject(0){|a,h|
-                    val=((h['N'].to_f / n_total)**2) * (h['s']**2 / h['n'].to_f) * (1 - (h['n'].to_f / h['N']))
-                    a+val
-                }
-            end
-            def standard_error_ksd_wor(es)
-                Math::sqrt(variance_ksd_wor(es))
-            end
-            
-            
-            
-            def variance_esd_wor(es)
-                n_total=es.inject(0) {|a,h|
-                    a+h['N']
-                }
-                
-                sum=es.inject(0){|a,h|
-                    val=h['N']*(h['N']-h['n'])*(h['s']**2 / h['n'].to_f)
-                    a+val
-                }
-                (1.0/(n_total**2))*sum
-            end
-            
-            
-            def standard_error_esd_wor(es)
-                Math::sqrt(variance_ksd_wor(es))
-            end
-            # Based on http://stattrek.com/Lesson6/STRAnalysis.aspx
-            def variance_esd_wr(es)
-                n_total=es.inject(0) {|a,h|
-                    a+h['N']
-                }
-                
-                sum=es.inject(0){|a,h|
-                    val= ((h['s']**2 * h['N']**2) / h['n'].to_f)
-                    a+val
-                }
-                (1.0/(n_total**2))*sum
-            end
-            def standard_error_esd_wr(es)
-                Math::sqrt(variance_esd_wr(es))
-            end
-            
-            def proportion_variance_ksd_wor(es)
-                n_total=es.inject(0) {|a,h|
-                    a+h['N']
-                }
-                
-                es.inject(0){|a,h|
-                    val= (((h['N'].to_f / n_total)**2 * h['p']*(1-h['p'])) / (h['n'])) * (1- (h['n'].to_f / h['N']))
-                    a+val
-                }
-            end
-            def proportion_sd_ksd_wor(es)
-                Math::sqrt(proportion_variance_ksd_wor(es))
-            end
-            
-            
-            def proportion_sd_ksd_wr(es)
-                n_total=es.inject(0) {|a,h|
-                    a+h['N']
-                }
-                
-                sum=es.inject(0){|a,h|
-                    val= (h['N']**2 * h['p']*(1-h['p'])) / h['n'].to_f
-                    a+val
-                }
-                Math::sqrt(sum) * (1.0/n_total)
-            end
-            def proportion_variance_ksd_wr(es)
-                proportion_variance_ksd_wor(es)**2
-            end
-            
-            def proportion_variance_esd_wor(es)
-                n_total=es.inject(0) {|a,h|
-                    a+h['N']
-                }
-                
-                sum=es.inject(0){|a,h|
-                    a=(h['N']**2 * (h['N']-h['n']) * h['p']*(1.0-h['p'])) / ((h['n']-1)*(h['N']-1))
-                    a+val
-                }
-                Math::sqrt(sum) * (1.0/n_total**2)
-            end
-            def proportion_sd_esd_wor(es)
-                Math::sqrt(proportion_variance_ksd_wor(es))
-            end
-            
-            
-            
+      def standard_error_ksd_wr(es)
+          n_total=0
+          sum=es.inject(0){|a,h|
+              n_total+=h['N']
+              a+((h['N']**2 * h['s']**2) / h['n'].to_f)
+          }
+          (1.to_f / n_total)*Math::sqrt(sum)
+      end
+      
+      
+      def variance_ksd_wr(es)
+          standard_error_ksd_wr(es)**2
+      end
+      def calculate_n_total(es)
+        es.inject(0) {|a,h| a+h['N'] }
+      end
+      # Source : Cochran (1972)
+      
+      def variance_ksd_wor(es)
+      n_total=calculate_n_total(es)
+      es.inject(0){|a,h|
+        val=((h['N'].to_f / n_total)**2) * (h['s']**2 / h['n'].to_f) * (1 - (h['n'].to_f / h['N']))
+        a+val
+      }
+      end
+      def standard_error_ksd_wor(es)
+          Math::sqrt(variance_ksd_wor(es))
+      end
+      
+      
+      
+      def variance_esd_wor(es)
+        n_total=calculate_n_total(es)
+        sum=es.inject(0){|a,h|
+          val=h['N']*(h['N']-h['n'])*(h['s']**2 / h['n'].to_f)
+          a+val
+        }
+        (1.0/(n_total**2))*sum
+      end
+      
+      
+      def standard_error_esd_wor(es)
+          Math::sqrt(variance_ksd_wor(es))
+      end
+      # Based on http://stattrek.com/Lesson6/STRAnalysis.aspx
+      def variance_esd_wr(es)
+        n_total=calculate_n_total(es)
+          sum=es.inject(0){|a,h|
+              val= ((h['s']**2 * h['N']**2) / h['n'].to_f)
+              a+val
+          }
+          (1.0/(n_total**2))*sum
+      end
+      def standard_error_esd_wr(es)
+          Math::sqrt(variance_esd_wr(es))
+      end
+      
+      def proportion_variance_ksd_wor(es)
+        n_total=calculate_n_total(es)
+          es.inject(0){|a,h|
+              val= (((h['N'].to_f / n_total)**2 * h['p']*(1-h['p'])) / (h['n'])) * (1- (h['n'].to_f / h['N']))
+              a+val
+          }
+      end
+      def proportion_sd_ksd_wor(es)
+          Math::sqrt(proportion_variance_ksd_wor(es))
+      end
+      
+      
+      def proportion_sd_ksd_wr(es)
+        n_total=calculate_n_total(es)
+        sum=es.inject(0){|a,h|
+          val= (h['N']**2 * h['p']*(1-h['p'])) / h['n'].to_f
+          a+val
+        }
+        Math::sqrt(sum) * (1.0/n_total)
+      end
+      def proportion_variance_ksd_wr(es)
+          proportion_variance_ksd_wor(es)**2
+      end
+      
+      def proportion_variance_esd_wor(es)
+      n_total=n_total=calculate_n_total(es)
+          
+          sum=es.inject(0){|a,h|
+              a=(h['N']**2 * (h['N']-h['n']) * h['p']*(1.0-h['p'])) / ((h['n']-1)*(h['N']-1))
+              a+val
+          }
+          Math::sqrt(sum) * (1.0/n_total**2)
+      end
+      def proportion_sd_esd_wor(es)
+          Math::sqrt(proportion_variance_ksd_wor(es))
+      end
 		end
-        def initialize(ms,strata_sizes)
-            raise TypeError,"ms should be a Multiset" unless ms.is_a? Statsample::Multiset
-            @ms=ms
-            raise ArgumentError,"You should put a strata size for each dataset" if strata_sizes.keys.sort!=ms.datasets_names
-            @strata_sizes=strata_sizes
-            @population_size=@strata_sizes.inject(0) {|a,x| a+x[1]}
-            @strata_number=@ms.n_datasets
-            @sample_size=@ms.datasets.inject(0) {|a,x| a+x[1].cases}
-        end
-        # Number of strata
-        def strata_number
-            @strata_number
-        end
-        # Population size. Equal to sum of strata sizes
-        # Symbol: N<sub>h</sub>
-        def population_size
-            @population_size
-        end
-        # Sample size. Equal to sum of sample of each stratum
-        def sample_size
-            @sample_size
-        end
-        # Size of stratum x
-        def stratum_size(h)
-            @strata_sizes[h]
-        end
-        def vectors_by_field(field)
-            @ms.datasets.collect{|k,ds|
-                ds[field]
-            }
-        end
-        # Population proportion based on strata
-        def proportion(field, v=1)
-			@ms.sum_field(field) {|s_name,vector|
-				stratum_ponderation(s_name)*vector.proportion(v)
-			}
-        end
-        # Stratum ponderation.
-        # Symbol: W\<sub>h\</sub>
-        def stratum_ponderation(h)
-            @strata_sizes[h].to_f / @population_size
-        end
-        alias_method :wh, :stratum_ponderation
-        
-        # Population mean based on strata
-        def mean(field)
-			@ms.sum_field(field) {|s_name,vector|
-				stratum_ponderation(s_name)*vector.mean
-			}
-        end
-        # Standard error with estimated population variance and without replacement.
-        # Source: Cochran (1972)
-        def standard_error_wor(field)
-            es=@ms.collect_vector(field) {|s_n, vector|
-                {'N'=>@strata_sizes[s_n],'n'=>vector.size, 's'=>vector.sds}
-            }
-            
-            StratifiedSample.standard_error_esd_wor(es)
-        end
-
-        # Standard error with estimated population variance and without replacement.
-        # Source: http://stattrek.com/Lesson6/STRAnalysis.aspx
-
-        def standard_error_wor_2(field)
-			sum=@ms.sum_field(field) {|s_name,vector|
-                s_size=@strata_sizes[s_name]
-				(s_size**2 * (1-(vector.size.to_f / s_size)) * vector.variance_sample / vector.size.to_f)
-			}
-            (1/@population_size.to_f)*Math::sqrt(sum)
-        end
-        
-        def standard_error_wr(field)
-            es=@ms.collect_vector(field) {|s_n, vector|
-                {'N'=>@strata_sizes[s_n],'n'=>vector.size, 's'=>vector.sds}
-            }
-            
-            StratifiedSample.standard_error_esd_wr(es)
-        end
-        def proportion_sd_esd_wor(field,v=1)
-            es=@ms.collect_vector(field) {|s_n, vector|
-                {'N'=>@strata_sizes[s_n],'n'=>vector.size, 'p'=>vector.proportion(v)}
-            }
-            
-            StratifiedSample.proportion_sd_esd_wor(es)
-        end
-        
-        def proportion_standard_error(field,v=1)
-            prop=proportion(field,v)
-            sum=@ms.sum_field(field) {|s_name,vector|
-                nh=vector.size
-                s_size=@strata_sizes[s_name]
-                (s_size**2 * (1-(nh/s_size)) * prop * (1-prop) / (nh -1 ))
-            }
-            (1.quo(@population_size)) * Math::sqrt(sum)
-        end
-        # Cochran(1971), p. 150 
-        def variance_pst(field,v=1)
-            sum=@ms.datasets.inject(0) {|a,da|
-                stratum_name=da[0]
-                ds=da[1]
-                nh=ds.cases.to_f
-                s_size=@strata_sizes[stratum_name]
-                prop=ds[field].proportion(v)
-                a + (((s_size**2 * (s_size-nh)) / (s_size-1))*(prop*(1-prop) / (nh-1)))
-            }
-            (1/@population_size.to_f ** 2)*sum
-        end
-    end
+  def initialize(ms,strata_sizes)
+      raise TypeError,"ms should be a Multiset" unless ms.is_a? Statsample::Multiset
+      @ms=ms
+      raise ArgumentError,"You should put a strata size for each dataset" if strata_sizes.keys.sort!=ms.datasets_names
+      @strata_sizes=strata_sizes
+      @population_size=@strata_sizes.inject(0) {|a,x| a+x[1]}
+      @strata_number=@ms.n_datasets
+      @sample_size=@ms.datasets.inject(0) {|a,x| a+x[1].cases}
+  end
+  # Number of strata
+  def strata_number
+      @strata_number
+  end
+  # Population size. Equal to sum of strata sizes
+  # Symbol: N<sub>h</sub>
+  def population_size
+      @population_size
+  end
+  # Sample size. Equal to sum of sample of each stratum
+  def sample_size
+      @sample_size
+  end
+  # Size of stratum x
+  def stratum_size(h)
+      @strata_sizes[h]
+  end
+  def vectors_by_field(field)
+      @ms.datasets.collect{|k,ds|
+          ds[field]
+      }
+  end
+  # Population proportion based on strata
+  def proportion(field, v=1)
+  @ms.sum_field(field) {|s_name,vector|
+  stratum_ponderation(s_name)*vector.proportion(v)
+  }
+  end
+  # Stratum ponderation.
+  # Symbol: W\<sub>h\</sub>
+  def stratum_ponderation(h)
+    @strata_sizes[h].to_f / @population_size
+  end
+  alias_method :wh, :stratum_ponderation
+  
+  # Population mean based on strata
+  def mean(field)
+    @ms.sum_field(field) {|s_name,vector|
+    stratum_ponderation(s_name)*vector.mean
+    }
+  end
+  # Standard error with estimated population variance and without replacement.
+  # Source: Cochran (1972)
+  def standard_error_wor(field)
+      es=@ms.collect_vector(field) {|s_n, vector|
+          {'N'=>@strata_sizes[s_n],'n'=>vector.size, 's'=>vector.sds}
+      }
+      
+      StratifiedSample.standard_error_esd_wor(es)
+  end
+  
+  # Standard error with estimated population variance and without replacement.
+  # Source: http://stattrek.com/Lesson6/STRAnalysis.aspx
+  
+  def standard_error_wor_2(field)
+  sum=@ms.sum_field(field) {|s_name,vector|
+          s_size=@strata_sizes[s_name]
+  (s_size**2 * (1-(vector.size.to_f / s_size)) * vector.variance_sample / vector.size.to_f)
+  }
+      (1/@population_size.to_f)*Math::sqrt(sum)
+  end
+  
+  def standard_error_wr(field)
+      es=@ms.collect_vector(field) {|s_n, vector|
+          {'N'=>@strata_sizes[s_n],'n'=>vector.size, 's'=>vector.sds}
+      }
+      
+      StratifiedSample.standard_error_esd_wr(es)
+  end
+  def proportion_sd_esd_wor(field,v=1)
+      es=@ms.collect_vector(field) {|s_n, vector|
+          {'N'=>@strata_sizes[s_n],'n'=>vector.size, 'p'=>vector.proportion(v)}
+      }
+      
+      StratifiedSample.proportion_sd_esd_wor(es)
+  end
+  
+  def proportion_standard_error(field,v=1)
+      prop=proportion(field,v)
+      sum=@ms.sum_field(field) {|s_name,vector|
+          nh=vector.size
+          s_size=@strata_sizes[s_name]
+          (s_size**2 * (1-(nh/s_size)) * prop * (1-prop) / (nh -1 ))
+      }
+      (1.quo(@population_size)) * Math::sqrt(sum)
+  end
+  # Cochran(1971), p. 150 
+  def variance_pst(field,v=1)
+      sum=@ms.datasets.inject(0) {|a,da|
+          stratum_name=da[0]
+          ds=da[1]
+          nh=ds.cases.to_f
+          s_size=@strata_sizes[stratum_name]
+          prop=ds[field].proportion(v)
+          a + (((s_size**2 * (s_size-nh)) / (s_size-1))*(prop*(1-prop) / (nh-1)))
+      }
+      (1/@population_size.to_f ** 2)*sum
+  end
+  end
 end