statsample 0.5.1 → 0.6.0

data/lib/statsample/combination.rb

@@ -40,8 +40,6 @@ module Statsample
     def next_value
         @d.next_value
     end
-    
-    # Ruby engine for Combinations
     class CombinationRuby
       attr_reader :data
       def initialize(k,n)

data/lib/statsample/converter/csv18.rb

@@ -31,7 +31,7 @@ module Statsample
             ds.add_case(rowa,false)
           end
         end
-        convert_to_scale(ds,fields)
+        convert_to_scale_and_date(ds,fields)
         ds.update_valid_data
         ds
       end

data/lib/statsample/converter/csv19.rb

@@ -32,7 +32,7 @@ module Statsample
             ds.add_case(rowa,false)
           end
         end
-        convert_to_scale(ds,fields)
+        convert_to_scale_and_date(ds,fields)
         ds.update_valid_data
         ds
       end

data/lib/statsample/converters.rb

@@ -40,6 +40,7 @@ module Statsample
         query="INSERT INTO #{table} ("+ds.fields.join(",")+") VALUES ("+((["?"]*ds.fields.size).join(","))+")"
         sth=dbh.prepare(query)
         ds.each_array{|c| sth.execute(*c) }
+        return true
       end
       # Create a sql, basen on a given Dataset
       #
@@ -72,182 +73,186 @@ module Statsample
       end
     end
   end
-    class SpreadsheetBase
-        class << self
-            def extract_fields(row)
-                fields=row.to_a.collect{|c| c.downcase}
-                fields.recode_repeated
-            end
-            
-            def process_row(row,empty)
-                row.to_a.collect do |c|
-                    if empty.include?(c)
-                        nil
-                    else
-                        if c.is_a? String and c.is_number?
-                            if c=~/^\d+$/
-                                c.to_i
-                            else
-                                c.gsub(",",".").to_f
-                            end
-                        else
-                            c
-                        end
-                    end
-                end
-            end
-            def convert_to_scale(ds,fields)
-                fields.each do |f|
-                    if ds[f].can_be_scale?
-                        ds[f].type=:scale
-                    end
-                end
+  class SpreadsheetBase
+    class << self
+      def extract_fields(row)
+        fields=row.to_a.collect{|c| c.downcase}
+        fields.recode_repeated
+      end
+    
+      def process_row(row,empty)
+        row.to_a.collect do |c|
+          if empty.include?(c)
+              nil
+          else
+            if c.is_a? String and c.is_number?
+              if c=~/^\d+$/
+                c.to_i
+              else
+                c.gsub(",",".").to_f
+              end
+            else
+              c
             end
-                
+          end
         end
+      end
+      def convert_to_scale_and_date(ds,fields)
+        fields.each do |f|
+          if ds[f].can_be_scale?
+            ds[f].type=:scale
+          elsif ds[f].can_be_date?
+            ds[f].type=:date
+          end
+        end
+      end
+    
     end
+  end
     class PlainText < SpreadsheetBase
-        class << self
-            def read(filename, fields)
-                ds=Statsample::Dataset.new(fields)
-                fp=File.open(filename,"r")
-                fp.each_line do |line|
-                    row=process_row(line.strip.split(/\s+/),[""])
-                    next if row==["\x1A"]
-                    ds.add_case_array(row)
-                end
-                convert_to_scale(ds,fields)
-                ds.update_valid_data
-                ds
-            end
+      class << self
+        def read(filename, fields)
+          ds=Statsample::Dataset.new(fields)
+          fp=File.open(filename,"r")
+          fp.each_line do |line|
+            row=process_row(line.strip.split(/\s+/),[""])
+            next if row==["\x1A"]
+            ds.add_case_array(row)
+          end
+          convert_to_scale_and_date(ds,fields)
+          ds.update_valid_data
+          ds
         end
+      end
     end
-    class Excel < SpreadsheetBase 
-        class << self
-            def write(dataset,filename)
-                require 'spreadsheet'
-                book = Spreadsheet::Workbook.new
-                sheet = book.create_worksheet
-                format = Spreadsheet::Format.new :color => :blue,
-                                   :weight => :bold
-                sheet.row(0).concat(dataset.fields)
-                sheet.row(0).default_format = format
-                i=1
-                dataset.each_array{|row|
-                    sheet.row(i).concat(row)
-                    i+=1
-                }
-                book.write(filename)
+  class Excel < SpreadsheetBase 
+    class << self
+      # Write a Excel spreadsheet based on a dataset
+      # * TODO: Format nicely date values
+      def write(dataset,filename)
+        require 'spreadsheet'
+        book = Spreadsheet::Workbook.new
+        sheet = book.create_worksheet
+        format = Spreadsheet::Format.new :color => :blue,
+                           :weight => :bold
+        sheet.row(0).concat(dataset.fields)
+        sheet.row(0).default_format = format
+        i=1
+        dataset.each_array{|row|
+          sheet.row(i).concat(row)
+          i+=1
+        }
+        book.write(filename)
+      end
+      # Returns a dataset based on a xls file
+      # USE:
+      #     ds = Statsample::Excel.read("test.xls")
+      #
+      def read(filename, worksheet_id=0, ignore_lines=0, empty=[''])
+        require 'spreadsheet'
+        first_row=true
+        fields=[]
+        fields_data={}
+        ds=nil
+        line_number=0
+        book = Spreadsheet.open filename
+        sheet= book.worksheet worksheet_id
+        sheet.each do |row|
+          begin
+            dates=[]
+            row.formats.each_index{|i|
+              if !row.formats[i].nil? and row.formats[i].number_format=="DD/MM/YYYY"
+                dates.push(i)
+              end
+            }
+            line_number+=1
+            if(line_number<=ignore_lines)
+            #puts "Skip line #{line_number}:#{row.to_s}"
+                next
             end
-            # Returns a dataset based on a xls file
-            # USE:
-            #     ds = Statsample::Excel.read("test.xls")
-            #
-            def read(filename, worksheet_id=0, ignore_lines=0, empty=[''])
-            require 'spreadsheet'
-                first_row=true
-                fields=[]
-                fields_data={}
-                ds=nil
-                line_number=0
-                book = Spreadsheet.open filename
-                sheet= book.worksheet worksheet_id
-                sheet.each do |row|
-                    begin
-                        dates=[]
-                        row.formats.each_index{|i|
-                            if !row.formats[i].nil? and row.formats[i].number_format=="DD/MM/YYYY"
-                                dates.push(i)
-                            end
-                        }
-                    line_number+=1
-                    if(line_number<=ignore_lines)
-                    #puts "Skip line #{line_number}:#{row.to_s}"
-                        next
-                    end
-                    # This should be fixed.
-                    # If we have a Formula, should be resolver first
-                    i=-1
-                    row.collect!{|c|
-                        i+=1
-                        if c.is_a? Spreadsheet::Formula
-                          if(c.value.is_a? Spreadsheet::Excel::Error)
-                            nil
-                          else
-                            c.value
-                          end
-                        elsif dates.include? i and !c.nil? and c.is_a? Numeric
-                            row.date(i)
-                        else
-                            c
-                        end
-                    }
-                    if first_row
-                        fields=extract_fields(row)
-                        ds=Statsample::Dataset.new(fields)
-                        first_row=false
-                    else
-                        rowa=process_row(row,empty)
-                        (fields.size - rowa.size).times {
-                            rowa << nil
-                        }
-                        ds.add_case(rowa,false)
-                    end
-                    rescue => e
-                        error="#{e.to_s}\nError on Line # #{line_number}:#{row.join(",")}"
-                        raise
-                    end
+            # This should be fixed.
+            # If we have a Formula, should be resolver first
+            i=-1
+            row.collect!{|c|
+                i+=1
+                if c.is_a? Spreadsheet::Formula
+                  if(c.value.is_a? Spreadsheet::Excel::Error)
+                    nil
+                  else
+                    c.value
+                  end
+                elsif dates.include? i and !c.nil? and c.is_a? Numeric
+                    row.date(i)
+                else
+                    c
                 end
-                convert_to_scale(ds,fields)
-                ds.update_valid_data
-                ds
+            }
+            if first_row
+              fields=extract_fields(row)
+              ds=Statsample::Dataset.new(fields)
+              first_row=false
+            else
+              rowa=process_row(row,empty)
+              (fields.size - rowa.size).times {
+                rowa << nil
+              }
+              ds.add_case(rowa,false)
             end
+          rescue => e
+              error="#{e.to_s}\nError on Line # #{line_number}:#{row.join(",")}"
+              raise
+          end
         end
+        convert_to_scale_and_date(ds, fields)
+        ds.update_valid_data
+        ds
+      end
     end
-    module Mx
-        class << self
-            def write(dataset,filename,type=:covariance)
-            puts "Writing MX File"
-            File.open(filename,"w") {|fp|
-                fp.puts "! #{filename}"
-                fp.puts "! Output generated by Statsample"
-                fp.puts "Data Ninput=#{dataset.fields.size} Nobservations=#{dataset.cases}"
-                fp.puts "Labels "+dataset.fields.join(" ")
-                case type
-                when :raw
-                    fp.puts "Rectangular"
-                    dataset.each {|row|
-                        out=dataset.fields.collect {|f|
-                            if dataset[f].is_valid? row[f]
-                                row[f]
-                            else
-                                "."
-                            end
-                        }
-                        fp.puts out.join("\t")
-                    }
-                    fp.puts "End Rectangular"
-                when :covariance
-                    fp.puts " CMatrix Full"
-                    cm=Statsample::Bivariate.covariance_matrix(dataset)
-                    d=(0...(cm.row_size)).collect {|row|
-                        (0...(cm.column_size)).collect{|col|
-                            cm[row,col].nil? ? "." : sprintf("%0.3f", cm[row,col])
-                        }.join(" ")
-                    }.join("\n")
-                    fp.puts d
+  end
+  module Mx
+    class << self
+      def write(dataset,filename,type=:covariance)
+        puts "Writing MX File"
+        File.open(filename,"w") do |fp|
+          fp.puts "! #{filename}"
+          fp.puts "! Output generated by Statsample"
+          fp.puts "Data Ninput=#{dataset.fields.size} Nobservations=#{dataset.cases}"
+          fp.puts "Labels "+dataset.fields.join(" ")
+          case type
+            when :raw
+            fp.puts "Rectangular"
+            dataset.each do |row|
+              out=dataset.fields.collect do |f|
+                if dataset[f].is_valid? row[f]
+                  row[f]
+                else
+                  "."
                 end
-            }
+              end
+              fp.puts out.join("\t")
+            end
+            fp.puts "End Rectangular"
+          when :covariance
+            fp.puts " CMatrix Full"
+            cm=Statsample::Bivariate.covariance_matrix(dataset)
+            d=(0...(cm.row_size)).collect {|row|
+              (0...(cm.column_size)).collect{|col|
+                cm[row,col].nil? ? "." : sprintf("%0.3f", cm[row,col])
+              }.join(" ")
+            }.join("\n")
+            fp.puts d
+          end
         end
+      end
     end
-    end
+  end
 	module GGobi
 		class << self
-            def write(dataset,filename,opt={})
-                File.open(filename,"w") {|fp|
-                    fp.write(self.out(dataset,opt))
-                }
-            end
+      def write(dataset,filename,opt={})
+        File.open(filename,"w") {|fp|
+          fp.write(self.out(dataset,opt))
+        }
+      end
 			def out(dataset,opt={})
 				require 'ostruct'
 				default_opt = {:dataname => "Default", :description=>"", :missing=>"NA"}
@@ -291,17 +296,17 @@ EOC
 out
 
 			end
-			def values_definition(c,missing)
-				c.collect{|v|
-                    if v.nil?
-                        "#{missing}"
-                    elsif v.is_a? Numeric
-						"#{v}"
-					else
-						"#{v.gsub(/\s+/,"_")}"
-					end
-				}.join(" ")
-			end
+      def values_definition(c,missing)
+        c.collect{|v|
+          if v.nil?
+            "#{missing}"
+          elsif v.is_a? Numeric
+            "#{v}"
+          else
+            "#{v.gsub(/\s+/,"_")}"
+          end
+        }.join(" ")
+      end
 			# Outputs a string for a variable definition
 			# v = vector
 			# name = name of the variable

data/lib/statsample/crosstab.rb

@@ -3,163 +3,236 @@ module Statsample
 	# With this, you can create reports and do chi square test
 	# The first vector will be at rows and the second will the the columns
 	#
-    class Crosstab
-        include GetText
-        bindtextdomain("statsample")
-		attr_reader :v_rows, :v_cols
-        attr_accessor :row_label, :column_label
-		def initialize(v1,v2)
-			raise ArgumentError, "Both arguments should be Vectors" unless v1.instance_of? Vector and v2.instance_of? Vector
-			raise ArgumentError, "Vectors should be the same size" unless v1.size==v2.size
-			@v_rows,@v_cols=v1,v2
-		end	
-		def rows_names
-			@v_rows.factors.sort
-		end
-		def cols_names
-			@v_cols.factors.sort
-		end
-		def rows_total
-			@v_rows.frequencies
-		end
-		def cols_total
-			@v_cols.frequencies
-		end
-		def frequencies
-      base=rows_names.inject([]){|s,row| 
-        s+=cols_names.collect{|col| [row,col]}
-      }.inject({}) {|s,par|
-        s[par]=0
-        s
-      }
-			base.update(Statsample::vector_cols_matrix(@v_rows,@v_cols).to_a.to_vector.frequencies)
-		end
+  class Crosstab
+    include GetText
+    bindtextdomain("statsample")
+    attr_reader :v_rows, :v_cols
+    attr_accessor :row_label, :column_label, :name, :percentage_row, :percentage_column, :percentage_total
+    def initialize(v1,v2,opts=Hash.new)
+    raise ArgumentError, "Both arguments should be Vectors" unless v1.is_a? Statsample::Vector and v2.is_a? Statsample::Vector
+    raise ArgumentError, "Vectors should be the same size" unless v1.size==v2.size
+    @v_rows, @v_cols=Statsample.only_valid(v1,v2)
+    @cases=@v_rows.size
+    @row_label=nil
+    @column_label=nil
+    @name=nil
+    @percentage_row=@percentage_column=@percentage_total=false
+    opts.each{|k,v|
+      self.send("#{k}=",v) if self.respond_to? k
+    }
+    if(@name.nil?)
+      if (!@row_label.nil? and !@column_label.nil?)
+        @name=_("Crosstab %s - %s") % [@row_label, @column_label]
+      else
+        @name=_("Crosstab")
+      end
+    end
+    end	
+    def rows_names
+    @v_rows.factors.sort
+    end
+    def cols_names
+    @v_cols.factors.sort
+    end
+    def rows_total
+    @v_rows.frequencies
+    end
+    def cols_total
+    @v_cols.frequencies
+    end
+    def frequencies
+    base=rows_names.inject([]){|s,row| 
+      s+=cols_names.collect{|col| [row,col]}
+    }.inject({}) {|s,par|
+      s[par]=0
+      s
+    }
+    base.update(Statsample::vector_cols_matrix(@v_rows,@v_cols).to_a.to_vector.frequencies)
+    end
     def to_matrix
-        f=frequencies
-        rn=rows_names
-        cn=cols_names
-        Matrix.rows(rn.collect{|row|
-            cn.collect{|col| f[[row,col]]}
-        })
+      f=frequencies
+      rn=rows_names
+      cn=cols_names
+      Matrix.rows(rn.collect{|row|
+          cn.collect{|col| f[[row,col]]}
+      })
     end
-        def frequencies_by_row
-            f=frequencies
-            rows_names.inject({}){|sr,row|
-                sr[row]=cols_names.inject({}) {|sc,col|
-                    sc[col]=f[[row,col]]
-                    sc
-                }
-                sr
-            }
-        end
-        def frequencies_by_col
-            f=frequencies
-            cols_names.inject({}){|sc,col|
-                sc[col]=rows_names.inject({}) {|sr,row|
-                    sr[row]=f[[row,col]]
-                    sr
-                }
-                sc
-            }
-        end
-        # Chi square, based on expected and real matrix
-        def chi_square
-            require 'statsample/test'
-            Statsample::Test.chi_square(self.to_matrix, matrix_expected)
-        end
-        # Useful to obtain chi square
-        def matrix_expected
-            rn=rows_names
-            cn=cols_names
-            rt=rows_total
-            ct=cols_total
-            t=@v_rows.size.to_f
-            m=rn.collect{|row|
-                cn.collect{|col|
-                    (rt[row]*ct[col]) / t 
-                }
-            }
-            Matrix.rows(m)
+    def frequencies_by_row
+    f=frequencies
+    rows_names.inject({}){|sr,row|
+      sr[row]=cols_names.inject({}) {|sc,col| sc[col]=f[[row,col]]; sc}
+      sr
+    }
+    end
+    def frequencies_by_col
+      f=frequencies
+      cols_names.inject({}){|sc,col| 
+        sc[col]=rows_names.inject({}) {|sr,row| sr[row]=f[[row,col]]; sr}
+        sc
+      }
+    end
+    # Chi square, based on expected and real matrix
+    def chi_square
+        require 'statsample/test'
+        Statsample::Test.chi_square(self.to_matrix, matrix_expected)
+    end
+    # Useful to obtain chi square
+    def matrix_expected
+      rn=rows_names
+      cn=cols_names
+      rt=rows_total
+      ct=cols_total
+      t=@v_rows.size
+      m=rn.collect{|row|
+        cn.collect{|col|
+          (rt[row]*ct[col]).quo(t) 
+          }
+      }
+      Matrix.rows(m)
+    end
+    def cols_empty_hash
+      cols_names.inject({}) {|a,x| a[x]=0;a}
+    end
+    def to_reportbuilder(generator)
+      anchor=generator.add_toc_entry(_("Crosstab: ")+name)
+      generator.add_html "<div class='crosstab'>"+_("Crosstab")+" #{@name}<a name='#{anchor}'></a>"
+      fq=frequencies
+      rn=rows_names
+      cn=cols_names
+      total=0
+      total_cols=cols_empty_hash
+      generator.add_text "Chi Square: #{chi_square}"
+      generator.add_text(_("Rows: %s") % @row_label) unless @row_label.nil?
+      generator.add_text(_("Columns: %s") % @column_label) unless @column_label.nil?
+      
+      t=ReportBuilder::Table.new(:name=>@name+" - "+_("Raw"), :header=>[""]+cols_names.collect {|c| @v_cols.labeling(c)}+[_("Total")])
+      rn.each do |row|
+        total_row=0
+        t_row=[@v_rows.labeling(row)]
+        cn.each do |col|
+          data=fq[[row,col]]
+          total_row+=fq[[row,col]]
+          total+=fq[[row,col]]                    
+          total_cols[col]+=fq[[row,col]]                    
+          t_row.push(data)
         end
-        def cols_empty_hash
-          cols_names.inject({}) {|a,x| a[x]=0;a}
+        t_row.push(total_row)
+        t.add_row(t_row)
+      end
+      t.add_horizontal_line
+      t_row=[_("Total")]
+      cn.each do |v|
+        t_row.push(total_cols[v])
+      end
+      t_row.push(total)
+      t.add_row(t_row)
+      generator.parse_element(t)
+      
+      if(@percentage_row)
+        table_percentage(generator,:row)
+      end
+      if(@percentage_column)
+      table_percentage(generator,:column)
+      end
+      if(@percentage_total)
+      table_percentage(generator,:total)
+      end
+      
+      generator.add_html("</div>")
+    end
+      
+    
+  
+    def table_percentage(generator,type)
+      fq=frequencies
+      cn=cols_names
+      rn=rows_names
+      rt=rows_total
+      ct=cols_total
+      
+      type_name=case type
+        when :row     then  _("% Row")
+        when :column  then  _("% Column")
+        when :total   then  _("% Total")
+      end
+      
+      t=ReportBuilder::Table.new(:name=>@name+" - "+_(type_name), :header=>[""]+cols_names.collect {|c| @v_cols.labeling(c) } + [_("Total")])
+        rn.each do |row|
+          t_row=[@v_rows.labeling(row)]
+          cn.each do |col|
+            total=case type
+              when :row     then  rt[row]
+              when :column  then  ct[col]
+              when :total   then  @cases
+            end
+            data = sprintf("%0.2f%%", fq[[row,col]]*100.0/ total )
+            t_row.push(data)
+          end
+          total=case type
+            when :row     then  rt[row]
+            when :column  then  @cases
+            when :total   then  @cases
+          end              
+          t_row.push(sprintf("%0.2f%%", rt[row]*100.0/total))
+          t.add_row(t_row)
         end
         
-        def summary(report_type = ConsoleSummary)
-            out=""
-            out.extend report_type
-            fq=frequencies
-            rn=rows_names
-            cn=cols_names
-            total=0
-            total_cols=cols_empty_hash
-            out.add "Chi Square: #{chi_square}\n"
-            out.add(_("Rows: %s\n") % @row_label) unless @row_label.nil?
-            out.add(_("Columns: %s\n") % @column_label) unless @column_label.nil?
-            
-            t=Statsample::ReportTable.new([""]+cols_names+[_("Total")])
-            rn.each{|row|
-                total_row=0
-                t_row=[@v_rows.labeling(row)]
-                cn.each{|col|
-                    data=fq[[row,col]]
-                    total_row+=fq[[row,col]]
-                    total+=fq[[row,col]]                    
-                    total_cols[col]+=fq[[row,col]]                    
-                    t_row.push(data)
-                }
-                t_row.push(total_row)
-                t.add_row(t_row)
-            }
-            t.add_horizontal_line
-            t_row=[_("Total")]
-            cn.each{|v|
-                t_row.push(total_cols[v])
-            }
-            t_row.push(total)
-            t.add_row(t_row)
-            out.parse_table(t)
-            out
-        end
-        def to_s
-            fq=frequencies
-            rn=rows_names
-            cn=cols_names
-            total=0
-            total_cols=cols_empty_hash
-            max_row_size = rn.inject(0) {|s,x| sl=@v_rows.labeling(x).size; sl>s ? sl : s}
-            
-            max_row_size=max_row_size<6 ? 6 : max_row_size
-            
-            max_col_size = cn.inject(0) {|s,x| sl=@v_cols.labeling(x).size; sl>s ? sl : s}
-            max_col_size = frequencies.inject(max_col_size) {|s,x| x[1].to_s.size>s ? x[1].to_s.size : s}
-            
-            out=""
-            out << " " * (max_row_size+2) << "|" << cn.collect{|c| name=@v_cols.labeling(c); " "+name+(" "*(max_col_size-name.size))+" "}.join("|") << "| Total\n"
-            linea="-" * (max_row_size+2) << "|" << ("-"*(max_col_size+2) +"|")*cn.size << "-"*7 << "\n"
-            out << linea
-            rn.each{|row|
-                total_row=0;
-                name=@v_rows.labeling(row)
-                out << " " +name  << " "*(max_row_size-name.size) << " | "
-                cn.each{|col|
-                    data=fq[[row,col]].to_s
-                    total_row+=fq[[row,col]]
-                    total+=fq[[row,col]]                    
-                    total_cols[col]+=fq[[row,col]]                    
-                    out << " " << data << " "*(max_col_size-data.size) << "| "
-                }
-                out << " " << total_row.to_s
-            out << "\n"
-            }
-            out << linea
-            out << " Total " << " "*(max_row_size-5) << "| "
-            cn.each{|v|
-                data=total_cols[v].to_s
-                out << " " << data << " "*(max_col_size-data.size) << "| "
-            }
-            out << " " << total.to_s
-            out
-        end
-	end
+        t.add_horizontal_line
+        t_row=[_("Total")]
+        cn.each{|col|
+          total=case type
+            when :row     then  @cases
+            when :column  then  ct[col]
+            when :total   then  @cases
+          end
+          t_row.push(sprintf("%0.2f%%", ct[col]*100.0/total))
+        }
+      t_row.push("100%")
+      t.add_row(t_row)
+      generator.parse_element(t)
+    end
+  
+  
+    
+    def to_s
+      fq=frequencies
+      rn=rows_names
+      cn=cols_names
+      total=0
+      total_cols=cols_empty_hash
+      max_row_size = rn.inject(0) {|s,x| sl=@v_rows.labeling(x).size; sl>s ? sl : s}
+      
+      max_row_size=max_row_size<6 ? 6 : max_row_size
+      
+      max_col_size = cn.inject(0) {|s,x| sl=@v_cols.labeling(x).size; sl>s ? sl : s}
+      max_col_size = frequencies.inject(max_col_size) {|s,x| x[1].to_s.size>s ? x[1].to_s.size : s}
+      
+      out=""
+      out << " " * (max_row_size+2) << "|" << cn.collect{|c| name=@v_cols.labeling(c); " "+name+(" "*(max_col_size-name.size))+" "}.join("|") << "| Total\n"
+      linea="-" * (max_row_size+2) << "|" << ("-"*(max_col_size+2) +"|")*cn.size << "-"*7 << "\n"
+      out << linea
+      rn.each{|row|
+          total_row=0;
+          name=@v_rows.labeling(row)
+          out << " " +name  << " "*(max_row_size-name.size) << " | "
+          cn.each{|col|
+              data=fq[[row,col]].to_s
+              total_row+=fq[[row,col]]
+              total+=fq[[row,col]]                    
+              total_cols[col]+=fq[[row,col]]                    
+              out << " " << data << " "*(max_col_size-data.size) << "| "
+          }
+          out << " " << total_row.to_s
+      out << "\n"
+      }
+      out << linea
+      out << " Total " << " "*(max_row_size-5) << "| "
+      cn.each{|v|
+          data=total_cols[v].to_s
+          out << " " << data << " "*(max_col_size-data.size) << "| "
+      }
+      out << " " << total.to_s
+      out
+    end
+  end
 end