statsample 1.5.0 → 2.0.0

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

@@ -59,8 +59,6 @@ class MatrixEngine < BaseEngine
     @matrix_y = @matrix_cor.submatrix(@fields, [y_var])
     @matrix_y_cov = @matrix_cov.submatrix(@fields, [y_var])
     
-
-    
     @y_sd=Math::sqrt(@matrix_cov.submatrix([y_var])[0,0])
     
     @x_sd=@n_predictors.times.inject({}) {|ac,i|
@@ -77,14 +75,14 @@ class MatrixEngine < BaseEngine
     @y_mean=0.0
     @name=_("Multiple reggresion of %s on %s") % [@fields.join(","), @y_var]
     
-    opts_default={:digits=>3}
-    opts=opts_default.merge opts
+    opts_default = {:digits=>3}
+    opts         = opts_default.merge opts
     opts.each{|k,v|
         self.send("#{k}=",v) if self.respond_to? k
     }
       result_matrix=@matrix_x_cov.inverse * @matrix_y_cov
 
-    if matrix._type==:covariance
+    if matrix._type == :covariance
       @coeffs=result_matrix.column(0).to_a
       @coeffs_stan=coeffs.collect {|k,v|
         coeffs[k]*@x_sd[k].quo(@y_sd)
@@ -116,12 +114,12 @@ class MatrixEngine < BaseEngine
   end
   # Value of constant
   def constant
-    c=coeffs
-    @y_mean - @fields.inject(0){|a,k| a + (c[k] * @x_mean[k])}
+    c = coeffs
+    @y_mean - @fields.inject(0) { |a,k| a + (c[k] * @x_mean[k])}
   end
   # Hash of b or raw coefficients
   def coeffs
-    assign_names(@coeffs)    
+    assign_names(@coeffs)
   end
   # Hash of beta or standarized coefficients
 
@@ -185,7 +183,7 @@ class MatrixEngine < BaseEngine
     sd[:constant]=0
     fields=[:constant]+@matrix_cov.fields-[@y_var]
     # Recreate X'X using the variance-covariance matrix
-    xt_x=Matrix.rows(fields.collect {|i|
+    xt_x=::Matrix.rows(fields.collect {|i|
       fields.collect {|j|
         if i==:constant or j==:constant
           cov=0

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

@@ -8,76 +8,74 @@ module Multiple
 # 
 # Example:
 #
-#   @a=[1,3,2,4,3,5,4,6,5,7].to_vector(:numeric)
-#   @b=[3,3,4,4,5,5,6,6,4,4].to_vector(:numeric)
-#   @c=[11,22,30,40,50,65,78,79,99,100].to_vector(:numeric)
-#   @y=[3,4,5,6,7,8,9,10,20,30].to_vector(:numeric)
-#   ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
-#   lr=Statsample::Regression::Multiple::RubyEngine.new(ds,'y')
+#   @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::RubyEngine.new(ds,:y)
 
 class RubyEngine < MatrixEngine
   def initialize(ds,y_var, opts=Hash.new)
-    matrix=ds.correlation_matrix
-    fields_indep=ds.fields-[y_var]
-    default={
-      :y_mean=>ds[y_var].mean,
-      :x_mean=>fields_indep.inject({}) {|ac,f|  ac[f]=ds[f].mean; ac},
-      :y_sd=>ds[y_var].sd,
-      :x_sd=>fields_indep.inject({}) {|ac,f|  ac[f]=ds[f].sd; ac},
-      :cases=>Statsample::Bivariate.min_n_valid(ds)
+    matrix = Statsample::Bivariate.correlation_matrix ds
+    fields_indep=ds.vectors.to_a - [y_var]
+    default= {
+      :y_mean => ds[y_var].mean,
+      :x_mean => fields_indep.inject({}) {|ac,f|  ac[f]=ds[f].mean; ac},
+      :y_sd   => ds[y_var].sd,
+      :x_sd   => fields_indep.inject({}) {|ac,f|  ac[f]=ds[f].sd; ac},
+      :cases  => Statsample::Bivariate.min_n_valid(ds)
     }
-    opts=opts.merge(default)
+    opts = opts.merge(default)
     super(matrix, y_var, opts)
-    @ds=ds
-    @dy=ds[@y_var]
-    @ds_valid=ds.dup_only_valid
-    @total_cases=@ds.cases
-    @valid_cases=@ds_valid.cases
-    @ds_indep = ds.dup(ds.fields-[y_var])
+    @ds = ds
+    @dy = ds[@y_var]
+    @ds_valid = ds.dup_only_valid
+    @total_cases = @ds.nrows
+    @valid_cases = @ds_valid.nrows
+    @ds_indep    = ds.dup(ds.vectors.to_a - [y_var])
     set_dep_columns
   end
   
   def set_dep_columns
-    @dep_columns=[]
-    @ds_indep.each_vector{|k,v|
-      @dep_columns.push(v.data_with_nils)
-    }                
+    @dep_columns = []
+    @ds_indep.each_vector { |v| @dep_columns.push(v.to_a) }                
   end
 
   def fix_with_mean
     i=0
-    @ds_indep.each do |row|
+    @ds_indep.each(:row) do |row|
       empty=[]
       row.each do |k,v|
         empty.push(k) if v.nil?
       end
+
       if empty.size==1
         @ds_indep[empty[0]][i]=@ds[empty[0]].mean
       end
-      i+=1
+      i += 1
     end
-    @ds_indep.update_valid_data
+    @ds_indep.update
     set_dep_columns
   end
   def fix_with_regression
-    i=0
-    @ds_indep.each{|row|
-      empty=[]
-      row.each{|k,v|
-          empty.push(k) if v.nil?
-      }
+    i = 0
+    @ds_indep.each(:row) do |row|
+      empty = []
+      row.each { |k,v| empty.push(k) if v.nil? }
       if empty.size==1
-        field=empty[0]
-        lr=MultipleRegression.new(@ds_indep,field)
-        fields=[]
-        @ds_indep.fields.each{|f|
-            fields.push(row[f]) unless f==field
+        field  = empty[0]
+        lr     = MultipleRegression.new(@ds_indep,field)
+        fields = []
+        @ds_indep.vectors.each { |f|
+          fields.push(row[f]) unless f == field
         }
+        
         @ds_indep[field][i]=lr.process(fields)
       end
       i+=1
-    }
-    @ds_indep.update_valid_data
+    end
+    @ds_indep.update
     set_dep_columns
   end
   # Standard error for constant

data/lib/statsample/reliability.rb

@@ -4,30 +4,30 @@ module Statsample
       # Calculate Chonbach's alpha for a given dataset.
       # only uses tuples without missing data
       def cronbach_alpha(ods)
-        ds=ods.dup_only_valid
-        n_items=ds.fields.size
-        return nil if n_items<=1
-        s2_items=ds.vectors.inject(0) {|ac,v|
-        ac+v[1].variance }
-        total=ds.vector_sum
+        ds = ods.dup_only_valid
+        n_items = ds.ncols
+        return nil if n_items <= 1
+        s2_items = ds.to_hash.values.inject(0) { |ac,v| 
+          ac + v.variance }
+        total    = ds.vector_sum
         
-        (n_items.quo(n_items-1)) * (1-(s2_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.
       # Only uses tuples without missing data
       # Return nil if one or more vectors has 0 variance
       def cronbach_alpha_standarized(ods)
+        ds = ods.dup_only_valid
+        return nil if ds.any? { |v| v.variance==0}
         
-        ds=ods.dup_only_valid
-        
-        return nil if ds.vectors.any? {|k,v| v.variance==0}
-        
-        ds=ds.fields.inject({}){|a,f|
-          a[f]=ods[f].standarized; 
-          a
-        }.to_dataset
-        
+        ds = Daru::DataFrame.new(
+          ds.vectors.to_a.inject({}) { |a,i|
+            a[i] = ods[i].standardize
+            a
+          }
+        )
+                
         cronbach_alpha(ds)
       end
       # Predicted reliability of a test by replicating
@@ -54,10 +54,10 @@ module Statsample
       end
       # Get Cronbach's alpha from a covariance matrix
       def cronbach_alpha_from_covariance_matrix(cov)
-        n=cov.row_size
+        n = cov.row_size
         raise "covariance matrix should have at least 2 variables" if n < 2
-        s2=n.times.inject(0) {|ac,i| ac+cov[i,i]}
-        (n.quo(n-1))*(1-(s2.quo(cov.total_sum)))
+        s2 = n.times.inject(0) { |ac,i| ac + cov[i,i] }
+        (n.quo(n - 1)) * (1 - (s2.quo(cov.total_sum)))
       end
       # Returns n necessary to obtain specific alpha
       # given variance and covariance mean of items
@@ -82,8 +82,6 @@ module Statsample
           end
           c_a=cronbach_alpha_from_n_s2_cov(n,s2,cov)
           dif=c_a - alpha
-          #puts "#{n} , #{c_a}"
-          
         end
         n
       end
@@ -110,20 +108,20 @@ module Statsample
       attr_reader :totals, :counts, :vector_total
       def initialize (ds, vector_total=nil)
         vector_total||=ds.vector_sum
-        raise ArgumentError, "Total size != Dataset size" if vector_total.size!=ds.cases
+        raise ArgumentError, "Total size != Dataset size" if vector_total.size != ds.nrows
         @vector_total=vector_total
         @ds=ds
         @totals={}
-        @counts=@ds.fields.inject({}) {|a,v| a[v]={};a}
+        @counts=@ds.vectors.to_a.inject({}) {|a,v| a[v]={};a}
         process
       end
       def process
         i=0
-        @ds.each do |row|
+        @ds.each_row do |row|
           tot=@vector_total[i]
           @totals[tot]||=0
           @totals[tot]+=1
-          @ds.fields.each  do |f|
+          @ds.vectors.each  do |f|
             item=row[f].to_s
             @counts[f][tot]||={}
             @counts[f][tot][item]||=0

data/lib/statsample/reliability/icc.rb

@@ -6,12 +6,12 @@ module Statsample
     # several ratings) on a target and another measurement obtained on that target"
     # == Usage
     #   require 'statsample'
-    #   size=1000
-    #   a = size.times.map {rand(10)}.to_numeric
+    #   size = 1000
+    #   a = Daru::Vector.new(size.times.map {rand(10)})
     #   b = a.recode{|i|i+rand(4)-2}
-    #   c  =a.recode{|i|i+rand(4)-2}
+    #   c = a.recode{|i|i+rand(4)-2}
     #   d = a.recode{|i|i+rand(4)-2}
-    #   ds={'a'=>a,'b'=>b,'c'=>c,'d'=>d}.to_dataset
+    #   ds = Daru::DataFrame.new({:a => a,:b => b,:c => c,:d => d})
     #   # Use :type attribute to set type to summarize
     #   icc=Statsample::Reliability::ICC.new(ds, :type=>:icc_1_k)
     #   puts icc.summary
@@ -96,10 +96,11 @@ module Statsample
       attr_accessor :alpha
       attr_accessor :name
       def initialize(ds, opts=Hash.new)
+        ds.update
         @ds=ds.dup_only_valid
-        @vectors=@ds.vectors.values
-        @n=@ds.cases
-        @k=@ds.fields.size
+        @vectors=@ds.map { |e| e }
+        @n=@ds.nrows
+        @k=@ds.ncols
         compute
         @g_rho=0
         @alpha=0.05

data/lib/statsample/reliability/multiscaleanalysis.rb

@@ -6,17 +6,17 @@ module Statsample
     # PCA and Factor Analysis.
     # 
     # == Usage
-    #  @x1=[1,1,1,1,2,2,2,2,3,3,3,30].to_vector(:numeric)
-    #  @x2=[1,1,1,2,2,3,3,3,3,4,4,50].to_vector(:numeric)
-    #  @x3=[2,2,1,1,1,2,2,2,3,4,5,40].to_vector(:numeric)
-    #  @x4=[1,2,3,4,4,4,4,3,4,4,5,30].to_vector(:numeric)
-    #  ds={'x1'=>@x1,'x2'=>@x2,'x3'=>@x3,'x4'=>@x4}.to_dataset
+    #  @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})
     #  opts={:name=>"Scales", # Name of analysis
     #        :summary_correlation_matrix=>true, # Add correlation matrix
     #        :summary_pca } # Add PCA between scales
     #  msa=Statsample::Reliability::MultiScaleAnalysis.new(opts) do |m|
-    #    m.scale :s1, ds.clone(%w{x1 x2})
-    #    m.scale :s2, ds.clone(%w{x3 x4}), {:name=>"Scale 2"}
+    #    m.scale :s1, ds.clone([:x1, :x2])
+    #    m.scale :s2, ds.clone([:x3, :x4]), {:name=>"Scale 2"}
     #  end
     #  # Retrieve summary
     #  puts msa.summary 
@@ -107,7 +107,7 @@ module Statsample
       # Retrieves a Principal Component Analysis (Factor::PCA)
       # using all scales, using <tt>opts</tt> a options.
       def pca(opts=nil)
-        opts||=pca_options        
+        opts ||= pca_options        
         Statsample::Factor::PCA.new(correlation_matrix, opts)
       end
       # Retrieve Velicer's MAP
@@ -123,14 +123,15 @@ module Statsample
         Statsample::Factor::PrincipalAxis.new(correlation_matrix, opts)
       end
       def dataset_from_scales
-        ds=Dataset.new(@scales_keys)
+        ds = Daru::DataFrame.new({}, order: @scales_keys.map(&:to_sym))
         @scales.each_pair do |code,scale|
-          ds[code.to_s]=scale.ds.vector_sum
-          ds[code.to_s].name=scale.name
+          ds[code.to_sym] = scale.ds.vector_sum
         end
-        ds.update_valid_data
+        
+        ds.update
         ds
       end
+
       def parallel_analysis(opts=nil)
         opts||=parallel_analysis_options
         Statsample::Factor::ParallelAnalysis.new(dataset_from_scales, opts)
@@ -140,6 +141,7 @@ module Statsample
       def correlation_matrix
         Statsample::Bivariate.correlation_matrix(dataset_from_scales)
       end
+
       def report_building(b) # :nodoc:
         b.section(:name=>name) do |s|
           s.section(:name=>_("Reliability analysis of scales")) do |s2|

data/lib/statsample/reliability/scaleanalysis.rb

@@ -3,12 +3,12 @@ module Statsample
     # Analysis of a Scale. Analoge of Scale Reliability analysis on SPSS.
     # Returns several statistics for complete scale and each item
     # == Usage
-    #  @x1=[1,1,1,1,2,2,2,2,3,3,3,30].to_vector(:numeric)
-    #  @x2=[1,1,1,2,2,3,3,3,3,4,4,50].to_vector(:numeric)
-    #  @x3=[2,2,1,1,1,2,2,2,3,4,5,40].to_vector(:numeric)
-    #  @x4=[1,2,3,4,4,4,4,3,4,4,5,30].to_vector(:numeric)
-    #  ds={'x1'=>@x1,'x2'=>@x2,'x3'=>@x3,'x4'=>@x4}.to_dataset
-    #  ia=Statsample::Reliability::ScaleAnalysis.new(ds)
+    #  @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)
     #  puts ia.summary
     class ScaleAnalysis
       include Summarizable
@@ -16,40 +16,40 @@ module Statsample
       attr_accessor :name
       attr_accessor :summary_histogram
       def initialize(ds, opts=Hash.new)
-        @dumped=ds.fields.find_all {|f|
-          ds[f].variance==0
+        @dumped=ds.vectors.to_a.find_all {|f|
+          ds[f].variance == 0
         }
         
-        @ods=ds
-        @ds=ds.dup_only_valid(ds.fields - @dumped)
-        @ds.name=ds.name
+        @ods = ds
+        @ds  = ds.dup_only_valid(ds.vectors.to_a - @dumped)
+        @ds.rename ds.name
         
-        @k=@ds.fields.size        
-        @total=@ds.vector_sum
+        @k     = @ds.ncols
+        @total = @ds.vector_sum
         @o_total=@dumped.size > 0 ? @ods.vector_sum : nil
         
-        @vector_mean=@ds.vector_mean
-        @item_mean=@vector_mean.mean
-        @item_sd=@vector_mean.sd
+        @vector_mean = @ds.vector_mean
+        @item_mean   = @vector_mean.mean
+        @item_sd     = @vector_mean.sd
         
-        @mean=@total.mean
-        @median=@total.median
-        
-        @skew=@total.skew
-        @kurtosis=@total.kurtosis
-        @sd = @total.sd
-        @variance=@total.variance
-        @valid_n = @total.size
-        opts_default={
-          :name=>_("Reliability Analysis"),
-          :summary_histogram=>true
+        @mean     = @total.mean
+        @median   = @total.median
+        @skew     = @total.skew
+        @kurtosis = @total.kurtosis
+        @sd       = @total.sd
+        @variance = @total.variance
+        @valid_n  = @total.size
+
+        opts_default = {
+          :name => _("Reliability Analysis"),
+          :summary_histogram => true
         }
-        @opts=opts_default.merge(opts)
-        @opts.each{|k,v| self.send("#{k}=",v) if self.respond_to? k }
+        @opts = opts_default.merge(opts)
+        @opts.each{ |k,v| self.send("#{k}=",v) if self.respond_to? k }
         
         @cov_m=Statsample::Bivariate.covariance_matrix(@ds)
         # Mean for covariances and variances
-        @variances=@k.times.map {|i| @cov_m[i,i]}.to_numeric
+        @variances = Daru::Vector.new(@k.times.map { |i| @cov_m[i,i] })
         @variances_mean=@variances.mean
         @covariances_mean=(@variance-@variances.sum).quo(@k**2-@k)
         #begin
@@ -66,7 +66,7 @@ module Statsample
         total={}
         @ds.each do |row|
           tot=@total[i]
-          @ds.fields.each do |f|
+          @ds.vectors.each do |f|
             out[f]||= {}
             total[f]||={}
             out[f][tot]||= 0
@@ -87,43 +87,41 @@ module Statsample
       # Adjusted RPB(Point biserial-correlation) for each item
       #
       def item_total_correlation
-        @itc||=@ds.fields.inject({}) do |a,v|
-          vector=@ds[v].clone
-          ds2=@ds.clone
-          ds2.delete_vector(v)
-          total=ds2.vector_sum
-          a[v]=Statsample::Bivariate.pearson(vector,total)
+        vecs = @ds.vectors.to_a
+        @itc ||= vecs.inject({}) do |a,v|
+          total=@ds.vector_sum(vecs - [v])
+          a[v]=Statsample::Bivariate.pearson(@ds[v],total)
           a
         end
       end
       def mean_rpb
-        item_total_correlation.values.to_numeric.mean
+        Daru::Vector.new(item_total_correlation.values).mean
       end
       def item_statistics
-          @is||=@ds.fields.inject({}) do |a,v|
-            a[v]={:mean=>@ds[v].mean, :sds=>Math::sqrt(@cov_m.variance(v))}
-            a
-          end
+        @is||=@ds.vectors.to_a.inject({}) do |a,v|
+          a[v]={:mean=>@ds[v].mean, :sds=>Math::sqrt(@cov_m.variance(v))}
+          a
+        end
       end
       # Returns a dataset with cases ordered by score
       # and variables ordered by difficulty
 
       def item_difficulty_analysis
         dif={}
-        @ds.fields.each{|f| dif[f]=@ds[f].mean }
-        dif_sort=dif.sort{|a,b| -(a[1]<=>b[1])}
+        @ds.vectors.each{|f| dif[f]=@ds[f].mean }
+        dif_sort = dif.sort { |a,b| -(a[1]<=>b[1]) }
         scores_sort={}
         scores=@ds.vector_mean
-        scores.each_index{|i| scores_sort[i]=scores[i] }
+        scores.each_index{ |i| scores_sort[i]=scores[i] }
         scores_sort=scores_sort.sort{|a,b| a[1]<=>b[1]}
-        ds_new=Statsample::Dataset.new(['case','score'] + dif_sort.collect{|a,b| a})
+        ds_new = Daru::DataFrame.new({}, order: ([:case,:score] + dif_sort.collect{|a,b| a.to_sym}))
         scores_sort.each do |i,score|
-          row=[i, score]
-          case_row=@ds.case_as_hash(i)
-          dif_sort.each{|variable,dif_value| row.push(case_row[variable]) }
-          ds_new.add_case_array(row)
+          row = [i, score]
+          case_row = @ds.row[i].to_hash
+          dif_sort.each{ |variable,dif_value| row.push(case_row[variable]) }
+          ds_new.add_row(row)
         end
-        ds_new.update_valid_data
+        ds_new.update
         ds_new
       end
       
@@ -132,9 +130,10 @@ module Statsample
       end
       
       def stats_if_deleted_intern # :nodoc:
-        return Hash.new if @ds.fields.size==1
-        @ds.fields.inject({}) do |a,v|
-          cov_2=@cov_m.submatrix(@ds.fields-[v])
+        return Hash.new if @ds.ncols == 1
+        vecs = @ds.vectors.to_a
+        vecs.inject({}) do |a,v|
+          cov_2=@cov_m.submatrix(vecs - [v])
           #ds2=@ds.clone
           #ds2.delete_vector(v)
           #total=ds2.vector_sum
@@ -151,11 +150,10 @@ module Statsample
       def report_building(builder) #:nodoc:
         builder.section(:name=>@name) do |s|
           
-          
           if @dumped.size>0
             s.section(:name=>"Items with variance=0") do |s1|
               s.table(:name=>_("Summary for %s with all items") % @name) do |t|
-                t.row [_("Items"), @ods.fields.size]
+                t.row [_("Items"), @ods.ncols]
                 t.row [_("Sum mean"),     "%0.4f" % @o_total.mean]
                 t.row [_("S.d. mean"),     "%0.4f" % @o_total.sd]
               end
@@ -170,7 +168,7 @@ module Statsample
           
           
           s.table(:name=>_("Summary for %s") % @name) do |t|
-            t.row [_("Valid Items"), @ds.fields.size]
+            t.row [_("Valid Items"), @ds.ncols]
           
           t.row [_("Valid cases"), @valid_n]
           t.row [_("Sum mean"),     "%0.4f" % @mean]
@@ -193,8 +191,8 @@ module Statsample
           end
           
           if (@alpha)
-            s.text _("Items for obtain alpha(0.8) : %d" % Statsample::Reliability::n_for_desired_reliability(@alpha, 0.8, @ds.fields.size))
-            s.text _("Items for obtain alpha(0.9) : %d" % Statsample::Reliability::n_for_desired_reliability(@alpha, 0.9, @ds.fields.size))          
+            s.text _("Items for obtain alpha(0.8) : %d" % Statsample::Reliability::n_for_desired_reliability(@alpha, 0.8, @ds.ncols))
+            s.text _("Items for obtain alpha(0.9) : %d" % Statsample::Reliability::n_for_desired_reliability(@alpha, 0.9, @ds.ncols))
           end
           
           
@@ -203,7 +201,7 @@ module Statsample
           itc=item_total_correlation
           
           s.table(:name=>_("Items report for %s") % @name, :header=>["item","mean","sd", "mean if deleted", "var if deleted", "sd if deleted"," item-total correl.", "alpha if deleted"]) do |t|
-            @ds.fields.each do |f|
+            @ds.vectors.each do |f|
               row=["#{@ds[f].name}(#{f})"]
               if is[f]
                 row+=[sprintf("%0.5f",is[f][:mean]), sprintf("%0.5f", is[f][:sds])]