statsample 1.5.0 → 2.0.0

data/lib/statsample/graph/histogram.rb

@@ -6,10 +6,10 @@ module Statsample
     # 
     # == Usage
     # === Svg output
-    #  a=[1,2,3,4].to_numeric
-    #  puts Statsample::Graph::Histogram.new(a).to_svg
+    # a = Daru::Vector.new([1,2,3,4])
+    # puts Statsample::Graph::Histogram.new(a).to_svg
     # === Using ReportBuilder
-    #  a=[1,2,3,4].to_numeric
+    #  a = Daru::Vector.new([1,2,3,4])
     #  rb=ReportBuilder.new
     #  rb.add(Statsample::Graph::Histogram.new(a))
     #  rb.save_html('histogram.html')
@@ -70,7 +70,7 @@ module Statsample
           @hist=@data
           @mean=@hist.estimated_mean
           @sd=@hist.estimated_standard_deviation
-        elsif @data.is_a? Statsample::Vector
+        elsif @data.is_a? Daru::Vector
           @mean=@data.mean
           @sd=@data.sd
           @bins||=Math::sqrt(@data.size).floor

data/lib/statsample/graph/scatterplot.rb

@@ -10,12 +10,12 @@ module Statsample
     # The data is displayed as a collection of points, each having the value of one variable determining the position on the horizontal axis and the value of the other variable determining the position on the vertical axis.[2] This kind of plot is also called a scatter chart, scatter diagram and scatter graph.
     # == Usage
     # === Svg output
-    #  a=[1,2,3,4].to_numeric
-    #  b=[3,4,5,6].to_numeric
+    #  a = Daru::Vector.new([1,2,3,4])
+    #  b = Daru::Vector.new([3,4,5,6])
     #  puts Statsample::Graph::Scatterplot.new(a,b).to_svg
     # === Using ReportBuilder
-    #  a=[1,2,3,4].to_numeric
-    #  b=[3,4,5,6].to_numeric
+    #  a = Daru::Vector.new([1,2,3,4])
+    #  b = Daru::Vector.new([3,4,5,6])
     #  rb=ReportBuilder.new
     #  rb.add(Statsample::Graph::Scatterplot.new(a,b))
     #  rb.save_html('scatter.html')
@@ -195,17 +195,18 @@ module Statsample
         end
         vis
       end
+
       # Returns SVG with scatterplot
       def to_svg
-        rp=rubyvis_panel
+        rp = rubyvis_panel
         rp.render
         rp.to_svg
       end
+
       def report_building(builder) # :nodoc:
         builder.section(:name=>name) do |b|
           b.image(to_svg, :type=>'svg', :width=>width, :height=>height)
-        end
-        
+        end       
       end
     end
   end

data/lib/statsample/histogram.rb

@@ -37,135 +37,144 @@ module Statsample
   # == 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)
+  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
-          range=p1
-          @n_bins=p1.size-1
-        elsif p1.is_a? Integer
-          @n_bins=p1
+          min,max=p1
+        else
+          min,max=p1,p2
         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
-        }
+        range=max - min
+        step=range / n_bins.to_f
+        range=(n_bins+1).times.map {|i| min + (step*i)}
+        Histogram.new(range)
       end
-      # Number of bins
-      def bins
-        @n_bins
+    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
-      # 
-      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
+      
+      @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
-      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 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
-      def report_building(generator)
-        hg=Statsample::Graph::Histogram.new(self)
-        generator.parse_element(hg)
+    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
-      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
+      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/matrix.rb

@@ -11,21 +11,23 @@ class ::Matrix
     self
   end
 
-  def to_dataset
-    f = (self.respond_to? :fields_y) ? fields_y : column_size.times.map {|i| _("VAR_%d") % (i+1) }
-    ds=Statsample::Dataset.new(f)
+  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].type=:numeric
-      ds[ff].name=ff
+      ds[ff].rename ff
     end
     row_size.times {|i|
-      ds.add_case_array(self.row(i).to_a)
+      ds.add_row(self.row(i).to_a)
     }
-    ds.update_valid_data
-    ds.name=self.name if self.respond_to? :name
+    ds.update
+    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
@@ -83,21 +85,23 @@ module GSL
       self
     end
 
-    def to_dataset
-      f = (self.respond_to? :fields_y) ? fields_y : column_size.times.map {|i| _("VAR_%d") % (i+1) }
-      ds=Statsample::Dataset.new(f)
+    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].type=:numeric
-        ds[ff].name=ff
+        ds[ff].rename ff
       end
+
       row_size.times {|i|
-        ds.add_case_array(self.row(i).to_a)
+        ds.add_row(self.row(i).to_a)
       }
-      ds.update_valid_data
-      ds.name=self.name if self.respond_to? :name
+      ds.update
+      ds.rename(self.name) if self.respond_to? :name
       ds
     end
 
+    alias :to_dataset :to_dataframe
+
     def row_size
       size1
     end

data/lib/statsample/multiset.rb

@@ -5,20 +5,21 @@ module Statsample
   class Multiset
     # Name of fields
     attr_reader :fields
-    # Array with Statsample::Dataset
+    # Array with Daru::DataFrame
     attr_reader :datasets
     # To create a multiset
     # * Multiset.new(%w{f1 f2 f3}) # define only fields
     def initialize(fields)
-        @fields=fields
-        @datasets={}
+      @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
+      ms = Multiset.new(fields)
+      ds_names.each do |d|
+        ms.add_dataset(d, Daru::DataFrame.new({}, order: fields))
+      end
+
+      ms
     end
     # Generate a new dataset as a union of partial dataset
     # If block given, this is applied to each dataset before union
@@ -29,65 +30,65 @@ module Statsample
       labels={}
       each do |k,ds|
         if block
-          ds=ds.dup
+          ds = ds.dup
           yield k,ds
         end
         @fields.each do |f|
-          union_field[f]||=Array.new
-          union_field[f].concat(ds[f].data)
-          types[f]||=ds[f].type
-          names[f]||=ds[f].name
-          labels[f]||=ds[f].labels
+          union_field[f] ||= Array.new
+          union_field[f].concat(ds[f].to_a)
+          types[f]  ||= ds[f].type
+          names[f]  ||= ds[f].name
+          labels[f] ||= ds[f].index.to_a
         end
       end
       
       @fields.each do |f|
-        union_field[f]=union_field[f].to_vector(types[f])
-        union_field[f].name=names[f]
-        union_field[f].labels=labels[f]
+        union_field[f] = Daru::Vector.new(union_field[f])
+        union_field[f].rename names[f]
       end
-      ds_union=union_field.to_dataset
-      ds_union.fields=@fields
+
+      ds_union = Daru::DataFrame.new(union_field, order: @fields)
       ds_union
     end
+
     def datasets_names
-        @datasets.keys.sort
+      @datasets.keys.sort
     end
+
     def n_datasets
-        @datasets.size
+      @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})"
+      if ds.vectors.to_a != @fields
+        raise ArgumentError, "Dataset(#{ds.vectors.to_a.to_s})must have the same fields of the Multiset(#{@fields})"
       else
-          @datasets[key]=ds
+        @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
+        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]
-      }
+      @datasets.collect { |k,v| yield k, v[field] }
     end
     
     def each_vector(field)
-      @datasets.each {|k,v|
-        yield k, v[field]
-      }
+      @datasets.each { |k,v| yield k, v[field] }
     end
-    def[](i)
+
+    def [](i)
       @datasets[i]
     end
+
     def each(&block)
       @datasets.each {|k,ds|
-        next if ds.cases==0
+        next if ds.nrows == 0
         block.call(k,ds)
       }
     end
@@ -204,9 +205,9 @@ module Statsample
       @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]}
+      @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}
+      @sample_size=@ms.datasets.inject(0) { |a,x| a+x[1].nrows }
     end
     # Number of strata
     def strata_number