statsample 0.3.0

data/lib/statsample/dominanceanalysis.rb

@@ -0,0 +1,259 @@
+require 'statsample/dominanceanalysis/bootstrap'
+module Statsample
+    class DominanceAnalysis
+        def initialize(ds,y_var, r_class = Regression::MultipleRegressionPairwise)
+            @y_var=y_var
+            @dy=ds[@y_var]
+            @ds=ds
+            @r_class=r_class
+            @ds_indep=ds.dup(ds.fields-[y_var])
+            @fields=@ds_indep.fields
+            create_models
+            fill_models
+        end
+        def fill_models
+            @models.each{|m|
+                @fields.each{|f|
+                    next if m.include? f
+                    base_model=md(m)
+                    comp_model=md(m+[f])
+                    base_model.add_contribution(f,comp_model.r2)
+                }
+            }
+        end
+        def dominance_for_nil_model(i,j)
+            if md(i).r2>md(j).r2
+                1
+            elsif md(i).r2<md(j).r2
+                0
+            else
+                0.5
+            end           
+        end
+        # Returns 1 if i D k, 0 if j dominates i and 0.5 if undetermined
+        def total_dominance_pairwise(i,j)
+            dm=dominance_for_nil_model(i,j)
+            return 0.5 if dm==0.5
+            dominances=[dm]
+            @models_data.each{|k,m|
+                if !m.contributions[i].nil? and !m.contributions[j].nil?
+                    if m.contributions[i]>m.contributions[j]
+                        dominances.push(1)
+                    elsif m.contributions[i]<m.contributions[j]
+                        dominances.push(0)
+                    else
+                        dominances.push(0.5)
+                    end
+                end
+            }
+            final=dominances.uniq
+            final.size>1 ? 0.5 : final[0]
+        end
+        
+        # Returns 1 if i cD k, 0 if j cD i and 0.5 if undetermined
+        def conditional_dominance_pairwise(i,j)
+            dm=dominance_for_nil_model(i,j)
+            return 0.5 if dm==0.5
+            dominances=[dm]
+            for k in 1...@fields.size
+                a=average_k(k)
+                if a[i]>a[j]
+                    dominances.push(1)
+                elsif a[i]<a[j]
+                    dominances.push(0)
+                else
+                    a(0.5)
+                end                 
+            end
+            final=dominances.uniq
+            final.size>1 ? 0.5 : final[0]            
+        end
+        # Returns 1 if i gD k, 0 if j gD i and 0.5 if undetermined        
+        def general_dominance_pairwise(i,j)
+            ga=general_averages
+            if ga[i]>ga[j]
+                1
+            elsif ga[i]<ga[j]
+                0
+            else
+                0.5
+            end                 
+        end
+        def pairs
+            @models.find_all{|m| m.size==2}
+        end
+        def total_dominance
+            pairs.inject({}){|a,pair|
+                a[pair]=total_dominance_pairwise(pair[0], pair[1])
+                a
+            }
+        end
+        def conditional_dominance
+            pairs.inject({}){|a,pair|
+                a[pair]=conditional_dominance_pairwise(pair[0], pair[1])
+                a
+            }
+        end
+        def general_dominance
+            pairs.inject({}){|a,pair|
+                a[pair]=general_dominance_pairwise(pair[0], pair[1])
+                a
+            }
+        end
+        
+        def md(m)
+            @models_data[m.sort]
+        end
+        # Get all model of size k
+        def md_k(k)
+            out=[]
+            models=@models.each{|m|
+                out.push(md(m)) if m.size==k
+            }
+            out
+        end
+        def average_k(k)
+            return nil if k==@fields.size
+            models=md_k(k)
+            averages=@fields.inject({}) {|a,v| a[v]=[];a}
+            models.each{|m|
+                @fields.each{|f|
+                    averages[f].push(m.contributions[f]) unless m.contributions[f].nil?
+                }
+            }
+            out={}
+            averages.each{|k,v|
+                out[k]=v.to_vector(:scale).mean
+            }
+            out
+        end
+        def general_averages
+            if @general_averages.nil?
+                averages=@fields.inject({}) {|a,v| a[v]=[md(v).r2];a}
+                for k in 1...@fields.size
+                    ak=average_k(k)
+                    @fields.each{|f|
+                        averages[f].push(ak[f])
+                    }
+                end
+                out={}
+                averages.each{|k,v|
+                    out[k]=v.to_vector(:scale).mean
+                }
+                @general_averages=out
+            end
+            @general_averages
+        end
+        def create_models
+            @models=[]
+            @models_data={}
+            for i in 1..@fields.size
+                c = GSL::Combination.calloc(@fields.size, i);
+            begin
+                convert=c.data.to_a.collect {|i|
+                    @fields[i]
+                }
+                @models.push(convert)
+                ds_prev=@ds.dup(convert+[@y_var])
+                modeldata=ModelData.new(convert,ds_prev, @y_var, @fields, @r_class)
+                
+                @models_data[convert.sort]=modeldata
+            end while c.next == GSL::SUCCESS
+            end
+        end
+        def summary(report_type=ConsoleSummary)
+            out=""
+            out.extend report_type
+            out << "Summary for Dominance Analysis of "+@fields.join(", ")+" over "+@y_var+"\n"
+                t=Statsample::ReportTable.new
+                t.header=["","r2","sign"]+@fields
+                row=["Model 0","",""]+@fields.collect{|f|
+                    sprintf("%0.3f",md(f).r2)
+                }
+                t.add_row(row)
+                t.add_horizontal_line
+            for i in 1..@fields.size
+                mk=md_k(i)
+                mk.each{|m|
+                    t.add_row(m.add_table_row)
+                }
+                # Report averages
+                a=average_k(i)
+                if !a.nil?
+                    t.add_horizontal_line
+                    row=["k=#{i} Average","",""] + @fields.collect{|f|
+                        sprintf("%0.3f",a[f])
+                    }
+                    t.add_row(row)
+                    t.add_horizontal_line
+                    
+                end
+                
+            end
+            
+            g=general_averages
+                    t.add_horizontal_line
+            
+            row=["Overall averages","",""]+@fields.collect{|f|
+                        sprintf("%0.3f",g[f])
+            }
+                    t.add_row(row)
+            out.parse_table(t)
+                    
+            out.nl
+            out << "Pairwise\n"
+            td=total_dominance
+            cd=conditional_dominance
+            gd=general_dominance
+            t=Statsample::ReportTable.new(["Pairs","T","C","G"])
+            pairs.each{|p|
+                name=p.join(" - ")
+                row=[name, sprintf("%0.1f",td[p]), sprintf("%0.1f",cd[p]), sprintf("%0.1f",gd[p])]
+                t.add_row(row)
+            }
+            out.parse_table(t)
+            return out
+        end
+            class ModelData
+            attr_reader :contributions
+            def initialize(name,ds,y_var,fields,r_class)
+                @name=name
+                @fields=fields
+                @contributions=@fields.inject({}){|a,v| a[v]=nil;a}
+                r_class=Regression::MultipleRegressionPairwise if r_class.nil?
+                @lr=r_class.new(ds,y_var)
+            end
+            def add_contribution(f,v)
+                @contributions[f]=v-r2
+            end
+            def r2
+                @lr.r2
+            end
+            def add_table_row
+                [@name.join("*"), sprintf("%0.3f",r2), sprintf("%0.3f",@lr.significance)]+@fields.collect{|k|
+                    v=@contributions[k]
+                    if v.nil?
+                        "--"
+                    else
+                    sprintf("%0.3f",v)
+                    end
+                }
+            end
+            def summary
+                out=sprintf("%s: r2=%0.3f(p=%0.2f)\n",@name.join("*"),r2,@lr.significance,@lr.sst)
+                out << @fields.collect{|k|
+                    v=@contributions[k]
+                    if v.nil?
+                        "--"
+                    else
+                    sprintf("%s=%0.3f",k,v)
+                    end
+                }.join(" | ") 
+                out << "\n"
+                
+                return out
+            end
+            end
+    end
+    
+end

data/lib/statsample/dominanceanalysis/bootstrap.rb

@@ -0,0 +1,126 @@
+module Statsample
+class DominanceAnalysis
+    class Bootstrap
+        include Writable
+        attr_reader :samples_td,:samples_cd,:samples_gd,:samples_ga, :fields
+        attr_writer :lr_class
+        def initialize(ds,y_var)
+            @ds=ds
+            @y_var=y_var
+            @n=ds.cases
+            @fields=ds.fields-[y_var]
+            @samples_ga=@fields.inject({}){|a,v| a[v]=[];a}
+            @n_samples=0
+            @lr_class=Regression::MultipleRegressionPairwise
+            create_samples_pairs            
+        end
+        def lr_class=(lr)
+            @lr_class=lr
+        end
+        def da
+            if @da.nil?
+                @da=DominanceAnalysis.new(@ds,@y_var,@lr_class)
+            end
+            @da
+        end
+        def bootstrap(number_samples,n=nil)
+                number_samples.times{ |t|
+                    @n_samples+=1
+                    puts "Bootstrap #{t+1} of #{number_samples}"
+                    ds_boot=@ds.bootstrap(n)
+                    da_1=DominanceAnalysis.new(ds_boot,@y_var,@lr_class)
+                    da_1.total_dominance.each{|k,v|
+                        @samples_td[k].push(v)
+                    }
+                    da_1.conditional_dominance.each{|k,v|
+                        @samples_cd[k].push(v)
+                    }
+                    da_1.general_dominance.each{|k,v|
+                        @samples_gd[k].push(v)
+                    }
+                    da_1.general_averages.each{|k,v|
+                        @samples_ga[k].push(v)
+                    }
+                }
+        end
+        def create_samples_pairs
+            @samples_td={}
+            @samples_cd={}
+            @samples_gd={}
+            @pairs=[]
+            c = GSL::Combination.calloc(@fields.size, 2);
+            begin
+                convert=c.data.to_a.collect {|i|
+                    @fields[i]
+                }
+                @pairs.push(convert)
+                [@samples_td,@samples_cd,@samples_gd].each{|s|
+                    s[convert]=[]
+                }
+            end while c.next == GSL::SUCCESS
+        end
+        def summary(report_type=ConsoleSummary)
+            out =""
+            raise "You should bootstrap first" if @n_samples==0
+            alfa=0.95
+            t=GSL::Cdf.tdist_Pinv(1-((1-alfa) / 2),@n_samples - 1)
+            out.extend report_type
+            out.add "Summary for Bootstrap Dominance Analysis of "+@fields.join(", ")+" over "+@y_var+"\n"
+            out.add "Size of sample: #{@n_samples}\n"
+            out.add "t:#{t}\n"
+            out.nl
+            table=ReportTable.new
+            header=["pairs","sD","Dij","SE(Dij)","Pij","Pji","Pno","Reprod"]
+            table.header=header
+            table.add_row(["Complete dominance"])
+            table.add_horizontal_line
+            @pairs.each{|pair|
+                std=@samples_td[pair].to_vector(:scale)
+                ttd=da.total_dominance_pairwise(pair[0],pair[1])
+                table.add_row(summary_pairs(pair,std,ttd))
+            }
+            table.add_horizontal_line
+            table.add_row(["Conditional dominance"])
+            table.add_horizontal_line
+            @pairs.each{|pair|
+                std=@samples_cd[pair].to_vector(:scale)
+                ttd=da.conditional_dominance_pairwise(pair[0],pair[1])
+                table.add_row(summary_pairs(pair,std,ttd))
+
+            }
+            table.add_horizontal_line
+            table.add_row(["General Dominance"])
+            table.add_horizontal_line
+            @pairs.each{|pair|
+                std=@samples_gd[pair].to_vector(:scale)
+                ttd=da.general_dominance_pairwise(pair[0],pair[1])
+                table.add_row(summary_pairs(pair,std,ttd))
+            }
+            out.parse_table(table)
+            out.add("General averages")
+            table=Statsample::ReportTable.new
+            table.header=["var","mean","se","p.5","p.95"]
+            @fields.each{|f|
+                v=@samples_ga[f].to_vector(:scale)
+                row=[f, sprintf("%0.3f",v.mean), sprintf("%0.3f",v.sd), sprintf("%0.3f",v.percentil(5)),sprintf("%0.3f",v.percentil(95))]
+                table.add_row(row)
+
+            }
+            out.parse_table(table)
+            out
+        end
+        def summary_pairs(pair,std,ttd)
+            freqs=std.proportions
+            [0,0.5,1].each{|n|
+                freqs[n]=0 if freqs[n].nil?
+            }
+            name=pair[0]+" - "+pair[1]
+            [name,f(ttd,1),f(std.mean,4),f(std.sd),f(freqs[1]), f(freqs[0]), f(freqs[0.5]), f(freqs[ttd])]
+        end
+        def f(v,n=3)
+            prec="%0.#{n}f"
+            sprintf(prec,v)
+        end
+    end
+end
+end

data/lib/statsample/graph/gdchart.rb

@@ -0,0 +1,45 @@
+require 'GDChart'
+module Statsample
+	module Util
+	class << self
+		def chart_gdchart(file,width,height,chart_type, labels, options,num_datasets,data)
+				require 'GDChart'
+				gdc=GDChart.new
+				gdc.title="Generic title"
+				gdc.bg_color=0xFFFFFF
+				gdc.image_type=GDChart::JPEG
+				options.each{|k,v|
+					gdc.send(k+"=",v)
+				}
+				f=File.open(file,"w") {|f|
+					gdc.out_graph(width,height,f,chart_type, data.length/num_datasets,labels,num_datasets,data)
+				}
+		end
+		end
+	end
+	class Nominal
+		# Creates a barchart using ruby-gdchart
+		def gdchart_frequencies(file, width=300, height=150, chart_type=GDChart::BAR, options={})
+			labels,data=[],[]
+			self.frequencies.sort.each{|k,v|
+				labels.push(k.to_s)
+				data.push(v) 
+			}
+			options['ext_color']=[0xFF3399,0xFF9933,0xFFEE33,0x33FF33, 0x9966FF]
+			Statsample::Util.chart_gdchart(file,width,height,chart_type, labels,options,1,data)
+		end
+	end
+	class Scale < Ordinal
+		def gdchart_histogram(bins,file, width=300, height=150, chart_type=GDChart::BAR, options={})
+            labels=[]
+            h=histogram(bins)
+            data=[]
+            (0...bins).each{|bin|
+                data.push(h[bin])
+                range=h.get_range(bin)
+                labels.push(((range[0]+range[1]) / 2.to_f).to_s)
+            }
+            Statsample::Util.chart_gdchart(file, width, height, chart_type, labels,options, 1,data)
+		end
+	end
+end

data/lib/statsample/graph/svgboxplot.rb

@@ -0,0 +1,108 @@
+module Statsample
+    module Graph
+        class SvgBoxplot < SVG::Graph::Bar
+            def initialize(config={})
+                config[:fields]=["dummy"]
+                super(config)
+            end
+            def get_x_labels
+                @data.collect{|d|
+                    d[:title]
+                }
+            end
+            
+            def min_value
+                min = 0
+                if min_scale_value.nil? 
+                    min = @data.collect{|x| x[:data].min}.min
+                    if min > 0
+                        if min > 10
+                            min=min-2
+                        else
+                            min=0
+                        end
+                    end
+                else
+                    min = min_scale_value
+                end
+                return min
+            end
+            def draw_data
+            minvalue = min_value
+            fieldwidth = field_width
+            unit_size =  (@graph_height.to_f - font_size*2*top_font) / 
+                          (get_y_labels.max - get_y_labels.min)
+            bargap = bar_gap ? (fieldwidth < 10 ? fieldwidth / 2 : 10) : 0
+            
+            bar_width = fieldwidth - bargap
+            bar_width /= @data.length if stack == :side
+            x_mod = (@graph_width-bargap) / 2 - (stack==:side ? bar_width/2 : 0)
+            
+            bottom = @graph_height
+            
+            field_count = 0
+            for dataset in @data
+            
+            # cases (assume 0 = +ve):
+            #   value  min  length
+            #    +ve   +ve  value - min
+            #    +ve   -ve  value - 0
+            #    -ve   -ve  value.abs - 0
+            
+            min=dataset[:data].min
+            max=dataset[:data].max
+            median=dataset[:vector].median
+            q1=dataset[:vector].percentil(25)
+            q3=dataset[:vector].percentil(75)
+            iqr=q3-q1
+            left = (fieldwidth * field_count)
+            #length = (value.abs - (minvalue > 0 ? minvalue : 0)) * unit_size
+            # top is 0 if value is negative
+            top_wisk=(q3+iqr*1.5 < max) ? q3+iqr*1.5 : max
+            down_wisk= (q1-iqr*1.5 > min) ? q1-iqr*1.5 : min
+            
+            top=@graph_height-((top_wisk-minvalue)*unit_size)
+            down=@graph_height-((down_wisk-minvalue)*unit_size)
+            
+            median_bar=@graph_height-((median-minvalue)*unit_size)
+            middle= left+(bar_width / 2)
+            left_whis=left+(bar_width * 0.4)
+            rigth_whis=left+(bar_width*0.6)
+            left_rect= left+(bar_width * 0.25)
+            rigth_rect = left+ (bar_width * 0.75)
+            top_rect=@graph_height-((q3-minvalue)*unit_size)
+            height_rect=iqr*unit_size
+            path="M #{left_whis} #{top} H #{rigth_whis} M #{middle} #{top} V #{down} M #{left_whis} #{down} H #{rigth_whis} M #{left_rect} #{median_bar} H #{rigth_rect}"
+            
+            
+            # Marcamos Outliers
+            if top_wisk!=max or down_wisk!=min
+                dataset[:vector].valid_data.each{|d|
+                    if(d<down_wisk) or (d>top_wisk)
+                    y_out=(@graph_height - (d -minvalue)*unit_size).to_s
+                        @graph.add_element( "circle", {
+                         "cx" => (middle).to_s,
+                         "cy" => y_out,
+                        "r" => "3",
+                        "class" => "dataPoint#{field_count+1}"
+                        })
+                        @graph.add_element( "text", {
+                        "x" => (middle+20).to_s,
+                        "y" => y_out,
+                        "class" => "dataPointLabel",
+                        "style" => "#{style} stroke: #000;"
+                        }).text = d.to_s                    end
+                }
+            end
+            
+            @graph.add_element( "rect", { "x" => left_rect.to_s, "y" => top_rect.to_s, "width" => (bar_width / 2).to_s, "height" => (height_rect).to_s, "class" => "fill#{field_count+1}"})
+
+            @graph.add_element("path",{"d"=>path, "style"=>"stroke:black;stroke-width:2"})
+            
+            field_count += 1
+            end
+           
+            end
+        end
+    end
+end