statsample-ekatena 2.0.2

data/lib/statsample-ekatena/analysis.rb

@@ -0,0 +1,100 @@
+require 'statsample/analysis/suite'
+require 'statsample/analysis/suitereportbuilder'
+
+module Statsample
+  # DSL to create analysis without hazzle. 
+  # * Shortcuts methods to avoid use complete namescapes, many based on R  
+  # * Attach/detach vectors to workspace, like R
+  # == Example
+  #  an1=Statsample::Analysis.store(:first) do
+  #    # Load excel file with x,y,z vectors
+  #    ds=excel('data.xls')
+  #    # See variables on ds dataset
+  #    names(ds) 
+  #    # Attach the vectors to workspace, like R
+  #    attach(ds)
+  #    # vector 'x' is attached to workspace like a method,
+  #    # so you can use like any variable
+  #    mean,sd=x.mean, x.sd 
+  #    # Shameless R robbery
+  #    a=c( 1:10)
+  #    b=c(21:30)
+  #    summary(cor(ds)) # Call summary method on correlation matrix
+  #  end
+  #  # You can run the analysis by its name
+  #  Statsample::Analysis.run(:first)
+  #  # or using the returned variables
+  #  an1.run
+  #  # You can also generate a report using ReportBuilder.
+  #  # .summary() method call 'report_building' on the object, 
+  #  # instead of calling text summary
+  #  an1.generate("report.html")
+  module Analysis
+    @@stored_analysis={}
+    @@last_analysis=nil
+    def self.clear_analysis
+      @@stored_analysis.clear
+    end
+    def self.stored_analysis
+      @@stored_analysis
+    end
+    def self.last
+      @@stored_analysis[@@last_analysis]
+    end
+    def self.store(name, opts=Hash.new,&block)
+      raise "You should provide a block" if !block
+      @@last_analysis=name
+      opts={:name=>name}.merge(opts)
+      @@stored_analysis[name]=Suite.new(opts,&block)
+    end
+    # Run analysis +*args+
+    # Without arguments, run all stored analysis
+    # Only 'echo' will be returned to screen
+    def self.run(*args)
+      args=stored_analysis.keys if args.size==0
+      raise "Analysis #{args} doesn't exists" if (args - stored_analysis.keys).size>0
+      args.each do |name|
+        stored_analysis[name].run
+      end
+    end
+
+    # Add analysis +*args+ to an reportbuilder object.
+    # Without arguments, add all stored analysis
+    # Each analysis is wrapped inside a ReportBuilder::Section object
+    # This is the method is used by save() and to_text()
+    
+    def self.add_to_reportbuilder(rb, *args)
+      args=stored_analysis.keys if args.size==0
+      raise "Analysis #{name} doesn't exists" if (args - stored_analysis.keys).size>0
+      args.each do |name|
+        section=ReportBuilder::Section.new(:name=>stored_analysis[name].name)
+        rb_an=stored_analysis[name].add_to_reportbuilder(section)
+        rb.add(section)        
+        rb_an.run
+      end
+    end
+    
+    # Save the analysis on a file
+    # Without arguments, add all stored analysis    
+    def self.save(filename, *args)
+      rb=ReportBuilder.new(:name=>filename)
+      add_to_reportbuilder(rb, *args)
+      rb.save(filename)
+    end
+    
+    # Run analysis and return as string
+    # output of echo callings
+    # Without arguments, add all stored analysis
+    
+    def self.to_text(*args)
+      rb=ReportBuilder.new(:name=>"Analysis #{Time.now}")
+      add_to_reportbuilder(rb, *args)
+      rb.to_text
+    end
+    # Run analysis and return to screen all
+    # echo and summary callings
+    def self.run_batch(*args)
+      puts to_text(*args)
+    end    
+  end
+end

data/lib/statsample-ekatena/analysis/suite.rb

@@ -0,0 +1,89 @@
+module Statsample
+  module Analysis
+    class Suite 
+      include Statsample::Shorthand
+      attr_accessor :output
+      attr_accessor :name
+      attr_reader :block
+      def initialize(opts=Hash.new(), &block)
+        if !opts.is_a? Hash
+          opts={:name=>opts}
+        end
+         
+        @block=block
+        @name=opts[:name] || "Analysis #{Time.now}"
+        @attached=[]
+        @output=opts[:output] || ::STDOUT
+      end
+      # Run the analysis, putting output on 
+      def run
+         @block.arity<1 ? instance_eval(&@block) : @block.call(self)
+      end
+      # Provides a description of the procedure. Only appears as a commentary on 
+      # SuiteReportBuilder outputs
+      def desc(d)
+        @output.puts("Description:")
+        @output.puts("  #{d}") 
+      end
+      def echo(*args)
+        @output.puts(*args)
+      end
+      def summary(obj)
+        obj.summary
+      end
+      def add_to_reportbuilder(rb)
+        SuiteReportBuilder.new({:name=>name, :rb=>rb}, &block)
+      end
+      
+      def generate(filename)
+        ar=SuiteReportBuilder.new({:name=>name}, &block)
+        ar.generate(filename)
+      end
+      def to_text
+        ar=SuiteReportBuilder.new({:name=>name}, &block)
+        ar.to_text
+      end
+      
+      def attach(ds)
+        @attached.push(ds)
+      end
+      def detach(ds=nil)
+        if ds.nil?
+          @attached.pop
+        else
+          @attached.delete(ds)
+        end
+      end
+      alias :old_boxplot :boxplot
+      alias :old_histogram :histogram
+      alias :old_scatterplot :scatterplot
+
+      def show_svg(svg)
+        require 'tmpdir'
+        fn=Dir.tmpdir+"/image_#{Time.now.to_f}.svg"
+        File.open(fn,"w") {|fp| fp.write svg}
+	if RUBY_PLATFORM =~/darwin/
+	  %x(open -a safari #{fn})
+	else
+	  %x(xdg-open #{fn})
+	end
+      end
+      def boxplot(*args)
+        show_svg(old_boxplot(*args).to_svg)
+      end
+      def histogram(*args)
+        show_svg(old_histogram(*args).to_svg)
+      end
+      def scatterplot(*args)
+        show_svg(old_scatterplot(*args).to_svg)
+      end
+      
+      def method_missing(name, *args,&block)
+        @attached.reverse.each do |ds|
+          return ds[name] if ds.vectors.to_a.include? (name)
+        end
+        raise "Method #{name} doesn't exists"
+      end
+    end
+  end
+end

data/lib/statsample-ekatena/analysis/suitereportbuilder.rb

@@ -0,0 +1,44 @@
+module Statsample
+  module Analysis
+    class SuiteReportBuilder < Suite
+      attr_accessor :rb
+      def initialize(opts=Hash.new,&block)
+        if !opts.is_a? Hash
+          opts={:name=>opts}
+        end        
+        super(opts,&block)
+        @rb=opts[:rb] || ReportBuilder.new(:name=>name)
+      end
+      def generate(filename)
+        run if @block
+        @rb.save(filename)
+      end
+      def to_text
+        run if @block
+        @rb.to_text
+      end
+      def summary(o)
+        @rb.add(o)
+      end
+      def desc(d)
+        @rb.add(d)
+      end
+      def echo(*args)
+        args.each do |a|
+          @rb.add(a)
+        end
+      end
+      
+      def boxplot(*args)
+        @rb.add(old_boxplot(*args))
+      end
+      def histogram(*args)
+        @rb.add(old_histogram(*args))
+      end
+      def boxplot(*args)
+        @rb.add(old_boxplot(*args))
+      end
+      
+    end
+  end
+end

data/lib/statsample-ekatena/anova.rb

@@ -0,0 +1,24 @@
+module Statsample
+  module Anova
+    class << self
+      def oneway(*args)
+        OneWay.new(*args)
+      end      
+      def twoway(*args)
+        TwoWay.new(*args)
+      end      
+      
+      def oneway_with_vectors(*args)
+        OneWayWithVectors.new(*args)
+      end
+      def twoway_with_vectors(*args)
+        TwoWayWithVectors.new(*args)
+      end
+      
+    end
+  end
+end
+
+require 'statsample/anova/oneway'
+require 'statsample/anova/contrast'
+require 'statsample/anova/twoway'

data/lib/statsample-ekatena/anova/contrast.rb

@@ -0,0 +1,79 @@
+module Statsample
+  module Anova
+    class Contrast
+      attr_reader :psi
+
+      attr_reader :msw
+      include Summarizable
+      def initialize(opts=Hash.new)
+        raise "Should set at least vectors options" if opts[:vectors].nil?
+        @vectors=opts[:vectors]
+        @c=opts[:c]
+        @c1,@c2=opts[:c1], opts[:c2]
+        @t_options=opts[:t_options] || {:estimate_name=>_("Psi estimate")}
+        @name=opts[:name] || _("Contrast")
+        @psi=nil
+        @anova=Statsample::Anova::OneWayWithVectors.new(@vectors)
+        @msw=@anova.msw
+      end
+      # Hypothesis contrast, selecting index for each constrast
+      # For example, if you want to contrast x_0 against x_1 and x_2
+      # you should use
+      # c.contrast([0],[1,2])
+      def c_by_index(c1,c2)
+        contrast=[0]*@vectors.size
+        c1.each {|i| contrast[i]=1.quo(c1.size)}
+        c2.each {|i| contrast[i]=-1.quo(c2.size)}
+        @c=contrast
+        c(contrast)
+      end
+      def psi
+        if @psi.nil?
+          c(@c) if @c
+          c_by_index(@c1,@c2) if (@c1 and @c2)
+        end
+        @psi
+      end
+      def confidence_interval(cl=nil)
+        t_object.confidence_interval(cl)
+      end
+      # Hypothesis contrast, using custom values
+      # Every parameter is a contrast value. You should use
+      # the same number of contrast as vectors on class and the sum
+      # of constrast should be 0.
+      def c(args=nil)
+        
+        return @c if args.nil?
+        @c=args
+        raise "contrast number!=vector number" if args.size!=@vectors.size
+        #raise "Sum should be 0" if args.inject(0) {|ac,v| ac+v}!=0
+        @psi=args.size.times.inject(0) {|ac,i| ac+(args[i]*@vectors[i].mean)}
+      end
+      def standard_error
+        sum=@vectors.size.times.inject(0) {|ac,i|
+          ac+((@c[i].rationalize**2).quo(@vectors[i].size))
+        } 
+        Math.sqrt(@msw*sum)
+      end
+      alias :se :standard_error
+      def df
+        @vectors.inject(0) {|ac,v| ac+v.size}-@vectors.size
+      end
+      def t_object
+        Statsample::Test::T.new(psi, se, df, @t_options)
+      end
+      def t
+        t_object.t
+      end
+      def probability
+        t_object.probability
+      end
+      def report_building(builder)
+         builder.section(:name=>@name) do |s|
+           s.text _("Contrast:%s") % c.join(",")
+           s.parse_element(t_object)
+         end
+      end
+    end
+  end
+end

data/lib/statsample-ekatena/anova/oneway.rb

@@ -0,0 +1,187 @@
+module Statsample
+  module Anova
+    # = Generic Anova one-way.
+    # You could enter the sum of squares or the mean squares. You
+    # should enter the degrees of freedom for numerator and denominator.
+    # == Usage
+    #  anova=Statsample::Anova::OneWay(:ss_num=>10,:ss_den=>20, :df_num=>2, :df_den=>10, @name=>"ANOVA for....")
+    class OneWay
+      include Summarizable
+      attr_reader :df_num, :df_den, :ss_num, :ss_den, :ms_num, :ms_den, :ms_total, :df_total, :ss_total
+      # Name of ANOVA Analisys
+      attr_accessor :name
+      attr_accessor :name_denominator
+      attr_accessor :name_numerator
+      def initialize(opts=Hash.new)
+        @name=@name_numerator=@name_denominator=nil
+        
+        # First see if sum of squares or mean squares are entered
+        raise ArgumentError, "You should set d.f." unless (opts.has_key? :df_num and opts.has_key? :df_den)
+        @df_num=opts.delete :df_num
+        @df_den=opts.delete :df_den
+        @df_total=@df_num+@df_den
+        if(opts.has_key? :ss_num and opts.has_key? :ss_den)
+          @ss_num = opts.delete :ss_num
+          @ss_den =opts.delete :ss_den
+          @ms_num =@ss_num.quo(@df_num)
+          @ms_den =@ss_den.quo(@df_den) 
+        elsif (opts.has_key? :ms_num and opts.has_key? :ms_den)
+          @ms_num =opts.delete :ms_num
+          @ms_den =opts.delete :ms_den
+          @ss_num =@ms_num * @df_num
+          @ss_den =@ss_den * @df_den
+        end
+        @ss_total=@ss_num+@ss_den
+        @ms_total=@ms_num+@ms_den
+        opts_default={:name=>"ANOVA",
+                      :name_denominator=>_("Explained variance"),
+                      :name_numerator=>_("Unexplained variance")}
+        @opts=opts_default.merge(opts)
+        opts.keys.each {|k|
+          send("#{k}=", @opts[k]) if self.respond_to? "#{k}="
+        }
+        @f_object=Statsample::Test::F.new(@ms_num, @ms_den, @df_num,@df_den)
+      end
+      # F value
+      def f
+        @f_object.f
+      end
+      # P-value of F test
+      def probability
+        @f_object.probability
+      end
+      def report_building(builder) #:nodoc:
+        builder.section(:name=>@name) do |b|
+          report_building_table(b)
+        end
+      end
+      def report_building_table(builder) #:nodoc:
+        builder.table(:name=>_("%s Table") % @name, :header=>%w{source ss df ms f p}.map {|v| _(v)}) do |t|
+          t.row([@name_numerator, sprintf("%0.3f",@ss_num),   @df_num, sprintf("%0.3f",@ms_num),  sprintf("%0.3f",f), sprintf("%0.3f", probability)])
+          t.row([@name_denominator, sprintf("%0.3f",@ss_den),  @df_den, sprintf("%0.3f",@ms_den), "", ""])
+          t.row([_("Total"), sprintf("%0.3f",@ss_total),  @df_total, sprintf("%0.3f",@ms_total),"",""])
+        end
+      end
+
+    end
+    
+    # One Way Anova with vectors
+    # Example:
+    #   v1 = Daru::Vector.new([2,3,4,5,6])
+    #   v2 = Daru::Vector.new([3,3,4,5,6])
+    #   v3 = Daru::Vector.new([5,3,1,5,6])
+    #   anova=Statsample::Anova::OneWayWithVectors.new([v1,v2,v3])
+    #   anova.f
+    #   => 0.0243902439024391
+    #   anova.probability
+    #   => 0.975953044203438
+    #   anova.sst 
+    #   => 32.9333333333333
+    #
+    class OneWayWithVectors < OneWay
+      # Show on summary Levene test
+      attr_accessor :summary_levene
+      # Show on summary descriptives for vectors
+      attr_accessor :summary_descriptives
+      # Show on summary of contrasts
+      attr_accessor :summary_contrasts
+      # Array with stored contrasts
+      attr_reader :contrasts
+      
+      def initialize(*args)
+        if args[0].is_a? Array
+          @vectors = args.shift
+        else
+          @vectors = args.find_all {|v| v.is_a? Daru::Vector}
+          opts     = args.find {|v| v.is_a? Hash}
+        end
+        opts||=Hash.new
+        opts_default={:name=>_("Anova One-Way"), 
+                      :name_numerator=>_("Between Groups"),
+                      :name_denominator=>_("Within Groups"),
+                      :summary_descriptives=>false,
+                      :summary_levene=>true,
+                      :summary_contrasts=>true
+        }
+        @opts=opts_default.merge(opts).merge(:ss_num=>ssbg, :ss_den=>sswg, :df_num=>df_bg, :df_den=>df_wg)
+        @contrasts=[]
+        super(@opts)
+      end
+      alias :sst :ss_total 
+      alias :msb :ms_num
+      alias :msw :ms_den
+      
+      # Generates and store a contrast.
+      # Options should be provided as a hash
+      # [:c]=>contrast vector
+      # [:c1 - :c2]=>index for automatic construction of contrast
+      # [:name]=>contrast name
+      
+      def contrast(opts=Hash.new)
+        name=opts[:name] || _("Contrast for %s") % @name
+        opts=opts.merge({:vectors=>@vectors, :name=>name})
+        c=Statsample::Anova::Contrast.new(opts)
+        @contrasts.push(c)
+        c
+      end
+      
+      def levene
+        Statsample::Test.levene(@vectors, :name=>_("Test of Homogeneity of variances (Levene)"))
+      end
+      # Total mean
+      def total_mean
+        sum=@vectors.inject(0){|a,v| a+v.sum}
+        sum.quo(n)
+      end
+      # Sum of squares within groups
+      def sswg
+        @sswg||=@vectors.inject(0) {|total,vector| total+vector.ss }
+      end
+      # Sum of squares between groups
+      def ssbg
+        m=total_mean
+        @vectors.inject(0) do |total,vector|
+          total + (vector.mean-m).square * vector.size 
+        end
+      end
+      # Degrees of freedom within groups
+      def df_wg
+        @dk_wg||=n-k
+      end
+      def k
+        @k||=@vectors.size
+      end
+      # Degrees of freedom between groups 
+      def df_bg
+          k-1
+      end
+      # Total number of cases
+      def n
+          @vectors.inject(0){|a,v| a+v.size}
+      end
+      def report_building(builder) # :nodoc:
+        builder.section(:name=>@name) do |s|
+          if summary_descriptives
+            s.table(:name=>_("Descriptives"),:header=>%w{Name N Mean SD Min Max}.map {|v| _(v)}) do |t|
+              @vectors.each do |v|
+                t.row [v.name, v.reject_values(*Daru::MISSING_VALUES).size, "%0.4f" % v.mean, "%0.4f" %  v.sd, "%0.4f" % v.min, "%0.4f" % v.max]
+              end
+            end
+          end
+          
+          if summary_levene
+            s.parse_element(levene)
+          end
+          report_building_table(s)
+          if summary_contrasts and @contrasts.size>0
+
+            @contrasts.each do |c|
+              s.parse_element(c)
+            end
+          end
+          
+        end
+      end
+    end
+  end
+end