statsample 0.5.0 → 0.5.1

data/lib/statsample/combination.rb

@@ -1,113 +1,115 @@
 module Statsample
-    # Combination class systematically generates all combinations of n elements, taken r at a time.
-    # With rbgsl, GSL::Combination is available for extra speed
-    # Source: http://snippets.dzone.com/posts/show/4666
-    # Use:
-    #  comb=Statsample::Combination.new(3,5)
-    #  => #<Statsample::Combination:0x7f6323804e08 @n=5, @d=#<Statsample::Combination::CombinationGsl:0x7f63237ff7f0 @n=5, @k=3, @c=GSL::Combination>, @k=3>
-    #  comb.each{|c| p c }
-    #  [0, 1, 2]
-    #  [0, 1, 3]
-    #  [0, 1, 4]
-    #  [0, 2, 3]
-    #  [0, 2, 4]
-    #  [0, 3, 4]
-    #  [1, 2, 3]
-    #  [1, 2, 4]
-    #  [1, 3, 4]
-    #  [2, 3, 4]
-    #
-    class Combination
-        attr_reader :d
-        def initialize(k,n,only_ruby=false)
-            @k=k
-            @n=n
-            if HAS_GSL and !only_ruby
-                @d=CombinationGsl.new(@k,@n)
-            else
-                @d=CombinationRuby.new(@k,@n)
-            end
+  # Combination class systematically generates all combinations of n elements, taken r at a time.
+  # With rbgsl, GSL::Combination is available for extra speed
+  # Source: http://snippets.dzone.com/posts/show/4666
+  # Use:
+  #  comb=Statsample::Combination.new(3,5)
+  #  => #<Statsample::Combination:0x7f6323804e08 @n=5, @d=#<Statsample::Combination::CombinationGsl:0x7f63237ff7f0 @n=5, @k=3, @c=GSL::Combination>, @k=3>
+  #  comb.each{|c| p c }
+  #  [0, 1, 2]
+  #  [0, 1, 3]
+  #  [0, 1, 4]
+  #  [0, 2, 3]
+  #  [0, 2, 4]
+  #  [0, 3, 4]
+  #  [1, 2, 3]
+  #  [1, 2, 4]
+  #  [1, 3, 4]
+  #  [2, 3, 4]
+  #
+  class Combination
+    attr_reader :d
+    def initialize(k,n,only_ruby=false)
+        @k=k
+        @n=n
+        if HAS_GSL and !only_ruby
+            @d=CombinationGsl.new(@k,@n)
+        else
+            @d=CombinationRuby.new(@k,@n)
         end
-        def each
-            reset
-            while a=next_value
-                yield a
-            end
-        end
-        def reset
-            @d.reset
-        end
-        def next_value
-            @d.next_value
-        end
-        class CombinationRuby
-        attr_reader :data
-        def initialize(k,n)
-            raise "k<=n" if k>n
-            @k=k
-            @n=n
-            reset
-        end
-        def reset
-            @data=[]
-            (0...@k).each {|i|
-                @data[i] = i;
-            }
-        end
-        def each
-            reset
-            while a=next_value
-                yield a
-            end
-        end
-        def next_value
-            return false if !@data
-            old_comb=@data.dup
-            i = @k - 1;
-            @data[i]+=1
-            while ((i >= 0) and (@data[i] >= @n - @k + 1 + i)) do
-                i-=1;
-                @data[i]+=1;
-            end
-            
-            if (@data[0] > @n - @k) # Combination (n-k, n-k+1, ..., n) reached */
-                @data=false # No more combinations can be generated 
-            else
-                # comb now looks like (..., x, n, n, n, ..., n).
-                # Turn it into (..., x, x + 1, x + 2, ...) 
-                i = i+1
-                (i...@k).each{ |i1|
-                    @data[i1] = @data[i1 - 1] + 1
-                }
-            end
-            return old_comb
+    end
+    def each
+        reset
+        while a=next_value
+            yield a
         end
     end
+    def reset
+        @d.reset
+    end
+    def next_value
+        @d.next_value
+    end
+    
+    # Ruby engine for Combinations
+    class CombinationRuby
+      attr_reader :data
+      def initialize(k,n)
+          raise "k<=n" if k>n
+          @k=k
+          @n=n
+          reset
+      end
+      def reset
+          @data=[]
+          (0...@k).each {|i| @data[i] = i }
+      end
+      def each
+          reset
+          while a=next_value
+              yield a
+          end
+      end
+      def next_value
+          return false if !@data
+          old_comb=@data.dup
+          i = @k - 1;
+          @data[i]+=1
+          while ((i >= 0) and (@data[i] >= @n - @k + 1 + i)) do
+              i-=1;
+              @data[i]+=1;
+          end
+          
+          if (@data[0] > @n - @k) # Combination (n-k, n-k+1, ..., n) reached */
+              @data=false # No more combinations can be generated 
+          else
+              # comb now looks like (..., x, n, n, n, ..., n).
+              # Turn it into (..., x, x + 1, x + 2, ...) 
+              i = i+1
+              (i...@k).each{ |i1|
+                  @data[i1] = @data[i1 - 1] + 1
+              }
+          end
+          return old_comb
+      end
+    end
+    
+    # rb-gsl engine for Combinations
     class CombinationGsl
-        def initialize(k,n)
-            require 'gsl'
-            raise "k<=n" if k>n
-            @k=k
-            @n=n
-            reset
-        end
-        def reset
-            @c= ::GSL::Combination.calloc(@n, @k);
-        end
-        def next_value
-            return false if !@c
-            data=@c.data.to_a
-            if @c.next != GSL::SUCCESS
-                @c=false
-            end
-            return data
-        end
-        def each
-            reset
-            begin
-                yield @c.data.to_a
-            end while @c.next == GSL::SUCCESS
-        end
+      def initialize(k,n)
+          require 'gsl'
+          raise "k<=n" if k>n
+          @k=k
+          @n=n
+          reset
+      end
+      def reset
+          @c= ::GSL::Combination.calloc(@n, @k);
+      end
+      def next_value
+          return false if !@c
+          data=@c.data.to_a
+          if @c.next != GSL::SUCCESS
+              @c=false
+          end
+          return data
+      end
+      def each
+          reset
+          begin
+            yield @c.data.to_a
+          end while @c.next == GSL::SUCCESS
+      end
     end
-end
+  end
 end

data/lib/statsample/converter/csv18.rb

@@ -1,56 +1,56 @@
 module Statsample
-class CSV < SpreadsheetBase
-		class << self
-        # Returns a Dataset  based on a csv file
-        #
-        # USE:
-        #     ds=Statsample::CSV.read("test_csv.csv")
-        def read(filename, empty=[''],ignore_lines=0,fs=nil,rs=nil)
+  class CSV < SpreadsheetBase
+    class << self
+      # Returns a Dataset  based on a csv file
+      #
+      # USE:
+      #     ds=Statsample::CSV.read("test_csv.csv")
+      def read(filename, empty=[''],ignore_lines=0,fs=nil,rs=nil)
         require 'csv'
-                first_row=true
-                fields=[]
-                fields_data={}
-                ds=nil
-                line_number=0
-                
-                ::CSV.open(filename,'r',fs,rs) do |row|
-                    line_number+=1
-                    if(line_number<=ignore_lines)
-                        #puts "Skip line"
-                        next
-                    end
-                    row.collect!{|c|
-                        c.to_s
-                    }
-                    if first_row
-                        fields=extract_fields(row)
-                        ds=Statsample::Dataset.new(fields)
-                        first_row=false
-                    else
-                        rowa=process_row(row,empty)
-                        ds.add_case(rowa,false)
-                    end
-                end
-                convert_to_scale(ds,fields)
-                ds.update_valid_data
-                ds
-            end
-        # Save a Dataset on a csv file
-        #
-        # USE:
-        #     Statsample::CSV.write(ds,"test_csv.csv")            
-        def write(dataset,filename, convert_comma=false,*opts)
- require 'csv'            
-                writer=::CSV.open(filename,'w',*opts)
-                writer << dataset.fields
-                dataset.each_array{|row|
-                    if(convert_comma)
-                        row.collect!{|v| v.to_s.gsub(".",",")}
-                    end
-                    writer << row
-                }
-                writer.close
-            end
-		end
+        first_row=true
+        fields=[]
+        fields_data={}
+        ds=nil
+        line_number=0
+        
+        ::CSV.open(filename,'r',fs,rs) do |row|
+          line_number+=1
+          if(line_number<=ignore_lines)
+            #puts "Skip line"
+            next
+          end
+          row.collect!{|c|
+          c.to_s
+          }
+          if first_row
+            fields=extract_fields(row)
+            ds=Statsample::Dataset.new(fields)
+            first_row=false
+          else
+            rowa=process_row(row,empty)
+            ds.add_case(rowa,false)
+          end
+        end
+        convert_to_scale(ds,fields)
+        ds.update_valid_data
+        ds
+      end
+      # Save a Dataset on a csv file
+      #
+      # USE:
+      #     Statsample::CSV.write(ds,"test_csv.csv")            
+      def write(dataset,filename, convert_comma=false,*opts)
+        require 'csv'            
+        writer=::CSV.open(filename,'w',*opts)
+        writer << dataset.fields
+        dataset.each_array do |row|
+          if(convert_comma)
+            row.collect!{|v| v.to_s.gsub(".",",")}
+          end
+          writer << row
+        end
+        writer.close
+      end
     end
+  end
 end

data/lib/statsample/converter/csv19.rb

@@ -1,60 +1,57 @@
 module Statsample
-class CSV < SpreadsheetBase
-		class << self
+  class CSV < SpreadsheetBase
+	  class << self
         # Returns a Dataset  based on a csv file
         #
         # USE:
         #     ds=Statsample::CSV.read("test_csv.csv")
-        def read(filename, empty=[''],ignore_lines=0,fs=nil,rs=nil)
+      def read(filename, empty=[''],ignore_lines=0,fs=nil,rs=nil)
         require 'csv'
-                first_row=true
-                fields=[]
-                fields_data={}
-                ds=nil
-                line_number=0
-                opts={}
-                opts[:col_sep]=fs unless fs.nil?
-                opts[:row_sep]=rs unless rs.nil?
-                csv=::CSV.open(filename,'r',opts)
-                
-                csv.each do |row|
-                    line_number+=1
-                    if(line_number<=ignore_lines)
-                        #puts "Skip line"
-                        next
-                    end
-                    row.collect!{|c|
-                        c.to_s
-                    }
-                    if first_row
-                        fields=extract_fields(row)
-                        ds=Statsample::Dataset.new(fields)
-                        first_row=false
-                    else
-                        rowa=process_row(row,empty)
-                        ds.add_case(rowa,false)
-                    end
-                end
-                convert_to_scale(ds,fields)
-                ds.update_valid_data
-                ds
-            end
+        first_row=true
+        fields=[]
+        fields_data={}
+        ds=nil
+        line_number=0
+        opts={}
+        opts[:col_sep]=fs unless fs.nil?
+        opts[:row_sep]=rs unless rs.nil?
+        csv=::CSV.open(filename,'r',opts)
+        csv.each do |row|
+          line_number+=1
+          if(line_number<=ignore_lines)
+            #puts "Skip line"
+            next
+          end
+          row.collect!{|c| c.to_s }
+          if first_row
+            fields=extract_fields(row)
+            ds=Statsample::Dataset.new(fields)
+            first_row=false
+          else
+            rowa=process_row(row,empty)
+            ds.add_case(rowa,false)
+          end
+        end
+        convert_to_scale(ds,fields)
+        ds.update_valid_data
+        ds
+      end
         # Save a Dataset on a csv file
         #
         # USE:
         #     Statsample::CSV.write(ds,"test_csv.csv")            
-        def write(dataset,filename, convert_comma=false,*opts)
-            require 'csv'            
-                writer=::CSV.open(filename,'w',*opts)
-                writer << dataset.fields
-                dataset.each_array{|row|
-                    if(convert_comma)
-                        row.collect!{|v| v.to_s.gsub(".",",")}
-                    end
-                    writer << row
-                }
-                writer.close
-            end
-		end
+      def write(dataset,filename, convert_comma=false,*opts)
+        require 'csv'            
+        writer=::CSV.open(filename,'w',*opts)
+        writer << dataset.fields
+        dataset.each_array do|row|
+          if(convert_comma)
+              row.collect!{|v| v.to_s.gsub(".",",")}
+          end
+          writer << row
+        end
+        writer.close
+      end
     end
+  end
 end

data/lib/statsample/converter/spss.rb

@@ -0,0 +1,47 @@
+module Statsample
+  module SPSS
+    class << self
+      # Export a SPSS Matrix with tetrachoric correlations .
+      #
+      # Use: 
+      #   ds=Statsample::Excel.read("my_data.xls")
+      #   puts Statsample::SPSS.tetrachoric_correlation_matrix(ds)
+      def tetrachoric_correlation_matrix(ds)
+        dsv=ds.dup_only_valid
+        # Delete all vectors doesn't have variation
+        dsv.fields.each{|f|
+          if dsv[f].factors.size==1
+            dsv.delete_vector(f) 
+          else
+            dsv[f]=dsv[f].dichotomize
+          end
+        }
+        tcm=Statsample::Bivariate.tetrachoric_correlation_matrix(dsv)
+        n=dsv.fields.collect {|f|
+          sprintf("%d",dsv[f].size)
+        }
+        meanlist=dsv.fields.collect{|f|
+          sprintf("%0.3f", dsv[f].mean)
+        }
+        stddevlist=dsv.fields.collect{|f|
+          sprintf("%0.3f", dsv[f].sd)
+        }
+        out=<<-HEREDOC
+MATRIX DATA VARIABLES=ROWTYPE_ #{dsv.fields.join(",")}.
+BEGIN DATA
+N #{n.join(" ")}
+MEAN	#{meanlist.join(" ")}
+STDDEV #{stddevlist.join(" ")}
+HEREDOC
+tcm.row_size.times {|i|
+  out +="CORR "
+  (i+1).times {|j|
+    out+=sprintf("%0.3f",tcm[i,j])+" "
+  }
+  out +="\n"
+}
+out+="END DATA.\nEXECUTE.\n"
+      end
+    end
+  end
+end