statsample-ekatena 2.0.2

data/lib/statsample-ekatena/histogram.rb

@@ -0,0 +1,180 @@
+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
+    include Enumerable
+
+    class << self
+      # Alloc +n_bins+, using +range+ as ranges of bins
+      def alloc(n_bins, range=nil, opts=Hash.new)
+        Histogram.new(n_bins, range, opts)
+        
+      end
+      # Alloc +n_bins+ bins, using +p1+ as minimum and +p2+
+      # as maximum
+      def alloc_uniform(n_bins, p1=nil,p2=nil)
+        if p1.is_a? Array
+          min,max=p1
+        else
+          min,max=p1,p2
+        end
+        range=max - min
+        step=range / n_bins.to_f
+        range=(n_bins+1).times.map {|i| min + (step*i)}
+        Histogram.new(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
+
+    # Number of bins
+    def bins
+      @n_bins
+    end
+    
+    def increment(x, w=1)
+      if x.respond_to? :each
+        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 get_range(i)
+      [@range[i],@range[i+1]]
+    end
+
+    def max
+      @range.last
+    end
+    
+    def min
+      @range.first
+    end
+    def max_val
+      @bin.max
+    end
+    def min_val
+      @bin.min
+    end
+    def each
+      bins.times.each do |i|
+        r=get_range(i)
+        arg={:i=>i, :low=>r[0],:high=>r[1], :middle=>(r[0]+r[1]) / 2.0,  :value=>@bin[i]}
+        yield arg
+      end
+    end
+    def estimated_variance
+      sum,n=0,0
+      mean=estimated_mean
+      each do |v|
+        sum+=v[:value]*(v[:middle]-mean)**2
+        n+=v[:value]
+      end
+      sum / (n-1)
+    end
+    def estimated_standard_deviation
+      Math::sqrt(estimated_variance)
+    end
+    def estimated_mean
+      sum,n=0,0
+      each do |v|
+        sum+= v[:value]* v[:middle]
+        n+=v[:value]
+      end
+      sum / n
+    end
+    alias :mean :estimated_mean
+    alias :sigma :estimated_standard_deviation
+    
+    def sum(start=nil,_end=nil)
+      start||=0
+      _end||=@n_bins-1
+      (start.._end).inject(0) {|ac,i| ac+@bin[i]}
+    end
+    def report_building(generator)
+      hg=Statsample::Graph::Histogram.new(self)
+      generator.parse_element(hg)
+    end
+    def report_building_text(generator)
+      @range.each_with_index do |r,i|
+        next if i==@bin.size
+        generator.text(sprintf("%5.2f : %d", r, @bin[i]))
+      end
+    end
+  end
+end

data/lib/statsample-ekatena/matrix.rb

@@ -0,0 +1,329 @@
+class ::Vector
+  def to_matrix
+    ::Matrix.columns([self.to_a])
+  end
+  def to_vector
+    self
+  end
+end
+class ::Matrix
+  def to_matrix
+    self
+  end
+
+  def to_dataframe
+    f = (self.respond_to? :fields_y) ? fields_y : column_size.times.map {|i| "VAR_#{i+1}".to_sym }
+    f = [f] unless f.is_a?(Array)
+    ds = Daru::DataFrame.new({}, order: f)
+    f.each do |ff|
+      ds[ff].rename ff
+    end
+    row_size.times {|i|
+      ds.add_row(self.row(i).to_a)
+    }
+    ds.rename(self.name) if self.respond_to? :name
+    ds
+  end
+
+  alias :to_dataset :to_dataframe
+
+  if defined? :eigenpairs
+    alias_method :eigenpairs_ruby, :eigenpairs
+  end
+
+  if Statsample.has_gsl?
+    # Optimize eigenpairs of extendmatrix module using gsl
+    def eigenpairs
+      to_gsl.eigenpairs
+    end
+  end
+
+  def eigenvalues
+    eigenpairs.collect {|v| v[0]}
+  end
+
+  def eigenvectors
+    eigenpairs.collect {|v| v[1]}
+  end
+
+  def eigenvectors_matrix
+    Matrix.columns(eigenvectors)
+  end
+
+  def to_gsl
+    out=[]
+    self.row_size.times{|i|
+      out[i]=self.row(i).to_a
+    }
+    GSL::Matrix[*out]
+  end
+
+  def []=(i, j, x)
+    @rows[i][j] = x
+  end
+end
+
+module GSL
+  class Vector
+    class Col
+      def to_matrix
+      ::Matrix.columns([self.size.times.map {|i| self[i]}])
+      end
+
+      def to_ary
+        to_a
+      end
+
+      def to_gsl
+        self
+      end
+    end
+  end
+  class Matrix
+    def to_gsl
+      self
+    end
+
+    def to_dataframe
+      f = (self.respond_to? :fields_y) ? fields_y : column_size.times.map { |i| "VAR_#{i+1}".to_sym }
+      ds=Daru::DataFrame.new({}, order: f)
+      f.each do |ff|
+        ds[ff].rename ff
+      end
+
+      row_size.times {|i|
+        ds.add_row(self.row(i).to_a)
+      }
+      ds.rename(self.name) if self.respond_to? :name
+      ds
+    end
+
+    alias :to_dataset :to_dataframe
+
+    def row_size
+      size1
+    end
+
+    def column_size
+      size2
+    end
+
+    def determinant
+      det
+    end
+
+    def inverse
+      GSL::Linalg::LU.invert(self)
+    end
+
+    def eigenvalues
+      eigenpairs.collect {|v| v[0]}
+    end
+
+    def eigenvectors
+      eigenpairs.collect {|v| v[1]}
+    end
+
+    # Matrix sum of squares
+    def mssq
+      sum=0
+      to_v.each {|i| sum+=i**2}
+      sum
+    end
+
+    def eigenvectors_matrix
+      eigval, eigvec= GSL::Eigen.symmv(self)
+      GSL::Eigen::symmv_sort(eigval, eigvec, GSL::Eigen::SORT_VAL_DESC)
+      eigvec
+    end
+
+    def eigenpairs
+      eigval, eigvec= GSL::Eigen.symmv(self)
+      GSL::Eigen::symmv_sort(eigval, eigvec, GSL::Eigen::SORT_VAL_DESC)
+      @eigenpairs=eigval.size.times.map {|i|
+        [eigval[i],eigvec.get_col(i)]
+      }
+    end
+
+    #def eigenpairs_ruby
+    #  self.to_matrix.eigenpairs_ruby
+    #end
+    def square?
+      size1==size2
+    end
+
+    def to_matrix
+      rows=self.size1
+      cols=self.size2
+      out=(0...rows).collect{|i| (0...cols).collect {|j| self[i,j]} }
+      ::Matrix.rows(out)
+    end
+    
+    def total_sum
+      sum=0
+      size1.times {|i|
+        size2.times {|j|
+          sum+=self[i,j]
+        }
+      }
+      sum
+    end
+  end
+end
+
+module Statsample
+  # Module to add names to X and Y fields
+  module NamedMatrix
+    include Summarizable
+
+    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
+    @fields_x||=row_size.times.collect {|i| _("X%d") % i}
+    end
+    def fields_y
+    @fields_y||=column_size.times.collect {|i| _("Y%d") % i}
+    end
+
+    def name
+      @name||=get_new_name
+    end
+    def name=(v)
+      @name=v
+    end
+    def get_new_name
+      @@named_matrix||=0
+      @@named_matrix+=1
+      _("Matrix %d") % @@named_matrix
+    end
+
+  end
+  # Module to add method for variance/covariance and correlation matrices
+  # == Usage
+  #  matrix=Matrix[[1,2],[2,3]]
+  #  matrix.extend CovariateMatrix
+  #
+  module CovariateMatrix
+    include NamedMatrix
+    @@covariatematrix=0
+
+    # Get type of covariate matrix. Could be :covariance or :correlation
+    def _type
+      if row_size==column_size
+        if row_size.times.find {|i| self[i,i]!=1.0}
+          :covariance
+        else
+          :correlation
+        end
+      else
+        @type
+      end
+
+    end
+    def _type=(t)
+      @type=t
+    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
+
+
+    # Get variance for field k
+    #
+    def variance(k)
+      submatrix([k])[0,0]
+    end
+
+    def get_new_name
+      @@covariatematrix+=1
+      _("Covariate matrix %d") % @@covariatematrix
+    end
+
+    # Select a submatrix of factors. If you have a correlation matrix
+    # with a, b and c, you could obtain a submatrix of correlations of
+    # a and b, b and c or a and b
+    #
+    # You could use labels or index to select the factors.
+    # If you don't specify columns, its 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.extend CovariateMatrix
+    #   a.fields=%w{a b c}
+    #   a.submatrix(%w{c a}, %w{b})
+    #   => Matrix[[0.5],[0.3]]
+    #   a.submatrix(%w{c a})
+    #   => Matrix[[1.0, 0.2] , [0.2, 1.0]]
+    def submatrix(rows,columns = nil)
+      raise ArgumentError, "rows shouldn't be empty" if rows.respond_to? :size and rows.size == 0
+      columns ||= rows
+      # Convert all fields on index
+      row_index = rows.collect do |v|
+        r = v.is_a?(Numeric) ? v : fields_x.index(v)
+        raise "Index #{v} doesn't exists on matrix" if r.nil?
+        r
+      end
+
+      column_index = columns.collect do |v|
+        r = v.is_a?(Numeric) ? v : fields_y.index(v)
+        raise "Index #{v} doesn't exists on matrix" if r.nil?
+        r
+      end
+
+
+      fx=row_index.collect {|v| fields_x[v]}
+      fy=column_index.collect {|v| fields_y[v]}
+
+      matrix = Matrix.rows(row_index.collect { |i| column_index.collect { |j| self[i, j] }})
+      matrix.extend CovariateMatrix
+      matrix.fields_x = fx
+      matrix.fields_y = fy
+      matrix._type = _type
+      matrix
+    end
+    def report_building(generator)
+      @name||= (_type==:correlation ? _("Correlation"):_("Covariance"))+_(" Matrix")
+      generator.table(:name=>@name, :header=>[""]+fields_y) do |t|
+        row_size.times {|i|
+          t.row([fields_x[i]]+row(i).to_a.collect {|i1|
+              i1.nil? ? "--" : sprintf("%0.3f",i1).gsub("0.",".")
+          })
+        }
+      end
+    end
+  end
+end