statsample 0.5.1 → 0.6.0

data/lib/statsample/resample.rb

@@ -1,20 +1,15 @@
 module Statsample
-    module Resample
-        class << self
-            def repeat_and_save(times,&action)
-                (1..times).inject([]) {|a,x|
-                    a.push(action.call)
-                    a
-                }
-            end
-            
-            def generate (size,low,upper)
-                range=upper-low+1
-                Vector.new((0...size).collect {|x|
-                    rand(range)+low
-                },:scale)
-            end
-                    
-        end
+  module Resample
+    class << self
+      def repeat_and_save(times,&action)
+        (1..times).inject([]) {|a,x| a.push(action.call); a}
+      end
+      
+      def generate (size,low,upper)
+        range=upper-low+1
+        Vector.new((0...size).collect {|x| rand(range)+low },:scale)
+      end
+              
     end
+  end
 end

data/lib/statsample/srs.rb

@@ -35,6 +35,8 @@ module Statsample
             n0=estimation_n0(d,prop,margin)
             n0.quo( 1 + ((n0 - 1).quo(n_pobl)))
         end
+        
+        
         # Proportion confidence interval with t values
         # Uses estimated proportion, sample without replacement.
         
@@ -42,6 +44,7 @@ module Statsample
             t = Distribution::T.p_value(1-((1-margin).quo(2)) , n_sample-1)
             proportion_confidence_interval(prop,n_sample,n_population, t)
         end
+        
         # Proportion confidence interval with z values
         # Uses estimated proportion, sample without replacement.
         def proportion_confidence_interval_z(p, n_sample, n_population, margin=0.95)
@@ -53,7 +56,7 @@ module Statsample
         
         def proportion_confidence_interval(p, sam,pop , x)
             f=sam.quo(pop)
-            one_range=x * Math::sqrt((qf(sam, pop) * p * (1-p)) / (sam-1)) + (1.quo(sam * 2.0))
+            one_range=x * Math::sqrt((qf(sam, pop) * p * (1-p)).quo (sam-1)) + (1.quo(sam * 2.0))
             [p-one_range, p+one_range]
         end
         # Standard deviation for sample distribution of a proportion

data/lib/statsample/test.rb

@@ -1,25 +1,26 @@
 module Statsample
-    # module for several statistical tests 
-    module Test
-        # Calculate chi square for two Matrix
-        class << self
-            def chi_square(real,expected)
-                raise TypeError, "Both argument should be Matrix" unless real.is_a? Matrix and expected.is_a?Matrix
-                sum=0
-                (0...real.row_size).each {|row_i|
-                    (0...real.column_size).each {|col_i|
-					
-                        val=((real[row_i,col_i].to_f - expected[row_i,col_i].to_f)**2) / expected[row_i,col_i].to_f
-                        # puts "Real: #{real[row_i,col_i].to_f} ; esperado: #{expected[row_i,col_i].to_f}"
-						# puts "Diferencial al cuadrado: #{(real[row_i,col_i].to_f - expected[row_i,col_i].to_f)**2}"
-                        sum+=val
-                    }
-                }
-                sum
-            end
-            def t_significance
-                
-            end
-        end
+  # Module for several statistical tests
+  
+  module Test
+    autoload(:UMannWhitney, 'statsample/test/umannwhitney')
+    # Calculate chi square for two Matrix
+    class << self
+      def chi_square(real,expected)
+        raise TypeError, "Both argument should be Matrix" unless real.is_a? Matrix and expected.is_a?Matrix
+        sum=0
+        (0...real.row_size).each {|row_i|
+          (0...real.column_size).each {|col_i|
+            val=((real[row_i,col_i].to_f - expected[row_i,col_i].to_f)**2) / expected[row_i,col_i].to_f
+            # puts "Real: #{real[row_i,col_i].to_f} ; esperado: #{expected[row_i,col_i].to_f}"
+# puts "Diferencial al cuadrado: #{(real[row_i,col_i].to_f - expected[row_i,col_i].to_f)**2}"
+            sum+=val
+          }
+        }
+        sum
+      end
+      def u_mannwhitney(v1p,v2p)
+        Statsample::Test::UMannWhitney.new(v1p,v2p)
+      end
     end
+  end
 end

data/lib/statsample/test/umannwhitney.rb

@@ -0,0 +1,182 @@
+module Statsample
+  module Test
+    #
+    # = U Mann-Whitney test
+    #
+    # Non-parametric test for assessing whether two independent samples
+    # of observations come from the same distribution.
+    # 
+    # == Assumptions
+    #
+    # * The two samples under investigation in the test are independent of each other and the observations within each sample are independent.
+    # * The observations are comparable (i.e., for any two observations, one can assess whether they are equal or, if not, which one is greater).
+    # * The variances in the two groups are approximately equal.
+    #
+    # Higher differences of distributions correspond to 
+    # to lower values of U.
+    #
+    class UMannWhitney
+      # Max for m*n allowed for exact calculation of probability
+      MAX_MN_EXACT=10000
+      
+      # Exact probability based on Dinneen & Blakesley (1973) algorithm
+      # This is the algorithm used on SPSS
+      #
+      # Reference: Dinneen, L., & Blakesley, B. (1973). Algorithm AS 62: A Generator for the Sampling Distribution of the Mann- Whitney U Statistic. Journal of the Royal Statistical Society, 22(2), 269-273
+      # 
+      def self.exact_probability_distribution_as62(n1,n2)
+
+        freq=[]
+        work=[]
+        mn1=n1*n2+1
+        max_u=n1*n2
+        minmn=n1<n2 ? n1 : n2
+        maxmn=n1>n2 ? n1 : n2
+        n1=maxmn+1
+        (1..n1).each{|i| freq[i]=1}
+        n1+=1
+        (n1..mn1).each{|i| freq[i]=0}
+        work[1]=0
+        xin=maxmn
+        (2..minmn).each do |i|
+          work[i]=0
+          xin=xin+maxmn
+          n1=xin+2
+          l=1+xin.quo(2)
+          k=i
+          (1..l).each do |j|
+            k=k+1
+            n1=n1-1
+            sum=freq[j]+work[j]
+            freq[j]=sum
+            work[k]=sum-freq[n1]
+            freq[n1]=sum
+          end
+        end
+        
+        # Generate percentages for normal U
+        dist=(1+max_u/2).to_i
+        freq.shift
+        total=freq.inject(0) {|a,v| a+v }
+        (0...dist).collect {|i|
+          if i!=max_u-i
+            ues=freq[i]*2
+          else
+            ues=freq[i]
+          end
+          ues.quo(total)
+        }
+      end
+      
+      # Generate distribution for permutations
+      
+      def self.distribution_permutations(n1,n2)
+        base=[0]*n1+[1]*n2
+        po=Statsample::Permutation.new(base)
+        upper=0
+        total=n1*n2
+        req={}
+        po.each do |perm|
+          r0,s0=0,0
+          perm.each_index {|c_i|
+            if perm[c_i]==0
+              r0+=c_i+1
+              s0+=1
+            end
+          }
+          u1=r0-((s0*(s0+1)).quo(2))
+          u2=total-u1
+          temp_u= (u1 <= u2) ? u1 : u2
+          req[perm]=temp_u
+        end
+        req
+      end
+      # Sample 1 Rank sum
+      attr_reader :r1
+      # Sample 2 Rank sum
+      attr_reader :r2
+      # Sample 1 U
+      attr_reader :u1
+      # Sample 2 U
+      attr_reader :u2
+      # U Value
+      attr_reader :u
+      # Compensation for ties
+      attr_reader :t
+      def initialize(v1,v2)
+        @n1=v1.valid_data.size
+        @n2=v2.valid_data.size
+
+        data=(v1.valid_data+v2.valid_data).to_scale
+        groups=(([0]*@n1)+([1]*@n2)).to_vector
+        ds={'g'=>groups, 'data'=>data}.to_dataset
+        @t=nil
+        @ties=data.data.size!=data.data.uniq.size        
+        if(@ties)
+          adjust_for_ties(ds['data'])
+        end
+        ds['ranked']=ds['data'].ranked(:scale)
+        
+        @n=ds.cases
+          
+        @r1=ds.filter{|r| r['g']==0}['ranked'].sum
+        @r2=((ds.cases*(ds.cases+1)).quo(2))-r1
+        @u1=r1-((@n1*(@n1+1)).quo(2))
+        @u2=r2-((@n2*(@n2+1)).quo(2))
+        @u=(u1<u2) ? u1 : u2
+      end
+      def summary
+        out=<<-HEREDOC
+Mann-Whitney U
+Sum of ranks v1: #{@r1.to_f}
+Sum of ranks v1: #{@r2.to_f}
+U Value: #{@u.to_f}
+Z: #{sprintf("%0.3f",z)} (p: #{sprintf("%0.3f",z_probability)})
+        HEREDOC
+        if @n1*@n2<MAX_MN_EXACT
+          out+="Exact p (Dinneen & Blakesley): #{sprintf("%0.3f",exact_probability)}"
+        end
+          out
+      end
+      # Exact probability of finding values of U lower or equal to sample on U distribution. Use with caution with m*n>100000
+      # Reference: Dinneen & Blakesley (1973)
+      def exact_probability
+        dist=UMannWhitney.exact_probability_distribution_as62(@n1,@n2)
+        sum=0
+        (0..@u.to_i).each {|i|
+          sum+=dist[i]
+        }
+        sum
+      end
+      # Reference: http://europe.isixsigma.com/library/content/c080806a.asp
+      def adjust_for_ties(data)
+        @t=data.frequencies.find_all{|k,v| v>1}.inject(0) {|a,v|
+          a+(v[1]**3-v[1]).quo(12)
+        }        
+      end
+      # Z value for U, with adjust for ties.
+      # For large samples, U is approximately normally distributed. 
+      # In that case, you can use z to obtain probabily for U.
+      # Reference: SPSS Manual
+      def z
+        mu=(@n1*@n2).quo(2)
+        if(!@ties)
+          ou=Math::sqrt(((@n1*@n2)*(@n1+@n2+1)).quo(12))
+        else
+          n=@n1+@n2
+          first=(@n1*@n2).quo(n*(n-1))
+          second=((n**3-n).quo(12))-@t
+          ou=Math::sqrt(first*second)
+        end
+        (@u-mu).quo(ou)
+      end
+      # Assuming H_0, the proportion of cdf with values of U lower
+      # than the sample. 
+      # Use with more than 30 cases per group.
+      def z_probability
+        (1-Distribution::Normal.cdf(z.abs()))*2
+      end
+    end
+      
+  end
+end

data/lib/statsample/vector.rb

@@ -1,3 +1,4 @@
+require 'date'
 class Array
     # Creates a new Statsample::Vector object
     # Argument should be equal to Vector.new
@@ -9,25 +10,24 @@ class Array
         Statsample::Vector.new(self,:scale,*args)
     end
 end
-
 module Statsample
-    class << self
-        # Create a matrix using vectors as columns.
-        # Use:
-        #
-        #   matrix=Statsample.vector_cols_matrix(v1,v2)
-        def vector_cols_matrix(*vs)
-            # test
-            size=vs[0].size
-            vs.each{|v|
-                raise ArgumentError,"Arguments should be Vector" unless v.instance_of? Statsample::Vector
-                raise ArgumentError,"Vectors size should be the same" if v.size!=size
-            }
-            Matrix.rows((0...size).to_a.collect() {|i|
-                vs.collect{|v| v[i]}
-            })
-        end
-    end
+  class << self
+    # Create a matrix using vectors as columns.
+    # Use:
+    #
+    #   matrix=Statsample.vector_cols_matrix(v1,v2)
+    def vector_cols_matrix(*vs)
+      # test
+      size=vs[0].size
+      vs.each{|v|
+        raise ArgumentError,"Arguments should be Vector" unless v.instance_of? Statsample::Vector
+        raise ArgumentError,"Vectors size should be the same" if v.size!=size
+      }
+      Matrix.rows((0...size).to_a.collect() {|i|
+        vs.collect{|v| v[i]}
+      })
+    end
+  end
 	# Returns a duplicate of the input vectors, without missing data
 	# for any of the vectors.
 	# 
@@ -46,834 +46,873 @@ module Statsample
 		ds.vectors.values
 	end
     
-    class Vector
-    include Enumerable
-    include Writable
-        DEFAULT_OPTIONS={
-        :missing_values=>[],
-        :labels=>{}
+  class Vector
+  include Enumerable
+  include Writable
+  DEFAULT_OPTIONS={
+    :missing_values=>[],
+    :today_values=>['NOW','TODAY', :NOW, :TODAY],
+    :labels=>{}
+  }
+  # Level of measurement. Could be :nominal, :ordinal or :scale
+  attr_reader :type
+  # Original data. 
+  attr_reader :data
+  # Valid data. Equal to data, minus values assigned as missing values
+  attr_reader :valid_data
+  # Array of values considered as missing. Nil is a missing value, by default
+  attr_reader :missing_values 
+  # Array of values considered as "Today", with date type. "NOW", "TODAY", :NOW and :TODAY are 'today' values, by default
+  attr_reader :today_values
+  # Missing values array
+  attr_reader :missing_data
+  # Original data, with all missing values replaced by nils
+  attr_reader :data_with_nils
+  # Date date, with all missing values replaced by nils
+  attr_reader :date_data_with_nils
+  # GSL Object, only available with rbgsl extension and type==:scale
+  attr_reader :gsl
+  # Change label for specific values
+  attr_accessor :labels
+  # Creates a new Vector object.
+  # [data]            Array of data.
+  # [type]            Level of meausurement. See Vector#type
+  # [opts]            Options
+  #   [:missing_values]  Array of missing values. See Vector#missing_values
+  #   [:today_values] Array of 'today' values. See Vector#today_values
+  #   [:labels]          Labels for data values
+  #
+  # The fast way to create a vector uses Array.to_vector or Array.to_scale.
+  #
+  #  v=[1,2,3,4].to_vector(:scale)
+  #  v=[1,2,3,4].to_scale
+  #
+  
+  def initialize(data=[], t=:nominal, opts=Hash.new)
+    raise "Data should be an array" unless data.is_a? Array
+    @data=data
+    @type=t
+    opts=DEFAULT_OPTIONS.merge(opts)
+    @missing_values=opts[:missing_values]
+    @labels=opts[:labels]
+    @today_values=opts[:today_values]
+    @valid_data=[]
+    @data_with_nils=[]
+    @date_data_with_nils=[]
+    @missing_data=[]
+    @has_missing_data=nil
+    @scale_data=nil
+    set_valid_data_intern
+    self.type=t
+  end
+  # Creates a duplicate of the Vector.
+  # Note: data, missing_values and labels are duplicated, so
+  # changes on original vector doesn't propages to copies.
+  def dup
+    Vector.new(@data.dup,@type, :missing_values => @missing_values.dup, :labels => @labels.dup)
+  end
+  # Returns an empty duplicate of the vector. Maintains the type,
+  # missing values and labels.
+  def dup_empty
+    Vector.new([],@type, :missing_values => @missing_values.dup, :labels => @labels.dup)
+  end
+  # Raises an exception if type of vector is inferior to t type
+  def check_type(t)
+    raise NoMethodError if (t==:scale and @type!=:scale) or (t==:ordinal and @type==:nominal) or (t==:date)
+  end
+  private :check_type
+  
+  # Return a vector usign the standarized values for data
+  # with sd with denominator N
+  def vector_standarized_pop
+      vector_standarized(true)
+  end
+  # Return a vector usign the standarized values for data
+  # with sd with denominator n-1
+  
+  def vector_standarized(use_population=false)
+    raise "Should be a scale" unless @type==:scale
+    m=mean
+    sd=use_population ? sdp : sds
+    @data_with_nils.collect{|x|
+      if !x.nil?
+        (x.to_f - m).quo(sd)
+      else
+        nil
+      end
+    }.to_vector(:scale)
+  end
+  
+  alias_method :standarized, :vector_standarized
+  
+  def box_cox_transformation(lambda) # :nodoc:
+    raise "Should be a scale" unless @type==:scale
+    @data_with_nils.collect{|x|
+    if !x.nil?
+      if(lambda==0)
+        Math.log(x)
+      else
+        (x**lambda-1).quo(lambda)
+      end
+    else
+      nil
+    end
+    }.to_vector(:scale)
+  end
+  
+  # Vector equality.
+  # Two vector will be the same if their data, missing values, type, labels are equals
+  def ==(v2)
+    raise TypeError,"Argument should be a Vector" unless v2.instance_of? Statsample::Vector
+    @data==v2.data and @missing_values==v2.missing_values and @type==v2.type and @labels=v2.labels
+  end
+  
+  def _dump(i) # :nodoc:
+    Marshal.dump({'data'=>@data,'missing_values'=>@missing_values, 'labels'=>@labels, 'type'=>@type})
+  end
+  
+  def self._load(data) # :nodoc:
+    h=Marshal.load(data)
+    Vector.new(h['data'], h['type'],:missing_values=> h['missing_values'], :labels=>h['labels'])
+  end
+  # Returns a new vector, with data modified by block.
+  # Equivalent to create a Vector after #collect on data 
+  def recode
+    @data.collect{|x|
+      yield x
+    }.to_vector(@type)
+  end
+  # Modifies current vector, with data modified by block.
+  # Equivalent to #collect! on @data 
+  def recode!
+    @data.collect!{|x|
+      yield x
     }
-    # Level of measurement. Could be :nominal, :ordinal or :scale
-    attr_reader :type
-    # Original data. 
-    attr_reader :data
-    # Valid data. Equal to data, minus values assigned as missing values
-    attr_reader :valid_data
-    # Array of values considered as missing. Nil is a missing value, by default
-    attr_reader :missing_values 
-    # Missing values array
-    attr_reader :missing_data
-    # Original data, with all missing values replaced by nils
-    attr_reader :data_with_nils
-    # GSL Object, only available with rbgsl extension and type==:scale
-    attr_reader :gsl
-    # Change label for specific values
-    attr_accessor :labels
-    # Creates a new Vector object.
-    # [data]            Array of data.
-    # [type]            Level of meausurement. See Vector#type
-    # [opts]            Options
-    #   [:missing_values]  Array of missing values. See Vector#missing_values
-    #   [:labels]          Labels for data values
-    #
-    # The fast way to create a vector uses Array.to_vector or Array.to_scale.
-    #
-    #  v=[1,2,3,4].to_vector(:scale)
-    #  v=[1,2,3,4].to_scale
-    #
-
-    def initialize(data=[], t=:nominal, opts=Hash.new)
-        raise "Data should be an array" unless data.is_a? Array
-        @data=data
-        @type=t
-        opts=DEFAULT_OPTIONS.merge(opts)
-        @missing_values=opts[:missing_values]
-        @labels=opts[:labels]
-        @valid_data=[]
-        @data_with_nils=[]
-        @missing_data=[]
-        @has_missing_data=nil
-        @scale_data=nil
-        set_valid_data_intern
-        self.type=t
-    end
-    # Creates a duplicate of the Vector.
-    # Note: data, missing_values and labels are duplicated, so
-    # changes on original vector doesn't propages to copies.
-    def dup
-        Vector.new(@data.dup,@type, :missing_values => @missing_values.dup, :labels => @labels.dup)
-    end
-    # Returns an empty duplicate of the vector. Maintains the type,
-    # missing values and labels.
-    def dup_empty
-        Vector.new([],@type, :missing_values => @missing_values.dup, :labels => @labels.dup)
-    end
-    # Raises an exception if type of vector is inferior to t type
-    def check_type(t)
-        raise NoMethodError if (t==:scale and @type!=:scale) or (t==:ordinal and @type==:nominal)
-    end
-    private :check_type
-    
-    # Return a vector usign the standarized values for data
-    # with sd with denominator N
-    def vector_standarized_pop
-        vector_standarized(true)
-    end
-    # Return a vector usign the standarized values for data
-    # with sd with denominator n-1
-    
-    def vector_standarized(use_population=false)
-        raise "Should be a scale" unless @type==:scale
-        m=mean
-        sd=use_population ? sdp : sds
-        @data_with_nils.collect{|x|
-            if !x.nil?
-                (x.to_f - m).quo(sd)
-            else
-                nil
-            end
-        }.to_vector(:scale)
-    end
-    
-    alias_method :standarized, :vector_standarized
-    
-    def box_cox_transformation(lambda) # :nodoc:
-        raise "Should be a scale" unless @type==:scale
-        @data_with_nils.collect{|x|
-        if !x.nil?
-            if(lambda==0)
-                Math.log(x)
-            else
-                (x**lambda-1).quo(lambda)
-            end
-        else
+    set_valid_data
+  end
+  # Dicotomize the vector with 0 and 1, based on lowest value
+  # If parameter if defined, this value and lower
+  # will be 0 and higher, 1
+  def dichotomize(low=nil)
+    fs=factors
+    low||=factors.min
+    @data_with_nils.collect{|x|
+      if x.nil?
+        nil
+      elsif x>low
+        1
+      else
+        0
+      end
+    }.to_scale
+  end
+  # Iterate on each item.
+  # Equivalent to
+  #   @data.each{|x| yield x}
+  def each
+      @data.each{|x| yield(x) }
+  end
+  
+  # Iterate on each item, retrieving index
+  def each_index
+    (0...@data.size).each {|i|
+      yield(i)
+    }
+  end
+  # Add a value at the end of the vector.
+  # If second argument set to false, you should update the Vector usign
+  # Vector.set_valid_data at the end of your insertion cycle
+  #
+  def add(v,update_valid=true)
+    @data.push(v)
+    set_valid_data if update_valid
+  end
+  # Update valid_data, missing_data, data_with_nils and gsl
+  # at the end of an insertion.
+  #
+  # Use after Vector.add(v,false)
+  # Usage:
+  #   v=Statsample::Vector.new
+  #   v.add(2,false)
+  #   v.add(4,false)
+  #   v.data
+  #   => [2,3]
+  #   v.valid_data
+  #   => []
+  #   v.set_valid_data
+  #   v.valid_data
+  #   => [2,3]
+  def set_valid_data
+    @valid_data.clear
+    @missing_data.clear
+    @data_with_nils.clear
+    @date_data_with_nils.clear
+    @gsl=nil
+    set_valid_data_intern
+    set_scale_data if(@type==:scale)
+    set_date_data if(@type==:date)
+  end
+  
+  if Statsample::STATSAMPLE__.respond_to?(:set_valid_data_intern)
+    def set_valid_data_intern #:nodoc:
+      Statsample::STATSAMPLE__.set_valid_data_intern(self)
+    end
+  else
+    def set_valid_data_intern #:nodoc:
+      _set_valid_data_intern                  
+    end
+  end
+  def _set_valid_data_intern #:nodoc:
+    @data.each do |n|
+      if is_valid? n
+        @valid_data.push(n)
+        @data_with_nils.push(n)
+      else
+        @data_with_nils.push(nil)
+        @missing_data.push(n)
+      end
+    end
+    @has_missing_data=@missing_data.size>0
+  end
+  
+  # Retrieves true if data has one o more missing values
+  def has_missing_data?
+    @has_missing_data
+  end
+  # Retrieves label for value x. Retrieves x if
+  # no label defined.
+  def labeling(x)
+    @labels.has_key?(x) ? @labels[x].to_s : x.to_s
+  end
+  # Returns a Vector with data with labels replaced by the label.
+  def vector_labeled
+    d=@data.collect{|x|
+      if @labels.has_key? x
+        @labels[x]
+      else
+        x
+      end
+    }
+    Vector.new(d,@type)
+  end
+  # Size of total data
+  def size
+    @data.size
+  end
+  alias_method :n, :size
+  
+  # Retrieves i element of data
+  def [](i)
+    @data[i]
+  end
+  # Set i element of data. 
+  # Note: Use set_valid_data if you include missing values
+  def []=(i,v)
+    @data[i]=v
+  end
+  # Return true if a value is valid (not nil and not included on missing values)
+  def is_valid?(x)
+    !(x.nil? or @missing_values.include? x)
+  end
+  # Set missing_values.
+  # if update_valid = false, you should use
+  # set_valid_data after all changes
+  def missing_values=(vals)
+    @missing_values = vals
+    set_valid_data
+  end
+  def today_values=(vals)
+    @today_values = vals
+    set_valid_data
+  end
+  # Set level of measurement. 
+  def type=(t)
+    @type=t	
+    set_scale_data if(t==:scale)
+    set_date_data if (t==:date)
+  end
+  def to_a
+    @data.dup
+  end
+  alias_method :to_ary, :to_a 
+  
+  # Vector sum. 
+  # - If v is a scalar, add this value to all elements
+  # - If v is a Array or a Vector, should be of the same size of this vector
+  #   every item of this vector will be added to the value of the
+  #   item at the same position on the other vector
+  def +(v)
+    _vector_ari("+",v)
+  end
+  # Vector rest. 
+  # - If v is a scalar, rest this value to all elements
+  # - If v is a Array or a Vector, should be of the same 
+  #   size of this vector
+  #   every item of this vector will be rested to the value of the
+  #   item at the same position on the other vector
+  
+  def -(v)
+    _vector_ari("-",v)
+  end
+  # Reports all values that doesn't comply with a condition.
+  # Returns a hash with the index of data and the invalid data.
+  def verify
+    h={}
+    (0...@data.size).to_a.each{|i|
+      if !(yield @data[i])
+        h[i]=@data[i]
+      end
+    }
+    h
+  end
+  def _vector_ari(method,v) # :nodoc:
+    if(v.is_a? Vector or v.is_a? Array)
+      if v.size==@data.size
+      #                    i=0
+      sum=[]
+      0.upto(v.size-1) {|i|
+          if((v.is_a? Vector and v.is_valid?(v[i]) and is_valid?(@data[i])) or (v.is_a? Array and !v[i].nil? and !data[i].nil?))
+              sum.push(@data[i].send(method,v[i]))
+          else
+              sum.push(nil)
+          end
+      }
+      Statsample::Vector.new(sum)
+      else
+      raise ArgumentError, "The array/vector parameter should be of the same size of the original vector"
+      end
+    elsif(v.respond_to? method )
+      Statsample::Vector.new(
+        @data.collect  {|x|
+          if(!x.nil?)
+            x.send(method,v)
+          else
             nil
-        end
-        }.to_vector(:scale)
-    end
-    
-    # Vector equality.
-    # Two vector will be the same if their data, missing values, type, labels are equals
-    def ==(v2)
-        raise TypeError,"Argument should be a Vector" unless v2.instance_of? Statsample::Vector
-        @data==v2.data and @missing_values==v2.missing_values and @type==v2.type and @labels=v2.labels
-    end
-    
-    def _dump(i) # :nodoc:
-        Marshal.dump({'data'=>@data,'missing_values'=>@missing_values, 'labels'=>@labels, 'type'=>@type})
-    end
-    
-    def self._load(data) # :nodoc:
-        h=Marshal.load(data)
-        Vector.new(h['data'], h['type'],:missing_values=> h['missing_values'], :labels=>h['labels'])
-    end
-    # Returns a new vector, with data modified by block.
-    # Equivalent to create a Vector after #collect on data 
-    def recode
-        @data.collect{|x|
-            yield x
-        }.to_vector(@type)
-    end
-    # Modifies current vector, with data modified by block.
-    # Equivalent to #collect! on @data 
-    def recode!
-        @data.collect!{|x|
-            yield x
-        }
-        set_valid_data
-    end
-    # Dicotomize the vector with 0 and 1, based on lowest value
-    # If parameter if defined, this value and lower
-    # will be 0 and higher, 1
-    def dichotomize(low=nil)
-      fs=factors
-      low||=factors.min
-      @data_with_nils.collect{|x|
-        if x.nil?
-          nil
-        elsif x>low
-          1
-        else
-          0
-        end
-      }.to_scale
-    end
-    # Iterate on each item.
-    # Equivalent to
-    #   @data.each{|x| yield x}
-    def each
-        @data.each{|x| yield(x) }
-    end
-    
-    # Iterate on each item, retrieving index
-    def each_index
-        (0...@data.size).each {|i|
-            yield(i)
+          end
         }
-    end
-    # Add a value at the end of the vector.
-    # If second argument set to false, you should update the Vector usign
-    # Vector.set_valid_data at the end of your insertion cycle
-    #
-    def add(v,update_valid=true)
-        @data.push(v)
-        set_valid_data if update_valid
-    end
-    # Update valid_data, missing_data, data_with_nils and gsl
-    # at the end of an insertion.
-    #
-    # Use after Vector.add(v,false)
-    # Usage:
-    #   v=Statsample::Vector.new
-    #   v.add(2,false)
-    #   v.add(4,false)
-    #   v.data
-    #   => [2,3]
-    #   v.valid_data
-    #   => []
-    #   v.set_valid_data
-    #   v.valid_data
-    #   => [2,3]
-    def set_valid_data
-        @valid_data.clear
-        @missing_data.clear
-        @data_with_nils.clear
-        @gsl=nil
-        set_valid_data_intern
-        set_scale_data if(@type==:scale)
-    end
-
-    if Statsample::STATSAMPLE__.respond_to?(:set_valid_data_intern)
-        def set_valid_data_intern #:nodoc:
-            Statsample::STATSAMPLE__.set_valid_data_intern(self)
-        end
+      )
     else
-        def set_valid_data_intern #:nodoc:
-            _set_valid_data_intern                  
-        end
-    end
-    def _set_valid_data_intern #:nodoc:
-        @data.each do |n|
-            if is_valid? n
-                @valid_data.push(n)
-                @data_with_nils.push(n)
-            else
-                @data_with_nils.push(nil)
-                @missing_data.push(n)
-            end
-        end
-        @has_missing_data=@missing_data.size>0
+        raise TypeError,"You should pass a scalar or a array/vector"
     end
-
-    # Retrieves true if data has one o more missing values
-    def has_missing_data?
-        @has_missing_data
-    end
-    # Retrieves label for value x. Retrieves x if
-    # no label defined.
-    def labeling(x)
-        @labels.has_key?(x) ? @labels[x].to_s : x.to_s
-    end
-    # Returns a Vector with data with labels replaced by the label.
-    def vector_labeled
-        d=@data.collect{|x|
-            if @labels.has_key? x
-                @labels[x]
-            else
-                x
-            end
-        }
-        Vector.new(d,@type)
-    end
-    # Size of total data
-    def size
-        @data.size
-    end
-    alias_method :n, :size
-
-    # Retrieves i element of data
-    def [](i)
-        @data[i]
-    end
-    # Set i element of data. 
-    # Note: Use set_valid_data if you include missing values
-    def []=(i,v)
-        @data[i]=v
-    end
-    # Return true if a value is valid (not nil and not included on missing values)
-    def is_valid?(x)
-        !(x.nil? or @missing_values.include? x)
-    end
-    # Set missing_values.
-    # if update_valid = false, you should use
-    # set_valid_data after all changes
-    def missing_values=(vals)
-        @missing_values = vals
-        set_valid_data
-    end
-    # Set level of measurement. 
-    def type=(t)
-        @type=t	
-        set_scale_data if(t==:scale)
-    end
-    def to_a
-        @data.dup
-    end
-    alias_method :to_ary, :to_a 
-    
-    # Vector sum. 
-    # - If v is a scalar, add this value to all elements
-    # - If v is a Array or a Vector, should be of the same size of this vector
-    #   every item of this vector will be added to the value of the
-    #   item at the same position on the other vector
-    def +(v)
-        _vector_ari("+",v)
-    end
-    # Vector rest. 
-    # - If v is a scalar, rest this value to all elements
-    # - If v is a Array or a Vector, should be of the same 
-    #   size of this vector
-    #   every item of this vector will be rested to the value of the
-    #   item at the same position on the other vector
     
-    def -(v)
-        _vector_ari("-",v)
-    end
-    # Reports all values that doesn't comply with a condition.
-    # Returns a hash with the index of data and the invalid data.
-    def verify
-        h={}
-        (0...@data.size).to_a.each{|i|
-            if !(yield @data[i])
-                h[i]=@data[i]
-            end
-        }
-        h
-    end
-    def _vector_ari(method,v) # :nodoc:
-        if(v.is_a? Vector or v.is_a? Array)
-            if v.size==@data.size
-#                    i=0
-                sum=[]
-                0.upto(v.size-1) {|i|
-                    if((v.is_a? Vector and v.is_valid?(v[i]) and is_valid?(@data[i])) or (v.is_a? Array and !v[i].nil? and !data[i].nil?))
-                        sum.push(@data[i].send(method,v[i]))
-                    else
-                        sum.push(nil)
-                    end
-                }
-                Statsample::Vector.new(sum)
-            else
-                raise ArgumentError, "The array/vector parameter should be of the same size of the original vector"
-            end
-        elsif(v.respond_to? method )
-            Statsample::Vector.new(
-                @data.collect  {|x|
-                    if(!x.nil?)
-                    x.send(method,v)
-                    else
-                        nil
-                    end
-                }
-            )
-        else
-            raise TypeError,"You should pass a scalar or a array/vector"
-        end
-        
-    end
-    # Return an array with the data splitted by a separator.
-    #   a=Vector.new(["a,b","c,d","a,b","d"])
-    #   a.splitted
-    #     =>
-    #   [["a","b"],["c","d"],["a","b"],["d"]]
-    def splitted(sep=Statsample::SPLIT_TOKEN)
-        @data.collect{|x|
-            if x.nil?
-                nil
-            elsif (x.respond_to? :split)
-                x.split(sep)
-            else
-                [x]
-            end
-        }
-    end
-    # Returns a hash of Vectors, defined by the different values
-    # defined on the fields
-    # Example:
-    #
-    #  a=Vector.new(["a,b","c,d","a,b"])
-    #  a.split_by_separator
-    #  =>  {"a"=>#<Statsample::Type::Nominal:0x7f2dbcc09d88 
-    #        @data=[1, 0, 1]>, 
-    #       "b"=>#<Statsample::Type::Nominal:0x7f2dbcc09c48 
-    #        @data=[1, 1, 0]>, 
-    #      "c"=>#<Statsample::Type::Nominal:0x7f2dbcc09b08 
-    #        @data=[0, 1, 1]>}
-    #
-    def split_by_separator(sep=Statsample::SPLIT_TOKEN)
-        split_data=splitted(sep)
-        factors=split_data.flatten.uniq.compact
-        out=factors.inject({}) {|a,x|
-            a[x]=[]
-            a
-        }
-        split_data.each{|r|
-            if r.nil?
-                factors.each{|f|
-                    out[f].push(nil)
-                }
-            else
+  end
+  # Return an array with the data splitted by a separator.
+  #   a=Vector.new(["a,b","c,d","a,b","d"])
+  #   a.splitted
+  #     =>
+  #   [["a","b"],["c","d"],["a","b"],["d"]]
+  def splitted(sep=Statsample::SPLIT_TOKEN)
+    @data.collect{|x|
+      if x.nil?
+        nil
+      elsif (x.respond_to? :split)
+        x.split(sep)
+      else
+        [x]
+      end
+    }
+  end
+  # Returns a hash of Vectors, defined by the different values
+  # defined on the fields
+  # Example:
+  #
+  #  a=Vector.new(["a,b","c,d","a,b"])
+  #  a.split_by_separator
+  #  =>  {"a"=>#<Statsample::Type::Nominal:0x7f2dbcc09d88 
+  #        @data=[1, 0, 1]>, 
+  #       "b"=>#<Statsample::Type::Nominal:0x7f2dbcc09c48 
+  #        @data=[1, 1, 0]>, 
+  #      "c"=>#<Statsample::Type::Nominal:0x7f2dbcc09b08 
+  #        @data=[0, 1, 1]>}
+  #
+  def split_by_separator(sep=Statsample::SPLIT_TOKEN)
+    split_data=splitted(sep)
+    factors=split_data.flatten.uniq.compact
+    out=factors.inject({}) {|a,x|
+        a[x]=[]
+        a
+    }
+    split_data.each{|r|
+        if r.nil?
             factors.each{|f|
-                out[f].push(r.include?(f) ? 1:0) 
+                out[f].push(nil)
             }
-            end
-        }
-        out.inject({}){|s,v|
-            s[v[0]]=Vector.new(v[1],:nominal)
-            s
+        else
+        factors.each{|f|
+            out[f].push(r.include?(f) ? 1:0) 
         }
+        end
+    }
+    out.inject({}){|s,v|
+        s[v[0]]=Vector.new(v[1],:nominal)
+        s
+    }
+  end
+  def split_by_separator_freq(sep=Statsample::SPLIT_TOKEN)
+      split_by_separator(sep).inject({}) {|a,v|
+          a[v[0]]=v[1].inject {|s,x| s+x.to_i}
+          a
+      }
+  end
+  
+  # Returns an random sample of size n, with replacement,
+  # only with valid data.
+  #
+  # In all the trails, every item have the same probability
+  # of been selected.
+  def sample_with_replacement(sample=1)
+    if(@type!=:scale or !HAS_GSL)
+      vds=@valid_data.size
+      (0...sample).collect{ @valid_data[rand(vds)] }
+    else
+      r = GSL::Rng.alloc(GSL::Rng::MT19937,rand(10000))
+      r.sample(@gsl, sample).to_a
+    end
+  end
+  # Returns an random sample of size n, without replacement,
+  # only with valid data.
+  #
+  # Every element could only be selected once.
+  # 
+  # A sample of the same size of the vector is the vector itself.
+      
+  def sample_without_replacement(sample=1)
+    if(@type!=:scale or !HAS_GSL)
+      raise ArgumentError, "Sample size couldn't be greater than n" if sample>@valid_data.size
+      out=[]
+      size=@valid_data.size
+      while out.size<sample
+        value=rand(size)
+        out.push(value) if !out.include?value
+      end
+      out.collect{|i|@data[i]}
+    else
+      r = GSL::Rng.alloc(GSL::Rng::MT19937,rand(10000))
+      r.choose(@gsl, sample).to_a
+    end
+  end
+   # Retrieves number of cases which comply condition.
+   # If block given, retrieves number of instances where
+   # block returns true.
+   # If other values given, retrieves the frequency for
+   # this value.
+  def count(x=false)
+    if block_given?
+      r=@data.inject(0) {|s, i|
+        r=yield i
+        s+(r ? 1 : 0)
+      }
+      r.nil? ? 0 : r
+    else
+      frequencies[x].nil? ? 0 : frequencies[x]
+    end
+  end
+  
+  # Returns the database type for the vector, according to its content
+  
+  def db_type(dbs='mysql')
+    # first, detect any character not number
+    if @data.find {|v|  v.to_s=~/\d{2,2}-\d{2,2}-\d{4,4}/} or @data.find {|v|  v.to_s=~/\d{4,4}-\d{2,2}-\d{2,2}/}
+      return "DATE"
+    elsif @data.find {|v|  v.to_s=~/[^0-9e.-]/ }
+      return "VARCHAR (255)"
+    elsif @data.find {|v| v.to_s=~/\./}
+      return "DOUBLE"
+    else
+      return "INTEGER"
+    end
+  end
+  # Return true if all data is Date, "today" values or nil
+  def can_be_date?
+    if @data.find {|v|       
+    !v.nil? and !v.is_a? Date and !v.is_a? Time and (v.is_a? String and !@today_values.include? v) and (v.is_a? String and !(v=~/\d{4,4}[-\/]\d{1,2}[-\/]\d{1,2}/))}
+      false
+    else
+      true
     end
-    def split_by_separator_freq(sep=Statsample::SPLIT_TOKEN)
-        split_by_separator(sep).inject({}) {|a,v|
-            a[v[0]]=v[1].inject {|s,x| s+x.to_i}
+  end
+  # Return true if all data is Numeric or nil
+  def can_be_scale?
+    if @data.find {|v| !v.nil? and !v.is_a? Numeric and !@missing_values.include? v}
+      false
+    else
+      true
+    end
+  end
+  
+  def to_s
+    sprintf("Vector(type:%s, n:%d)[%s]",@type.to_s,@data.size, @data.collect{|d| d.nil? ? "nil":d}.join(","))
+  end
+  # Ugly name. Really, create a Vector for standard 'matrix' package.
+  # <tt>dir</tt> could be :horizontal or :vertical
+  def to_matrix(dir=:horizontal)
+    case dir
+    when :horizontal
+      Matrix[@data]
+    when :vertical
+      Matrix.columns([@data])
+    end
+  end
+  def inspect
+      self.to_s
+  end
+  # Retrieves uniques values for data.
+  def factors
+    if @type==:scale
+      @scale_data.uniq.sort
+    elsif @type==:date
+      @date_data_with_nils.uniq.sort
+    else
+      @valid_data.uniq.sort
+    end
+  end
+  if Statsample::STATSAMPLE__.respond_to?(:frequencies)
+    # Returns a hash with the distribution of frecuencies for
+    # the sample                
+    def frequencies
+      Statsample::STATSAMPLE__.frequencies(@valid_data)
+    end
+  else
+    def frequencies #:nodoc:
+      _frequencies
+    end
+  end
+  def _frequencies #:nodoc:
+    @valid_data.inject(Hash.new) {|a,x|
+      a[x]||=0
+      a[x]=a[x]+1
+      a
+    }
+  end
+  # Plot frequencies on a chart, using gnuplot
+      def plot_frequencies
+      require 'gnuplot'
+      x=[]
+      y=[]
+      self.frequencies.sort.each{|k,v|
+          x.push(k)
+          y.push(v) 
+      }
+      Gnuplot.open do |gp|
+          Gnuplot::Plot.new( gp ) do |plot|
+              plot.boxwidth("0.9 absolute")
+              plot.yrange("[0:#{y.max}]")
+              plot.style("fill  solid 1.00 border -1")
+              plot.set("xtics border in scale 1,0.5 nomirror rotate by -45  offset character 0, 0, 0")
+              plot.style("histogram")
+              plot.style("data histogram")
+              i=-1
+              plot.set("xtics","("+x.collect{|v| i+=1; sprintf("\"%s\" %d",v,i)}.join(",")+")")
+              plot.data << Gnuplot::DataSet.new( [y] ) do |ds|
+                  end
+              end
+          end
+  
+      end
+  
+  
+    # Returns the most frequent item.
+    def mode
+        frequencies.max{|a,b| a[1]<=>b[1]}[0]
+    end
+    # The numbers of item with valid data.
+    def n_valid
+        @valid_data.size
+    end
+    # Returns a hash with the distribution of proportions of
+    # the sample.
+    def proportions
+        frequencies.inject({}){|a,v|
+            a[v[0]] = v[1].quo(n_valid)
             a
         }
     end
-    
-    # Returns an random sample of size n, with replacement,
-    # only with valid data.
-    #
-    # In all the trails, every item have the same probability
-    # of been selected.
-    def sample_with_replacement(sample=1)
-        if(@type!=:scale or !HAS_GSL)
-            vds=@valid_data.size
-            (0...sample).collect{ @valid_data[rand(vds)] }
-        else
-            r = GSL::Rng.alloc(GSL::Rng::MT19937,rand(10000))
-            r.sample(@gsl, sample).to_a
-        end
-    end
-    # Returns an random sample of size n, without replacement,
-    # only with valid data.
-    #
-    # Every element could only be selected once.
-    # 
-    # A sample of the same size of the vector is the vector itself.
-        
-    def sample_without_replacement(sample=1)
-        if(@type!=:scale or !HAS_GSL)
-            raise ArgumentError, "Sample size couldn't be greater than n" if sample>@valid_data.size
-            out=[]
-            size=@valid_data.size
-            while out.size<sample
-            value=rand(size)
-            out.push(value) if !out.include?value
-            end
-            out.collect{|i|@data[i]}
-        else
-            r = GSL::Rng.alloc(GSL::Rng::MT19937,rand(10000))
-            r.choose(@gsl, sample).to_a
+    # Proportion of a given value.
+    def proportion(v=1)
+        frequencies[v].quo(@valid_data.size)
+    end
+    def summary(out="")
+        out << sprintf("n valid:%d\n",n_valid)
+        out <<  sprintf("factors:%s\n",factors.join(","))
+        out <<  "mode:"+mode.to_s+"\n"
+        out <<  "Distribution:\n"
+        frequencies.sort.each{|k,v|
+            key=labels.has_key?(k) ? labels[k]:k
+            out <<  sprintf("%s : %s (%0.2f%%)\n",key,v, (v.quo(n_valid))*100)
+        }
+        if(@type==:ordinal)
+            out << "median:"+median.to_s+"\n"
         end
-    end
-     # Retrieves number of cases which comply condition.
-     # If block given, retrieves number of instances where
-     # block returns true.
-     # If other values given, retrieves the frequency for
-     # this value.
-    def count(x=false)
-        if block_given?
-            r=@data.inject(0) {|s, i|
-                r=yield i
-                s+(r ? 1 : 0)
-            }
-            r.nil? ? 0 : r
-        else
-            frequencies[x].nil? ? 0 : frequencies[x]
+        if(@type==:scale)
+            out << "mean:"+mean.to_s+"\n"
+            out << "sd:"+sd.to_s+"\n"
+            
         end
+        out
     end
-    
-    # Returns the database type for the vector, according to its content
-    
-    def db_type(dbs='mysql')
-        # first, detect any character not number
-        if @data.find {|v|  v.to_s=~/\d{2,2}-\d{2,2}-\d{4,4}/} or @data.find {|v|  v.to_s=~/\d{4,4}-\d{2,2}-\d{2,2}/}
-            return "DATE"
-        elsif @data.find {|v|  v.to_s=~/[^0-9e.-]/ }
-            return "VARCHAR (255)"
-        elsif @data.find {|v| v.to_s=~/\./}
-            return "DOUBLE"
-        else
-            return "INTEGER"
+      
+      # Variance of p, according to poblation size
+      def variance_proportion(n_poblation, v=1)
+          Statsample::proportion_variance_sample(self.proportion(v), @valid_data.size, n_poblation)
+      end
+      # Variance of p, according to poblation size
+      def variance_total(n_poblation, v=1)
+          Statsample::total_variance_sample(self.proportion(v), @valid_data.size, n_poblation)
+      end
+      def proportion_confidence_interval_t(n_poblation,margin=0.95,v=1)
+          Statsample::proportion_confidence_interval_t(proportion(v), @valid_data.size, n_poblation, margin)
+      end
+      def proportion_confidence_interval_z(n_poblation,margin=0.95,v=1)
+          Statsample::proportion_confidence_interval_z(proportion(v), @valid_data.size, n_poblation, margin)
+      end
+      
+      self.instance_methods.find_all{|met| met=~/_slow$/}.each do |met|
+          met_or=met.gsub("_slow","")
+          if !self.method_defined?(met_or)
+              alias_method met_or, met
+          end
+      end
+  ######
+  ### Ordinal Methods
+  ######
+  
+      # Return the value of the percentil q
+      def percentil(q)
+          check_type :ordinal
+          sorted=@valid_data.sort
+          v= (n_valid * q).quo(100)
+          if(v.to_i!=v)
+              sorted[v.to_i]
+          else
+              (sorted[(v-0.5).to_i].to_f + sorted[(v+0.5).to_i]).quo(2)
+          end
+      end
+      # Returns a ranked vector.
+      def ranked(type=:ordinal)
+        check_type :ordinal
+        i=0
+        r=frequencies.sort.inject({}){|a,v|
+          a[v[0]]=(i+1 + i+v[1]).quo(2)
+          i+=v[1]
+          a
+        }
+        @data.collect {|c| r[c] }.to_vector(type)
+      end
+    # Return the median (percentil 50)
+    def median
+      check_type :ordinal
+      if HAS_GSL and @type==:scale
+        sorted=GSL::Vector.alloc(@scale_data.sort)
+        GSL::Stats::median_from_sorted_data(sorted)
+      else
+        percentil(50)
+      end
+    end
+    # Minimun value
+    def min; 
+      check_type :ordinal
+      @valid_data.min;
+    end
+        # Maximum value
+    def max; 
+      check_type :ordinal
+      @valid_data.max;
+    end
+    def set_date_data # :nodoc:
+      @date_data_with_nils=@data.collect do|x|
+        if x.is_a? Date
+          x
+        elsif x.is_a? Time
+          Date.new(x.year, x.month, x.day)
+        elsif x.is_a? String and x=~/(\d{4,4})[-\/](\d{1,2})[-\/](\d{1,2})/
+          Date.new($1.to_i,$2.to_i,$3.to_i)
+        elsif @today_values.include? x
+          Date.today()
+        elsif @missing_values.include? x or x.nil?
+          nil
         end
+      end
     end
-    # Return true if all data is Numeric or nil
-    def can_be_scale?
-        if @data.find {|v| !v.nil? and !v.is_a? Numeric}
-            false
+    def set_scale_data # :nodoc
+      @scale_data=@valid_data.collect do|x|
+        if x.is_a? Numeric
+          x
+        elsif x.is_a? String and x.to_i==x.to_f
+          x.to_i
         else
-            true
-        end
+          x.to_f
+        end
+      end
+      if HAS_GSL
+        @gsl=GSL::Vector.alloc(@scale_data) if @scale_data.size>0
+      end
+    end
+    private :set_scale_data
+  
+    # The range of the data (max - min)
+    def range; 
+      check_type :scale
+      @scale_data.max - @scale_data.min
+    end
+    # The sum of values for the data
+    def sum
+      check_type :scale
+      @scale_data.inject(0){|a,x|x+a} ; 
+    end
+    # The arithmetical mean of data
+    def mean
+      check_type :scale
+      sum.to_f.quo(n_valid)
+    end
+    # Sum of squares for the data around a value.
+    # By default, this value is the  mean
+    #   ss= sum{(xi-m)^2}
+    # 
+    def sum_of_squares(m=nil)
+      check_type :scale
+      m||=mean
+      @scale_data.inject(0){|a,x| a+(x-m).square}
     end
     
-    def to_s
-        sprintf("Vector(type:%s, n:%d)[%s]",@type.to_s,@data.size, @data.collect{|d| d.nil? ? "nil":d}.join(","))
-    end
-    # Ugly name. Really, create a Vector for standard 'matrix' package.
-    # <tt>dir</tt> could be :horizontal or :vertical
-    def to_matrix(dir=:horizontal)
-        case dir
-        when :horizontal
-            Matrix[@data]
-        when :vertical
-            Matrix.columns([@data])
-        end
-    end
-    def inspect
-        self.to_s
+    # Sum of squared deviation
+    def sum_of_squared_deviation
+      check_type :scale
+      @scale_data.inject(0) {|a,x| x.square+a} - (sum.square.quo(n_valid))
     end
-    # Retrieves uniques values for data.
-    def factors
-        if @type==:scale
-            @scale_data.uniq.sort
-        else
-            @valid_data.uniq.sort
-        end
+    
+    # Population variance (denominator N)
+    def variance_population(m=nil)
+      check_type :scale
+      m||=mean
+      squares=@scale_data.inject(0){|a,x| x.square+a}
+      squares.quo(n_valid) - m.square
     end
-    if Statsample::STATSAMPLE__.respond_to?(:frequencies)
-        # Returns a hash with the distribution of frecuencies for
-        # the sample                
-        def frequencies
-            Statsample::STATSAMPLE__.frequencies(@valid_data)
-        end
-    else
-        def frequencies #:nodoc:
-            _frequencies
-        end
+    
+
+    # Population Standard deviation (denominator N)
+    def standard_deviation_population(m=nil)
+      check_type :scale
+      Math::sqrt( variance_population(m) )
     end
-    def _frequencies #:nodoc:
-        @valid_data.inject(Hash.new) {|a,x|
-            a[x]||=0
-            a[x]=a[x]+1
-            a
-        }
+    # Sample Variance (denominator n-1)
+    
+    def variance_sample(m=nil)
+      check_type :scale
+      m||=mean
+      sum_of_squares(m).quo(n_valid - 1)
     end
-    # Plot frequencies on a chart, using gnuplot
-        def plot_frequencies
-        require 'gnuplot'
-        x=[]
-        y=[]
-        self.frequencies.sort.each{|k,v|
-            x.push(k)
-            y.push(v) 
-        }
-        Gnuplot.open do |gp|
-            Gnuplot::Plot.new( gp ) do |plot|
-                plot.boxwidth("0.9 absolute")
-                plot.yrange("[0:#{y.max}]")
-                plot.style("fill  solid 1.00 border -1")
-                plot.set("xtics border in scale 1,0.5 nomirror rotate by -45  offset character 0, 0, 0")
-                plot.style("histogram")
-                plot.style("data histogram")
-                i=-1
-                plot.set("xtics","("+x.collect{|v| i+=1; sprintf("\"%s\" %d",v,i)}.join(",")+")")
-                plot.data << Gnuplot::DataSet.new( [y] ) do |ds|
-                    end
-                end
-            end
 
-        end
-
-
-        # Returns the most frequent item.
-        def mode
-            frequencies.max{|a,b| a[1]<=>b[1]}[0]
-        end
-        # The numbers of item with valid data.
-        def n_valid
-            @valid_data.size
-        end
-        # Returns a hash with the distribution of proportions of
-        # the sample.
-        def proportions
-            frequencies.inject({}){|a,v|
-                a[v[0]] = v[1].quo(n_valid)
-                a
-            }
-        end
-        # Proportion of a given value.
-        def proportion(v=1)
-            frequencies[v].quo(@valid_data.size)
-        end
-        def summary(out="")
-            out << sprintf("n valid:%d\n",n_valid)
-            out <<  sprintf("factors:%s\n",factors.join(","))
-            out <<  "mode:"+mode.to_s+"\n"
-            out <<  "Distribution:\n"
-            frequencies.sort.each{|k,v|
-                key=labels.has_key?(k) ? labels[k]:k
-                out <<  sprintf("%s : %s (%0.2f%%)\n",key,v, (v.quo(n_valid))*100)
-            }
-            if(@type==:ordinal)
-                out << "median:"+median.to_s+"\n"
-            end
-            if(@type==:scale)
-                out << "mean:"+mean.to_s+"\n"
-                out << "sd:"+sd.to_s+"\n"
-                
-            end
-            out
-        end
+    # Sample Standard deviation (denominator n-1)
+    
+    def standard_deviation_sample(m=nil)
+        check_type :scale
         
-        # Variance of p, according to poblation size
-        def variance_proportion(n_poblation, v=1)
-            Statsample::proportion_variance_sample(self.proportion(v), @valid_data.size, n_poblation)
-        end
-        # Variance of p, according to poblation size
-        def variance_total(n_poblation, v=1)
-            Statsample::total_variance_sample(self.proportion(v), @valid_data.size, n_poblation)
-        end
-        def proportion_confidence_interval_t(n_poblation,margin=0.95,v=1)
-            Statsample::proportion_confidence_interval_t(proportion(v), @valid_data.size, n_poblation, margin)
-        end
-        def proportion_confidence_interval_z(n_poblation,margin=0.95,v=1)
-            Statsample::proportion_confidence_interval_z(proportion(v), @valid_data.size, n_poblation, margin)
-        end
+        m||=mean
+        Math::sqrt(variance_sample(m))
+    end
+    # Skewness of the sample
+    def skew(m=nil)
+        check_type :scale
+        m||=mean
+        th=@scale_data.inject(0){|a,x| a+((x-m)**3)}
+        th.quo((@scale_data.size)*sd(m)**3)
+    end
+    # Kurtosis of the sample
+    def kurtosis(m=nil)
+        check_type :scale
+        m||=mean
+        fo=@scale_data.inject(0){|a,x| a+((x-m)**4)}
+        fo.quo((@scale_data.size)*sd(m)**4)-3
         
-        self.instance_methods.find_all{|met| met=~/_slow$/}.each do |met|
-            met_or=met.gsub("_slow","")
-            if !self.method_defined?(met_or)
-                alias_method met_or, met
-            end
-        end
-    ######
-    ### Ordinal Methods
-    ######
-    
-        # Return the value of the percentil q
-        def percentil(q)
-            check_type :ordinal
-            sorted=@valid_data.sort
-            v= (n_valid * q).quo(100)
-            if(v.to_i!=v)
-                sorted[v.to_i]
-            else
-                (sorted[(v-0.5).to_i].to_f + sorted[(v+0.5).to_i]).quo(2)
-            end
-        end
-        # Returns a ranked vector.
-        def ranked(type=:ordinal)
-            check_type :ordinal
-            i=0
-            r=frequencies.sort.inject({}){|a,v|
-                a[v[0]]=(i+1 + i+v[1]).quo(2)
-                i+=v[1]
-                a
-            }
-            @data.collect {|c|
-                r[c]
-            }.to_vector(type)
-        end
-        # Return the median (percentil 50)
-        def median
-            check_type :ordinal
-            if HAS_GSL and @type==:scale
-                GSL::Stats::median_from_sorted_data(@gsl)
-            else
-            percentil(50)
-            end
-        end
-        # Minimun value
-        def min; 
-            check_type :ordinal
-            @valid_data.min;
-        end
-            # Maximum value
-        def max; 
-            check_type :ordinal
-            @valid_data.max;
-        end
-
-        def set_scale_data # :nodoc
-            @scale_data=@valid_data.collect do|x|
-                if x.is_a? Numeric
-                    x
-                elsif x.is_a? String and x.to_i==x.to_f
-                    x.to_i
-                else
-                    x.to_f
-                end
-            end
-            if HAS_GSL
-                @gsl=GSL::Vector.alloc(@scale_data) if @scale_data.size>0
-            end
-        end
-        private :set_scale_data
+    end
+    # Product of all values on the sample
+    # 
+    def product
+        check_type :scale
+        @scale_data.inject(1){|a,x| a*x }
+    end
+    if HAS_GSL
+      %w{skew kurtosis variance_sample standard_deviation_sample variance_population standard_deviation_population mean sum}.each{|m|
+          m_nuevo=(m+"_slow").intern
+          alias_method m_nuevo, m.intern
+      }
+      def sum # :nodoc:
+      check_type :scale
+          
+          @gsl.sum
+      end
+      def mean # :nodoc:
+      check_type :scale
+          
+          @gsl.mean
+      end				
+      def variance_sample(m=nil) # :nodoc:
+      check_type :scale
+          
+          m||=mean
+          @gsl.variance_m
+      end
+      def standard_deviation_sample(m=nil) # :nodoc:
+          check_type :scale
+          m||=mean
+          @gsl.sd(m)
+      end
       
-        # The range of the data (max - min)
-        def range; 
-            check_type :scale
-            @scale_data.max - @scale_data.min
-        end
-        # The sum of values for the data
-        def sum
-            check_type :scale
-            @scale_data.inject(0){|a,x|x+a} ; 
-        end
-        # The arithmetical mean of data
-        def mean
-            check_type :scale
-            sum.to_f.quo(n_valid)
-        end
-        # Sum of squares for the data around a value.
-        # By default, this value is the  mean
-        #   ss= sum{(xi-m)^2}
-        # 
-        def sum_of_squares(m=nil)
-            check_type :scale
-            m||=mean
-            @scale_data.inject(0){|a,x| a+(x-m).square}
-        end
-        
-        # Sum of squared deviation
-        def sum_of_squared_deviation
-            check_type :scale
-            @scale_data.inject(0) {|a,x| x.square+a} - (sum.square.quo(n_valid))
-        end
+      def variance_population(m=nil) # :nodoc:
+      check_type :scale    
+          m||=mean
+          @gsl.variance_with_fixed_mean(m)
+      end
+      def standard_deviation_population(m=nil) # :nodoc:
+          check_type :scale
+          m||=mean
+          @gsl.sd_with_fixed_mean(m)
+      end
+      def skew # :nodoc:
+          check_type :scale
+          @gsl.skew
+      end
+      def kurtosis # :nodoc:
+          check_type :scale
+          @gsl.kurtosis
+      end
+      # Create a GSL::Histogram
+      # With a fixnum, creates X bins within the range of data
+      # With an Array, each value will be a cut point
+      def histogram(bins=10)
+        check_type :scale
         
-        # Population variance (denominator N)
-        def variance_population(m=nil)
-            check_type :scale
-            m||=mean
-            squares=@scale_data.inject(0){|a,x| x.square+a}
-            squares.quo(n_valid) - m.square
+        if bins.is_a? Array
+          #h=Statsample::Histogram.new(self, bins)
+          h=GSL::Histogram.alloc(bins)                        
+        else
+          # ugly patch. The upper limit for a bin has the form
+          # x < range
+          #h=Statsample::Histogram.new(self, bins)
+          h=GSL::Histogram.alloc(bins,[@valid_data.min,@valid_data.max+0.0001])
         end
-        
+        h.increment(@gsl)
+        h
+      end
+      def plot_histogram(bins=10,options="")
+          check_type :scale
+          self.histogram(bins).graph(options)
+      end
     
-        # Population Standard deviation (denominator N)
-        def standard_deviation_population(m=nil)
-            check_type :scale
-            
-            Math::sqrt( variance_population(m) )
-        end
-        # Sample Variance (denominator n-1)
-        
-        def variance_sample(m=nil)
-            check_type :scale
-            
-            m||=mean
-            sum_of_squares(m).quo(n_valid - 1)
-        end
-
-        # Sample Standard deviation (denominator n-1)
-        
-        def standard_deviation_sample(m=nil)
-            check_type :scale
-            
-            m||=m
-            Math::sqrt(variance_sample(m))
-        end
-        # Skewness of the sample
-        def skew
-            check_type :scale
-            m=mean
-            thirds=@scale_data.inject(0){|a,x| a+((x-mean)**3)}
-            thirds.quo((@scale_data.size-1)*sd**3)
-        end
-        # Kurtosis of the sample
-        def kurtosis
-            check_type :scale
-            
-            m=mean
-            thirds=@scale_data.inject(0){|a,x| a+((x-mean)**4)}
-            thirds.quo((@scale_data.size-1)*sd**4)
-            
-        end
-        # Product of all values on the sample
-        # 
-        def product
-            check_type :scale
-            @scale_data.inject(1){|a,x| a*x }
-        end
-        if HAS_GSL
-            %w{skew kurtosis variance_sample standard_deviation_sample variance_population standard_deviation_population mean sum}.each{|m|
-                m_nuevo=(m+"_slow").intern
-                alias_method m_nuevo, m.intern
-            }
-            def sum # :nodoc:
-            check_type :scale
-                
-                @gsl.sum
-            end
-            def mean # :nodoc:
-            check_type :scale
-                
-                @gsl.mean
-            end				
-            def variance_sample(m=nil) # :nodoc:
-            check_type :scale
-                
-                m||=mean
-                @gsl.variance_m
-            end
-            def standard_deviation_sample(m=nil) # :nodoc:
-                check_type :scale
-                m||=mean
-                @gsl.sd(m)
-            end
-            
-            def variance_population(m=nil) # :nodoc:
-            check_type :scale    
-                m||=mean
-                @gsl.variance_with_fixed_mean(m)
-            end
-            def standard_deviation_population(m=nil) # :nodoc:
-                check_type :scale
-                m||=mean
-                @gsl.sd_with_fixed_mean(m)
-            end
-            def skew # :nodoc:
-                check_type :scale
-                @gsl.skew
-            end
-            def kurtosis # :nodoc:
-                check_type :scale
-                @gsl.kurtosis
-            end
-            # Create a GSL::Histogram
-            # With a fixnum, creates X bins within the range of data
-            # With an Array, each value will be a cut point
-            def histogram(bins=10)
-                check_type :scale
-                if bins.is_a? Array
-                    h=GSL::Histogram.alloc(bins)                        
-                else
-                    # ugly patch. The upper limit for a bin has the form
-                    # x < range
-                    h=GSL::Histogram.alloc(bins,[@valid_data.min,@valid_data.max+0.0001])
-                end
-                h.increment(@gsl)
-                 h
-            end
-            def plot_histogram(bins=10,options="")
-                check_type :scale
-                self.histogram(bins).graph(options)
-            end
-        
-        end
-        
-        # Coefficient of variation
-        # Calculed with the sample standard deviation
-        def coefficient_of_variation
-            check_type :scale
-            standard_deviation_sample.quo(mean)
-        end
-        
-        alias_method :sdp, :standard_deviation_population
-        alias_method :sds, :standard_deviation_sample
-        alias_method :cov, :coefficient_of_variation
-        alias_method :variance, :variance_sample
-        alias_method :sd, :standard_deviation_sample
-        alias_method :ss, :sum_of_squares
     end
+      
+    # Coefficient of variation
+    # Calculed with the sample standard deviation
+    def coefficient_of_variation
+        check_type :scale
+        standard_deviation_sample.quo(mean)
+    end
+    
+    alias_method :sdp, :standard_deviation_population
+    alias_method :sds, :standard_deviation_sample
+    alias_method :cov, :coefficient_of_variation
+    alias_method :variance, :variance_sample
+    alias_method :sd, :standard_deviation_sample
+    alias_method :ss, :sum_of_squares
+  end
 end