statsample 0.5.1 → 0.6.0

data/lib/statsample/factor/pca.rb

@@ -0,0 +1,128 @@
+module Statsample
+module Factor
+  # Principal Component Analysis of a given covariance or correlation matrix. 
+  # For factorial Analysis, use Statsample::Factor::PrincipalAxis
+  # Reference: SPSS manual
+  #   Use:
+  #   a=[2.5, 0.5, 2.2, 1.9, 3.1, 2.3, 2.0, 1.0, 1.5, 1.1].to_scale
+  #   b=[2.4,0.7,2.9,2.2,3.0,2.7,1.6,1.1,1.6,0.9].to_scale
+  #   ds={'a'=>a,'b'=>b}.to_dataset
+  #   cor_matrix=Statsample::Bivariate.correlation_matrix(ds)
+  #   pca=Statsample::Factor::PCA.new(cor_matrix)
+  #   p pca.component_matrix
+  class PCA
+    attr_accessor :name, :m
+    include GetText
+    bindtextdomain("statsample")
+    
+    
+    def initialize(matrix ,opts=Hash.new)
+      if matrix.is_a? ::Matrix
+        require 'matrix_extension'
+        matrix=matrix.to_gsl
+      end
+      @name=""
+      @matrix=matrix
+      @n_variables=@matrix.size1
+      @m=nil
+      opts.each{|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+      }
+      calculate_eigenpairs
+      if @m.nil?
+        # Set number of factors with eigenvalues > 1
+        @m=@eigenpairs.find_all {|v| v[0]>=1.0}.size
+      end
+
+    end
+    def create_centered_ds
+      h={}
+      @original_ds.factors.each {|f|
+        mean=@original_ds[f].mean
+        h[f]=@original_ds[f].recode {|c| c-mean}
+      }
+      @ds=h.to_dataset
+    end
+    # Feature vector for m factors
+    def feature_vector(m=nil)
+      m||=@m
+      omega_m=GSL::Matrix.zeros(@n_variables, m)
+      m.times do |i|
+        omega_m.set_col(i, @eigenpairs[i][1])
+      end
+      omega_m
+    end
+    # data_transformation
+    def data_transformation(data_matrix, m)
+      m||=@m
+      raise "Data variables number should be equal to original variable number" if data_matrix.size2!=@n_variables
+      fv=feature_vector(m)
+      (fv.transpose*data_matrix.transpose).transpose
+    end
+    # Component matrix for m factors
+    def component_matrix(m=nil)
+      m||=@m
+      raise "m should be > 0" if m<1
+      omega_m=GSL::Matrix.zeros(@n_variables, m)
+      gammas=[]
+      m.times {|i|
+        omega_m.set_col(i, @eigenpairs[i][1])
+        gammas.push(Math::sqrt(@eigenpairs[i][0]))
+      }
+      gamma_m=GSL::Matrix.diagonal(gammas)
+      omega_m*(gamma_m)
+    end
+    # Communality for all variables given m factors
+    def communality(m=nil)
+      m||=@m
+      h=[]
+      @n_variables.times do |i|
+        sum=0
+        m.times do |j|
+          sum+=@eigenpairs[j][0].abs*@eigenpairs[j][1][i]**2
+        end
+        h.push(sum)
+      end
+      h
+    end
+    def eigenvalues
+      @eigenpairs.collect {|c| c[0] }
+    end
+    def calculate_eigenpairs
+      eigval, eigvec= GSL::Eigen.symmv(@matrix)
+      @eigenpairs={}
+      eigval.each_index {|i|
+        @eigenpairs[eigval[i]]=eigvec.get_col(i)
+      }
+      @eigenpairs=@eigenpairs.sort.reverse
+    end
+    def to_reportbuilder(generator)
+      anchor=generator.add_toc_entry(_("PCA: ")+name)
+      generator.add_html "<div class='pca'>"+_("PCA")+" #{@name}<a name='#{anchor}'></a>"
+
+      generator.add_text "Number of factors: #{m}"
+      t=ReportBuilder::Table.new(:name=>_("Communalities"), :header=>["Variable","Initial","Extraction"])
+      communality(m).each_with_index {|com,i|
+        t.add_row([i, 1.0, sprintf("%0.3f", com)])
+      }
+      generator.parse_element(t)
+      
+      t=ReportBuilder::Table.new(:name=>_("Eigenvalues"), :header=>["Variable","Value"])
+      eigenvalues.each_with_index {|eigenvalue,i|
+        t.add_row([i, sprintf("%0.3f",eigenvalue)])
+      }
+      generator.parse_element(t)
+      
+      t=ReportBuilder::Table.new(:name=>_("Component Matrix"), :header=>["Variable"]+m.times.collect {|c| c+1})
+      
+      i=0
+      component_matrix(m).to_a.each do |row|
+        t.add_row([i]+row.collect {|c| sprintf("%0.3f",c)})
+        i+=1
+      end
+      generator.parse_element(t)
+      generator.add_html("</div>")
+    end
+  end
+end
+end

data/lib/statsample/factor/principalaxis.rb

@@ -0,0 +1,133 @@
+module Statsample
+module Factor
+  class PrincipalAxis
+    MIN_CHANGE_ESTIMATE=0.0001
+    include GetText
+    bindtextdomain("statsample")
+    attr_accessor :m, :name
+    
+    attr_reader :iterations, :initial_eigenvalues
+    def initialize(matrix ,opts=Hash.new)
+      @matrix=matrix
+      @name=""
+      @m=nil
+      opts.each{|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+      }
+      @clean=true
+    end
+    def communality(m)
+      if m!=@m or @clean
+        iterate(m)
+        raise "Can't calculate comunnality" if @communality.nil?
+      end
+      @communality
+    end
+    def component_matrix(m)
+      if m!=@m  or @clean
+        iterate(m)
+      end
+      @component_matrix
+    end
+
+    def iterate(m, t=25)
+      @clean=false
+      @m=m
+      work_matrix=@matrix.to_a
+      prev_com=initial_communalities
+      pca=PCA.new(::Matrix.rows(work_matrix))
+      @initial_eigenvalues=pca.eigenvalues
+      @iterations=0
+      t.times do |i|
+        @iterations+=1
+        prev_com.each_with_index{|v,i|
+          work_matrix[i][i]=v
+        }
+        pca=Statsample::PCA.new(::Matrix.rows(work_matrix))
+        
+        @communality=pca.communality(m)
+        jump=true
+        @communality.each_with_index do |v2,i2|
+          raise "Variable #{i2} with communality > 1" if v2>1.0
+          #p (v2-prev_com[i2]).abs
+          jump=false if (v2-prev_com[i2]).abs>=MIN_CHANGE_ESTIMATE
+        end
+        break if jump
+        prev_com=@communality
+      end
+      @component_matrix=pca.component_matrix(m)
+    end
+    
+    
+    def initial_communalities
+      if @initial_communalities.nil?
+        @initial_communalities=@matrix.column_size.times.collect {|i|
+          rxx , rxy = FactorialAnalysis.separate_matrices(@matrix,i)
+          matrix=(rxy.t*rxx.inverse*rxy)
+          matrix[0,0]
+        }
+      end      
+      @initial_communalities
+    end
+    # Returns two matrixes from a correlation matrix
+    # with regressors correlation matrix and criteria xy
+    # matrix.
+    def self.separate_matrices(matrix, y)
+      ac=[]
+      matrix.column_size.times do |i|
+        ac.push(matrix[y,i]) if i!=y
+      end
+      rxy=Matrix.columns([ac])
+      rows=[]
+      matrix.row_size.times do |i|
+        if i!=y
+          row=[]
+          matrix.row_size.times do |j|
+            row.push(matrix[i,j]) if j!=y
+          end
+          rows.push(row)
+        end
+      end
+      rxx=Matrix.rows(rows)
+      [rxx,rxy]
+    end
+    
+    
+    def to_reportbuilder(generator)
+      anchor=generator.add_toc_entry(_("Factor Analysis: ")+name)
+      generator.add_html "<div class='pca'>"+_("Factor Analysis")+" #{@name}<a name='#{anchor}'></a>"
+      if @m.nil?
+        # Set number of factors with eigenvalues > 1
+        m=@eigenpairs.find_all {|v| v[0]>=1.0}.size
+      else
+        m=@m
+      end
+      generator.add_text "Number of factors: #{m}"
+      t=ReportBuilder::Table.new(:name=>_("Communalities"), :header=>["Variable","Initial","Extraction"])
+      communality(m).each_with_index {|com,i|
+        t.add_row([i, sprintf("%0.3f", initial_communalities[i]), sprintf("%0.3f", com)])
+      }
+      generator.parse_element(t)
+      
+      t=ReportBuilder::Table.new(:name=>_("Eigenvalues"), :header=>["Variable","Value"])
+      @initial_eigenvalues.each_with_index {|eigenvalue,i|
+        t.add_row([i, sprintf("%0.3f",eigenvalue)])
+      }
+      generator.parse_element(t)
+      
+      t=ReportBuilder::Table.new(:name=>_("Component Matrix"), :header=>["Variable"]+m.times.collect {|c| c+1})
+      
+      i=0
+      component_matrix(m).to_a.each do |row|
+        t.add_row([i]+row.collect {|c| sprintf("%0.3f",c)})
+        i+=1
+      end
+      generator.parse_element(t)
+      generator.add_html("</div>")
+    end
+    
+    
+  end
+  
+end
+end

data/lib/statsample/factor/rotation.rb

@@ -0,0 +1,125 @@
+module Statsample
+module Factor
+  # Base class for rotate matrixes
+  # References: 
+  # * SPSS Manual
+  # * Johnny Lin code for IDL: http://www.johnny-lin.com/idl_code/varimax_k58.pro
+  # Use Varimax, Equimax or Quartimax for desired type of rotation
+  #   Use:
+  #   a = Matrix[ [ 0.4320,  0.8129,  0.3872] 
+  #     , [ 0.7950, -0.5416,  0.2565]  
+  #     , [ 0.5944,  0.7234, -0.3441]  
+  #     , [ 0.8945, -0.3921, -0.1863] ]
+  #   rotation = Statsample::Factor::Varimax(a)
+  #   rotation.iterate
+  #   p rotation.rotated
+  #   p rotation.component_transformation_matrix
+  # 
+  class Rotation
+    MAX_PRECISION=1e-15
+    attr_reader :iterations, :rotated, :component_transformation_matrix, :h2
+    def initialize(matrix, opts=Hash.new)
+      @matrix=matrix
+      @n=@matrix.row_size # Variables, p on original
+      @m=@matrix.column_size # Factors, r on original
+      @component_transformation_matrix=nil
+      @h2=(@matrix.collect {|c| c**2} * Matrix.column_vector([1]*@m)).column(0).to_a
+    end
+    alias_method :communalities, :h2
+    alias_method :rotated_component_matrix, :rotated
+    # Start iteration of 
+    def iterate(max_i=25)
+      t=Matrix.identity(@m)
+      b=@matrix.dup
+      h=Matrix.diagonal(*@h2).collect {|c| Math::sqrt(c)}
+      h_inverse=h.collect {|c| c!=0 ? 1/c : 0 }
+      bh=h_inverse*b
+      @not_converged=true
+      @iterations=0
+      while @not_converged
+        break if iterations>max_i 
+        @iterations+=1
+        #puts "Iteration #{iterations}"
+        num_pairs=@m*(@m-1).quo(2)
+        (0..(@m-2)).each do |i| #+ go through factor index 0:r-1-1 (begin)
+          ((i+1)..(@m-1)).each do |j| #+ pair i to "rest" of factors (begin)
+            
+            xx = bh.column(i)
+            yy = bh.column(j)
+            tx = t.column(i)
+            ty = t.column(j)
+            
+            uu = @n.times.collect {|var_i| xx[var_i]**2-yy[var_i]**2}
+            vv = @n.times.collect {|var_i| 2*xx[var_i]*yy[var_i]}
+            
+            a  = @n.times.inject(0) {|ac,var_i| ac+ uu[var_i] }
+            b  = @n.times.inject(0) {|ac,var_i| ac+ vv[var_i] }
+            c  = @n.times.inject(0) {|ac,var_i| ac+ (uu[var_i]**2 - vv[var_i]**2) }
+            d  = @n.times.inject(0) {|ac,var_i| ac+ (2*uu[var_i]*vv[var_i]) }
+            num=x(a,b,c,d)
+            den=y(a,b,c,d)
+            phi=Math::atan2(num,den) / 4.0
+            # puts "#{i}-#{j}: #{phi}"
+            
+            if(Math::sin(phi.abs) >= MAX_PRECISION)
+              xx_rot=( Math::cos(phi)*xx)+(Math::sin(phi)*yy)
+              yy_rot=((-Math::sin(phi))*xx)+(Math::cos(phi)*yy)
+              
+              
+              tx_rot=( Math::cos(phi)*tx)+(Math::sin(phi)*ty)
+              ty_rot=((-Math::sin(phi))*tx)+(Math::cos(phi)*ty)
+
+              
+              bh=bh.to_a
+
+              @n.times {|row_i|
+                bh[row_i][i] = xx_rot[row_i]
+                bh[row_i][j] = yy_rot[row_i]
+              }
+              t=t.to_a
+              @m.times {|row_i|
+                t[row_i][i]=tx_rot[row_i]
+                t[row_i][j]=ty_rot[row_i]
+              }
+              
+              bh=Matrix.rows(bh)
+              t=Matrix.rows(t)
+            else
+              num_pairs=num_pairs-1
+              @not_converged=false if num_pairs==0
+            end # if
+          end #j
+        end #i
+      end # while
+      @rotated=h*bh
+      @component_transformation_matrix=t
+      @rotated
+    end
+
+  end
+  class Varimax < Rotation
+    def x(a,b,c,d)
+      d-(2*a*b / @n.to_f)
+    end
+    def y(a,b,c,d)
+      c-((a**2-b**2) / @n.to_f)
+    end
+  end
+  class Equimax < Rotation
+    def x(a,b,c,d)
+      d-(@m*a*b / @n.to_f)
+    end
+    def y(a,b,c,d)
+      c-@m*((a**2-b**2) / (2*@n.to_f))
+    end
+  end
+  class Quartimax < Rotation
+    def x(a,b,c,d)
+      d
+    end
+    def y(a,b,c,d)
+      c
+    end
+  end
+end
+end

data/lib/statsample/histogram.rb

@@ -0,0 +1,99 @@
+module Statsample
+  # A histogram consists of a set of bins which count the 
+  # number of events falling into a given range of a continuous variable x. 
+  # 
+  # This implementations follows convention of GSL
+  # for specification.
+  # 
+  #  * Verbatim: *
+  #
+  #  The range for bin[i] is given by range[i] to range[i+1]. 
+  #  For n bins there are n+1 entries in the array range. 
+  #  Each bin is inclusive at the lower end and exclusive at the upper end. 
+  #  Mathematically this means that the bins are defined 
+  #  by the following inequality,
+  # 
+  #   bin[i] corresponds to range[i] <= x < range[i+1]
+  # 
+  #  Here is a diagram of the correspondence between ranges and bins
+  #  on the number-line for x,
+  # 
+  # 
+  #      [ bin[0] )[ bin[1] )[ bin[2] )[ bin[3] )[ bin[4] )
+  #   ---|---------|---------|---------|---------|---------|---  x
+  #    r[0]      r[1]      r[2]      r[3]      r[4]      r[5]
+  # 
+  # 
+  #  In this picture the values of the range array are denoted by r. 
+  #  On the left-hand side of each bin the square bracket ‘[’ denotes 
+  #  an inclusive lower bound ( r <= x), and the round parentheses ‘)’ 
+  #  on the right-hand side denote an exclusive upper bound (x < r). 
+  #  Thus any samples which fall on the upper end of the histogram are 
+  #  excluded. 
+  #  If you want to include this value for the last bin you will need to 
+  #  add an extra bin to your histogram. 
+  #
+  #
+  # Reference:
+  # http://www.gnu.org/software/gsl/manual/html_node/The-histogram-struct.html
+  
+    class Histogram
+      class << self
+        def alloc(n_bins, range=nil, opts=Hash.new)
+          Histogram.new(n_bins, range)
+          
+        end
+      end
+      attr_accessor :name
+      attr_reader :bin
+      attr_reader :range
+      include GetText
+      bindtextdomain("statsample")
+      def initialize(p1, min_max=false, opts=Hash.new)
+        
+        if p1.is_a? Array
+          range=p1
+          n_bins=p1.size-1
+        elsif p1.is_a? Integer
+          n_bins=p1
+        end
+        
+        @bin=[0.0]*(n_bins)
+        if(min_max)
+          min, max=min_max[0], min_max[1]
+          range=Array.new(n_bins+1)
+          (n_bins+1).times {|i| range[i]=min+(i*(max-min).quo(n_bins)) }
+        end
+        range||=[0.0]*(n_bins+1)
+        set_ranges(range)
+        @name=""
+        opts.each{|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+        }
+      end
+      
+      def increment(x, w=1)
+        if x.is_a? Array
+          x.each{|y| increment(y,w) }
+        elsif x.is_a? Numeric
+          (range.size-1).times do |i|
+            if x>=range[i] and x<range[i+1]
+              @bin[i]+=w
+              break
+            end
+          end
+        end
+      end
+      def set_ranges(range)
+        raise "Range size should be bin+1" if range.size!=@bin.size+1
+        @range=range
+      end
+      def to_reportbuilder_text(generator)
+        anchor=generator.add_toc_entry(_("Histogram %s") % [@name])
+        range.each_with_index do |r,i|
+          next if i==@bin.size
+          generator.add_text(sprintf("%4.2f : %d", r, @bin[i]))
+        end
+      end
+    end
+end