statsample 0.6.1 → 0.6.2

data/lib/statsample/bivariate/tetrachoric.rb

@@ -27,7 +27,7 @@ module Statsample
     # See http://www.john-uebersax.com/stat/tetra.htm for extensive 
     # documentation about tetrachoric correlation.
     #
-    # This class uses Brown(1977) algorithm. You can see FORTRAN code on http://lib.stat.cmu.edu/apstat/116
+    # This class uses Brown (1977) algorithm. You can see FORTRAN code on http://lib.stat.cmu.edu/apstat/116
     # 
     # == References:
     # * Brown, MB. (1977) Algorithm AS 116: the tetrachoric correlation and its standard error. _Applied Statistics, 26_, 343-351.
@@ -52,8 +52,10 @@ module Statsample
     
     
     class Tetrachoric
-      
+      include GetText
+      bindtextdomain("statsample")
       attr_reader :r
+      attr_accessor :name
       
       TWOPI=Math::PI*2
       SQT2PI= 2.50662827
@@ -67,10 +69,14 @@ module Statsample
       NITER = 25
       X=[0,0.9972638618,  0.9856115115,  0.9647622556, 0.9349060759,  0.8963211558, 0.8493676137, 0.7944837960, 0.7321821187, 0.6630442669, 0.5877157572, 0.5068999089, 0.4213512761, 0.3318686023, 0.2392873623, 0.1444719616, 0.0483076657]
       W=[0, 0.0070186100,  0.0162743947,  0.0253920653, 0.0342738629,  0.0428358980,  0.0509980593, 0.0586840935,  0.0658222228,  0.0723457941, 0.0781938958, 0.0833119242, 0.0876520930, 0.0911738787, 0.0938443991, 0.0956387201, 0.0965400885]
+      # Creates a Tetrachoric object based on a 2x2 Matrix.
+      def self.new_with_matrix(m)
+        Tetrachoric.new(m[0,0], m[0,1], m[1,0],m[1,1])
+      end
       # Creates a Tetrachoric object based on two vectors.
       # The vectors are dichotomized previously.
       def self.new_with_vectors(v1,v2)
-        v1a,v2a=Statsample.only_valid(v1,v2)
+        v1a, v2a=Statsample.only_valid(v1,v2)
         v1a=v1a.dichotomize
         v2a=v2a.dichotomize
         raise "v1 have only 0" if v1a.factors==[0]
@@ -90,17 +96,42 @@ module Statsample
         @sdr
       end
       # Threshold for variable x (rows)
+      # Point on gauss curve under X rater select cases
       def threshold_x
-        @zac
+        @zab
       end
 
       # Threshold for variable y (columns)
+      # Point on gauss curve under Y rater select cases
+
       def threshold_y
-        @zab
+        @zac
+      end
+      def summary
+        rp=ReportBuilder.new()
+        rp.add(self)
+        rp.to_text
+      end
+      
+      def to_reportbuilder(generator)
+        section=ReportBuilder::Section.new(:name=>@name)
+        t=ReportBuilder::Table.new(:name=>_("Contingence Table"),:header=>["","Y=0","Y=1", "T"])
+        t.add_row(["X=0", @a,@b,@a+@b])
+        t.add_row(["X=1", @c,@d,@c+@d])
+        t.add_hr
+        t.add_row(["T", @a+@c,@b+@d,@a+@b+@c+@d])
+        section.add(t)
+        #generator.parse_element(t)
+        section.add(sprintf("r: %0.3f",r))
+        section.add(_("SE: %0.3f") % se)
+        section.add(_("Threshold X: %0.3f ") % [threshold_x] )
+        section.add(_("Threshold Y: %0.3f ") % [threshold_y] )
+        generator.parse_element(section)
       end
       
       def initialize(a,b,c,d)
         @a,@b,@c,@d=a,b,c,d
+        @name=_("Tetrachoric correlation")
         #
         #       CHECK IF ANY CELL FREQUENCY IS NEGATIVE
         #
@@ -396,6 +427,7 @@ module Statsample
         pdf = Math::exp(-0.5 * (@zac ** 2 - 2 * @r * @zac * @zab + @zab ** 2)  / rrsq ** 2) / (TWOPI * rrsq)
         @pac = Distribution::Normal.cdf((@zac - @r * @zab) / rrsq) - 0.5
         @pab = Distribution::Normal.cdf((@zab - @r * @zac) / rrsq) - 0.5
+        
         @sdr = ((@aa+@dd) * (@bb + @cc)).quo(4) + @pab ** 2 * (@aa + @cc) * (@bb + @dd) + @pac ** 2 * (@aa + @bb) * (@cc + @dd) + 2.0 * @pab * @pac * (@aa * @dd - @bb * @cc) - @pab * (@aa * @bb - @cc * @dd) - @pac * (@aa * @cc - @bb * @dd)
         @sdr=0 if (@sdr<0)
         @sdr= Math::sqrt(@sdr) / (@tot * pdf * Math::sqrt(@tot))

data/lib/statsample/converters.rb

@@ -76,6 +76,17 @@ module Statsample
   class SpreadsheetBase
     class << self
       def extract_fields(row)
+=begin
+        fields=[]
+        row.to_a.collect {|c|
+          if c.nil?
+            break
+          else
+            fields.push(c)
+          end
+        }
+=end
+raise "Should'nt be empty headers: [#{row.to_a.join(",")}]" if row.to_a.find_all {|c| c.nil?}.count>0
         fields=row.to_a.collect{|c| c.downcase}
         fields.recode_repeated
       end

data/lib/statsample/dominanceanalysis.rb

@@ -1,11 +1,13 @@
 require 'statsample/dominanceanalysis/bootstrap'
 module Statsample
-  # Dominance Analysis is a procedure based on an examination of the R2 values
+  # Dominance Analysis is a procedure based on an examination of the R^2 values
   # for all possible subset models, to identify the relevance of one or more 
   # predictors in the prediction of criterium.
   #
   # See Budescu(1993) and Azen & Budescu (2003) for more information.
-  #  Use:
+  #
+  # Example: 
+  #
   #  a=1000.times.collect {rand}.to_scale
   #  b=1000.times.collect {rand}.to_scale
   #  c=1000.times.collect {rand}.to_scale
@@ -13,40 +15,42 @@ module Statsample
   #  ds['y']=ds.collect{|row| row['a']*5+row['b']*3+row['c']*2+rand()}
   #  da=Statsample::DominanceAnalysis.new(ds,'y')
   #  puts da.summary
-  #  ==>
-  #  Resultado del Analisis de Dominancia de a, b, c en y
   # 
-  #  ----------------------------------------------------------------
-  #  |                      | r2    | sign  | a     | b     | c     |
-  #  ----------------------------------------------------------------
-  #  |  Modelo 0            |       |       | 0.637 | 0.260 | 0.115 |
-  #  ----------------------------------------------------------------
-  #  |  a                   | 0.637 | 0.000 | --    | 0.239 | 0.109 |
-  #  |  b                   | 0.260 | 0.000 | 0.617 | --    | 0.103 |
-  #  |  c                   | 0.115 | 0.000 | 0.632 | 0.249 | --    |
-  #  ----------------------------------------------------------------
-  #  |  k=1 Promedio        |       |       | 0.624 | 0.244 | 0.106 |
-  #  ----------------------------------------------------------------
-  #  |  a*b                 | 0.877 | 0.000 | --    | --    | 0.098 |
-  #  |  a*c                 | 0.746 | 0.000 | --    | 0.229 | --    |
-  #  |  b*c                 | 0.363 | 0.000 | 0.612 | --    | --    |
-  #  ----------------------------------------------------------------
-  #  |  k=2 Promedio        |       |       | 0.612 | 0.229 | 0.098 |
-  #  ----------------------------------------------------------------
-  #  |  a*b*c               | 0.975 | 0.000 | --    | --    | --    |
-  #  ----------------------------------------------------------------
-  #  |  Promedios generales |       |       | 0.624 | 0.244 | 0.106 |
-  #  ----------------------------------------------------------------
-  #  
-  #  De a pares
+  # Output:
+  #
+  #  Report: Report 2010-02-08 19:10:11 -0300
+  #  Table: Dominance Analysis result
+  #  ------------------------------------------------------------
+  #  |                  | r2    | sign  | a     | b     | c     |
+  #  ------------------------------------------------------------
+  #  | Model 0          |       |       | 0.648 | 0.265 | 0.109 |
+  #  ------------------------------------------------------------
+  #  | a                | 0.648 | 0.000 | --    | 0.229 | 0.104 |
+  #  | b                | 0.265 | 0.000 | 0.612 | --    | 0.104 |
+  #  | c                | 0.109 | 0.000 | 0.643 | 0.260 | --    |
+  #  ------------------------------------------------------------
+  #  | k=1 Average      |       |       | 0.627 | 0.244 | 0.104 |
+  #  ------------------------------------------------------------
+  #  | a*b              | 0.877 | 0.000 | --    | --    | 0.099 |
+  #  | a*c              | 0.752 | 0.000 | --    | 0.224 | --    |
+  #  | b*c              | 0.369 | 0.000 | 0.607 | --    | --    |
+  #  ------------------------------------------------------------
+  #  | k=2 Average      |       |       | 0.607 | 0.224 | 0.099 |
+  #  ------------------------------------------------------------
+  #  | a*b*c            | 0.976 | 0.000 | --    | --    | --    |
+  #  ------------------------------------------------------------
+  #  | Overall averages |       |       | 0.628 | 0.245 | 0.104 |
+  #  ------------------------------------------------------------
   #  
-  #  ----------------------------
-  #  |  Pares | T   | C   | G   |
-  #  ----------------------------
-  #  |  a - b | 1.0 | 1.0 | 1.0 |
-  #  |  a - c | 1.0 | 1.0 | 1.0 |
-  #  |  b - c | 1.0 | 1.0 | 1.0 |
-  #  ----------------------------
+  #  Table: Pairwise dominance
+  #  -----------------------------------------
+  #  | Pairs | Total | Conditional | General |
+  #  -----------------------------------------
+  #  | a - b | 1.0   | 1.0         | 1.0     |
+  #  | a - c | 1.0   | 1.0         | 1.0     |
+  #  | b - c | 1.0   | 1.0         | 1.0     |
+  #  -----------------------------------------
+
   #
   # == References:
   # * Budescu, D. V. (1993). Dominance analysis: a new approach to the problem of relative importance of predictors in multiple regression. _Psychological Bulletin, 114_, 542-551.
@@ -54,22 +58,30 @@ module Statsample
   class DominanceAnalysis
     include GetText
     bindtextdomain("statsample")
+    # Class to generate the regressions. Default to Statsample::Regression::Multiple::RubyEngine
+    attr_accessor :regression_class
+    # Name of analysis
+    attr_accessor :name
+    
     # Creates a new DominanceAnalysis object
     # Params:
     # * ds: A Dataset object
     # * y_var: Name of dependent variable
-    # * r_class: Class to generate the regressions. Could be any subclass of 
-    #            Statsample::Regression::Multiple::BaseEngine
+    # * opts: Any other attribute of the class 
     # 
-    def initialize(ds,y_var, r_class = Regression::Multiple::RubyEngine)
-    @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
+    def initialize(ds,y_var, opts=Hash.new)
+      @y_var=y_var
+      @dy=ds[@y_var]
+      @ds=ds
+      @ds_indep=ds.dup(ds.fields-[y_var])
+      @fields=@ds_indep.fields
+      @regression_class=Statsample::Regression::Multiple::RubyEngine
+      @name=_("Dominance Analysis:  %s over %s") % [ ds.fields.join(",") , @y_var]
+      opts.each{|k,v|
+        self.send("#{k}=",v) if self.respond_to? k
+      }
+      create_models
+      fill_models
     end
     def fill_models
       @models.each do |m|
@@ -215,63 +227,65 @@ module Statsample
         convert=data.collect {|i1| @fields[i1] }
         @models.push(convert)
         ds_prev=@ds.dup(convert+[@y_var])
-        modeldata=ModelData.new(convert,ds_prev, @y_var, @fields, @r_class)
+        modeldata=ModelData.new(convert,ds_prev, @y_var, @fields, @regression_class)
         @models_data[convert.sort]=modeldata
       end
       end
     end
-    def summary(report_type=ConsoleSummary)
-    out=""
-    out.extend report_type
-    out << _("Summary for Dominance Analysis of %s on %s\n") % [@fields.join(", "),@y_var]
-      t=Statsample::ReportTable.new
-      t.header=["","r2","sign"]+@fields
+    def summary
+      rp=ReportBuilder.new()
+      rp.add(self)
+      rp.to_text
+    end
+    def to_reportbuilder(generator)
+      anchor=generator.add_toc_entry(_("DA: ")+@name)
+      generator.add_html "<div class='dominance-analysis'>#{@name}<a name='#{anchor}'></a>"
+      t=ReportBuilder::Table.new(:name=>_("Dominance Analysis result"))
+      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=%d Average") % i,"",""] + @fields.collect{|f|
-              sprintf("%0.3f",a[f])
-          }
-          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=%d Average") % i,"",""] + @fields.collect{|f|
+                sprintf("%0.3f",a[f])
+            }
+            t.add_row(row)
+            t.add_horizontal_line
+            
+        end
+        
       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])]
+      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)
-    return out
+      generator.parse_element(t)
+      
+      td=total_dominance
+      cd=conditional_dominance
+      gd=general_dominance
+      t=ReportBuilder::Table.new(:name=>_("Pairwise dominance"), :header=>[_("Pairs"),_("Total"),_("Conditional"),_("General")])
+      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)
+      }
+      generator.parse_element(t)
+      generator.add_html("</div>")
     end
     class ModelData
       attr_reader :contributions

data/lib/statsample/dominanceanalysis/bootstrap.rb

@@ -1,137 +1,166 @@
 module Statsample
-class DominanceAnalysis
-  # Generates Bootstrap sample to identity the replicability of a Dominance Analysis. See Azen & Bodescu (2003) for more information.
-  # References: 
-  # * Azen, R. & Budescu, D.V. (2003). The dominance analysis approach for comparing predictors in multiple regression. _Psychological Methods, 8_(2), 129-148.
+  class DominanceAnalysis
+    # Generates Bootstrap sample to identity the replicability of a Dominance Analysis. See Azen & Bodescu (2003) for more information.
+    # References: 
+    # * Azen, R. & Budescu, D.V. (2003). The dominance analysis approach for comparing predictors in multiple regression. _Psychological Methods, 8_(2), 129-148.
     class Bootstrap
-        include GetText
-        include Writable
-        bindtextdomain("statsample")
-        attr_reader :samples_td,:samples_cd,:samples_gd,:samples_ga, :fields
-        attr_writer :lr_class
-        attr_accessor :ds
-        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::Multiple::RubyEngine
-            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
-        # Creates re-samples from original dataset.
-        # * number_samples: Number of new samples to add
-        # * n: size of each new sample. If nil, equal to original sample size
-        # * report: if true, echo number of current resample and total
-        def bootstrap(number_samples,n=nil,report=false)
-          number_samples.times{ |t|
-            @n_samples+=1
-            puts _("Bootstrap %d of %d") % [t+1, number_samples] if report
-            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)
-            }
+      include GetText
+      include Writable
+      bindtextdomain("statsample")
+      # Total Dominance results
+      attr_reader :samples_td
+      # Conditional Dominance results
+      attr_reader :samples_cd
+      # General Dominance results
+      attr_reader :samples_gd
+      # General average results 
+      attr_reader :samples_ga
+      # Name of fields
+      attr_reader :fields
+      # Regression class used for analysis
+      attr_accessor :regression_class
+      # Dataset
+      attr_accessor :ds
+      # Name of analysis
+      attr_accessor :name
+      # Alpha level of confidence
+      attr_accessor :alpha
+      # Create a new Dominance Analysis Bootstrap Object
+      # 
+      # * ds: A Dataset object
+      # * y_var: Name of dependent variable
+      # * opts: Any other attribute of the class 
+      def initialize(ds,y_var, opts=Hash.new)
+        @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
+        @alpha=0.95
+        @regression_class=Regression::Multiple::RubyEngine
+        @name=_("Bootstrap dominance Analysis:  %s over %s") % [ ds.fields.join(",") , @y_var]
+        opts.each{|k,v|
+          self.send("#{k}=",v) if self.respond_to? k
+        }
+        create_samples_pairs            
+      end
+      # lr_class deprecated
+      alias_method :lr_class, :regression_class
+      def da
+          if @da.nil?
+            @da=DominanceAnalysis.new(@ds,@y_var, :regression_class => @regression_class)
+          end
+          @da
+      end
+      # Creates n re-samples from original dataset and store result of
+      # each sample on @samples_td, @samples_cd, @samples_gd, @samples_ga
+      # 
+      # * number_samples: Number of new samples to add
+      # * n: size of each new sample. If nil, equal to original sample size
+      # * report: if true, echo number of current resample and total
+      def bootstrap(number_samples,n=nil,report=false)
+        number_samples.times{ |t|
+          @n_samples+=1
+          puts _("Bootstrap %d of %d") % [t+1, number_samples] if report
+          ds_boot=@ds.bootstrap(n)
+          da_1=DominanceAnalysis.new(ds_boot, @y_var, :regression_class => @regression_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=Statsample::Combination.new(2,@fields.size)
+        c.each do |data|
+          convert=data.collect {|i| @fields[i] }
+          @pairs.push(convert)
+          [@samples_td, @samples_cd, @samples_gd].each{|s|
+            s[convert]=[]
           }
         end
-        def create_samples_pairs
-            @samples_td={}
-            @samples_cd={}
-            @samples_gd={}
-            @pairs=[]
-            c=Statsample::Combination.new(2,@fields.size)
-            c.each{|data|
-                convert=data.collect {|i|
-                    @fields[i]
-                }
-                @pairs.push(convert)
-                [@samples_td,@samples_cd,@samples_gd].each{|s|
-                    s[convert]=[]
-                }
-            }
-            end
-        def summary(report_type=ConsoleSummary)
-            out =""
-            raise "You should bootstrap first" if @n_samples==0
-            alfa=0.95
-            out.extend report_type
-            out.add _("Summary for Bootstrap Dominance Analysis of %s on %s\n") % [@fields.join(", "), @y_var]
-            out.add _("Sample size: %d\n") % @n_samples
-            t=Distribution::T.p_value(1-((1-alfa) / 2), @n_samples - 1)
-                out.add "t:#{t}\n"
-            out.add "Linear Regression Engine: #{@lr_class.name}"
-            out.nl
-            table=ReportTable.new
-            header=[_("pairs"),"sD","Dij",_("SE(Dij)"),"Pij","Pji","Pno",_("Reproducibility")]
-            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=[@ds.label(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=@ds.label(pair[0])+" - "+@ds.label(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
+      def summary
+        rp=ReportBuilder.new()
+        rp.add(self)
+        rp.to_text
+      end
+      def t
+        Distribution::T.p_value(1-((1-@alpha) / 2), @n_samples - 1)
+      end
+      def to_reportbuilder(generator)
+        raise "You should bootstrap first" if @n_samples==0
+        anchor=generator.add_toc_entry(_("DAB: ")+@name)
+        generator.add_html "<div class='dominance-analysis-bootstrap'>#{@name}<a name='#{anchor}'></a>"
+        
+        generator.add_text _("Sample size: %d\n") % @n_samples
+        generator.add_text "t: #{t}\n"
+        generator.add_text _("Linear Regression Engine: %s") % @regression_class.name
+        
+        table=ReportBuilder::Table.new(:name=>"Bootstrap report", :header => [_("pairs"), "sD","Dij", _("SE(Dij)"), "Pij", "Pji", "Pno", _("Reproducibility")])
+        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))
+        }
+        generator.parse_element(table)
+        
+        table=ReportBuilder::Table.new(:name=>_("General averages"), :header=>[_("var"), _("mean"), _("se"), _("p.5"), _("p.95")])
+        
+        @fields.each{|f|
+          v=@samples_ga[f].to_vector(:scale)
+          row=[@ds.label(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)
+        
+        }
+        
+        generator.parse_element(table)
+        generator.add_html("</div>")
+      end
+      def summary_pairs(pair,std,ttd)
+          freqs=std.proportions
+          [0, 0.5, 1].each{|n|
+              freqs[n]=0 if freqs[n].nil?
+          }
+          name=@ds.label(pair[0])+" - "+@ds.label(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
 end