statsample 1.5.0 → 2.0.0

data/lib/statsample/test/wilcoxonsignedrank.rb

@@ -8,13 +8,13 @@ module Statsample
       
       # Name of F analysis
       attr_accessor :name
-	  attr_reader :w
-	  attr_reader :nr
-	  attr_writer :tails
+	    attr_reader :w
+	    attr_reader :nr
+      attr_writer :tails
       # Parameters:
       def initialize(v1,v2, opts=Hash.new)
-		@v1=v1
-		@v2=v2
+		    @v1 = v1
+		    @v2 = v2
         opts_default={:name=>_("Wilcoxon Signed Rank Test"),:tails=>:both}
         @opts=opts_default.merge(opts)
         opts_default.keys.each {|k|
@@ -22,66 +22,68 @@ module Statsample
         }
         calculate
       end
+
       def calculate
-		df=Statsample::Dataset.new({'v1'=>@v1,'v2'=>@v2})
-		df["abs"]=df.collect {|row| 
-			r=(row["v2"]-row["v1"]).abs
-		}
-		df["sgn"]=df.collect {|row| 
-			r=row["v2"]-row["v1"]
-			r==0 ? 0 : r/r.abs
-		}
-		df=df.filter {|row| row["sgn"]!=0}
-		df["rank"]=df["abs"].ranked
-		@nr=df.cases
-		@w=df.collect {|row|
-			row["sgn"]*row["rank"]
-			#p row["sgn"]*row["rank"]
-		}.sum
+		    df = Daru::DataFrame.new({:v1 => @v1,:v2 => @v2})
+		    # df[:abs]=df.collect(:row) { |row|  (row[:v2] - row[:v1]).abs }
+        df[:abs] = (df[:v2] - df[:v1]).abs
+		    df[:sgn] = df.collect(:row) { |row| 
+			   r = row[:v2] - row[:v1]
+			   r == 0 ? 0 : r/r.abs
+		    }
+		    df = df.filter_rows { |row| row[:sgn] != 0}
+		    df[:rank] = df[:abs].ranked
+		    @nr = df.nrows
+
+		    @w = df.collect(:row) { |row|
+          row[:sgn] * row[:rank]
+		    }.sum
       end
+
       def report_building(generator) # :nodoc:
         generator.section(:name=>@name) do |s|
           s.table(:name=>_("%s results") % @name) do |t|
             t.row([_("W Value"), "%0.3f" % @w])
             t.row([_("Z"), "%0.3f (p: %0.3f)" % [z, probability_z]])
             if(nr<=10) 
-				t.row([_("Exact probability"), "p-exact: %0.3f" % [probability_exact]])
+				      t.row([_("Exact probability"), "p-exact: %0.3f" % [probability_exact]])
             end
           end
         end
       end
       def z
-		sigma=Math.sqrt((nr*(nr+1)*(2*nr+1))/6)
-		(w-0.5)/sigma
+		    sigma=Math.sqrt((nr*(nr+1)*(2*nr+1))/6)
+		    (w-0.5)/sigma
       end
       # Assuming normal distribution of W, this calculate
       # the probability of samples with Z equal or higher than
       # obtained on sample
       def probability_z
-		(1-Distribution::Normal.cdf(z))*(@tails==:both ? 2:1)
+		    (1-Distribution::Normal.cdf(z))*(@tails==:both ? 2:1)
       end
       # Calculate exact probability.
       # Don't calculate for large Nr, please!
       def probability_exact
-		str_format="%0#{nr}b"
-		combinations=2**nr
-		#p str_format
-		total_w=combinations.times.map {|i|
-			comb=sprintf(str_format,i)
-			w_local=comb.length.times.inject(0) {|ac,j|
-				sgn=comb[j]=="0" ? -1 : 1
-				ac+(j+1)*sgn
-			}
-		}.sort
-		total_w.find_all {|v| 
-			if @tails==:both
-				v<=-w.abs or v>=w.abs
-			elsif @tails==:left
-				v<=w
-			elsif @tails==:right
-				v>=w
-			end
-		}.count/(combinations.to_f)
+		    str_format="%0#{nr}b"
+		    combinations=2**nr
+		    #p str_format
+		    total_w=combinations.times.map do |i|
+          comb=sprintf(str_format,i)
+          w_local=comb.length.times.inject(0) do |ac,j|
+            sgn=comb[j]=="0" ? -1 : 1
+				    ac+(j+1)*sgn
+          end
+		    end.sort
+
+  		  total_w.find_all do |v| 
+          if @tails==:both
+            v<=-w.abs or v>=w.abs
+          elsif @tails==:left
+            v<=w
+          elsif @tails==:right
+  				  v>=w
+          end
+  		  end.count/(combinations.to_f)
       end
     end
   end

data/lib/statsample/vector.rb

@@ -1,22 +1,18 @@
-require 'date'
-require 'statsample/vector/gsl'
-
 module Statsample::VectorShorthands
   # Creates a new Statsample::Vector object
   # Argument should be equal to Vector.new
   def to_vector(*args)
-    Statsample::Vector.new(self,*args)
+    Statsample::Vector.new(self)
   end
 
-  # Creates a new Statsample::Vector object of type :scale.
+  # Creates a new Daru::Vector object of type :scale.
   # Deprecated. Use to_numeric instead.
   def to_scale(*args)
-    $stderr.puts "WARNING: to_scale has been deprecated. Use to_numeric instead."
-    Statsample::Vector.new(self, :numeric, *args)
+    Statsample::Vector.new(self, *args)
   end
 
   def to_numeric(*args)
-    Statsample::Vector.new(self, :numeric, *args)
+    Statsample::Vector.new(self)
   end
 end
 
@@ -39,1057 +35,118 @@ module Statsample
   # == Usage
   # The fast way to create a vector uses Array.to_vector or Array.to_numeric.
   #
-  #  v=[1,2,3,4].to_vector(:numeric)
-  #  v=[1,2,3,4].to_numeric
-  #
-  class Vector
-    include Enumerable
-    include Writable
-    include Summarizable
+  # == Deprecation Warning
+  # 
+  # Statsample::Vector has been deprecated in favour of Daru::Vector. Daru is
+  # a dedicated data analysis and manipulation library that brings awesome
+  # data analysis functionality to ruby. Check out the daru docs at
+  # https://github.com/v0dro/daru#notebooks
+  class Vector < Daru::Vector
     include Statsample::VectorShorthands
 
-    # Level of measurement. Could be :object, :numeric
-    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
+    # Valid data. Equal to data, minus values assigned as missing values.
+    # 
+    # == Deprecation Warning
+    # 
+    # Use Daru::Vector#only_valid instead of this method.
+    def valid_data
+      $stderr.puts "WARNING: valid_data in Statsample::Vector has been deprecated in favor of only_valid in Daru::Vector. Please use that.\n"
+      only_valid.to_a
+    end
     # 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
-    # Change label for specific values
-    attr_accessor :labels
-    # Name of vector. Should be used for output by many classes
-    attr_accessor :name
+    # 
+    # == Deprecation Warning
+    # 
+    # Use Daru::Vector#only_valid instead of this method.
+    def missing_data
+      only_missing.to_a
+    end
+    # Original data.
+    # 
+    # == Deprecation Warning
+    # 
+    # Use Daru::Vector#to_a instead of this method.
+    def data_with_nils
+      to_a
+    end
+
+    def type= val
+      raise NoMethodError, "Daru::Vector automatically figures the type of data. There is no need to assign it anymore."
+    end
+
+    def initialize(data=[], type=:object, opts=Hash.new)  
+      $stderr.puts "WARNING: Statsample::Dataset and Statsample::Vector have been deprecated in favor of Daru::DataFrame and Daru::Vector. Please switch to using that."      
 
-    # Creates a new Vector object.
-    # * <tt>data</tt> Any data which can be converted on Array
-    # * <tt>type</tt> Level of meausurement. See Vector#type
-    # * <tt>opts</tt> Hash of options
-    #   * <tt>:missing_values</tt>  Array of missing values. See Vector#missing_values
-    #   * <tt>:today_values</tt> Array of 'today' values. See Vector#today_values
-    #   * <tt>:labels</tt> Labels for data values
-    #   * <tt>:name</tt> Name of vector
-    def initialize(data=[], type=:object, opts=Hash.new)
       if type == :ordinal or type == :scale
-        $stderr.puts "WARNING: #{type} has been deprecated. Use :numeric instead."
-        type = :numeric
+        $stderr.puts "WARNING: #{type} has been deprecated."
       end
 
       if type == :nominal
-        $stderr.puts "WARNING: nominal has been deprecated. Use :object instead."
-        type = :object
+        $stderr.puts "WARNING: nominal has been deprecated."
       end
 
-      @data=data.is_a?(Array) ? data : data.to_a
-      @type=type
-      opts_default={
-        :missing_values=>[],
-        :today_values=>['NOW','TODAY', :NOW, :TODAY],
-        :labels=>{},
-        :name=>nil
-      }
-      @opts=opts_default.merge(opts)
-      if  @opts[:name].nil?
+      if opts[:today_values]
+        raise ArgumentError, "This option is no longer supported in Vector. Watch out for the next version of Daru::Vector that will have full time series support"
+      end
+
+      if  opts[:name].nil?
         @@n_table||=0
         @@n_table+=1
-        @opts[:name]="Vector #{@@n_table}"
+        opts[:name] = "Vector #{@@n_table}"
       end
-      @missing_values=@opts[:missing_values]
-      @labels=@opts[:labels]
-      @today_values=@opts[:today_values]
-      @name=@opts[:name]
-      @valid_data=[]
-      @data_with_nils=[]
-      @date_data_with_nils=[]
-      @missing_data=[]
-      @has_missing_data=nil
-      @numeric_data=nil
-      set_valid_data
-      self.type=type
+
+      super(data, opts)
     end
+
     # Create a vector using (almost) any object
     # * Array: flattened
     # * Range: transformed using to_a
     # * Statsample::Vector
     # * Numeric and string values
+    # 
+    # == Deprecation Warning
+    # 
+    # Statsample::Vector is to be replaced by Daru::Vector soon. Use the 
+    # equivalent method Daru::Vector.[] for this purpose.
     def self.[](*args)
-      values=[]
-      args.each do |a|
-        case a
-        when Array
-          values.concat a.flatten
-        when Statsample::Vector
-          values.concat a.to_a
-        when Range
-          values.concat  a.to_a
-        else
-          values << a
-        end
-      end
-      vector=new(values)
-      vector.type=:numeric if vector.can_be_numeric?
-      vector
+      $stderr.puts "WARNING: Statsample::Dataset and Statsample::Vector have been deprecated in favor of Daru::DataFrame and Daru::Vector. Please switch to using that."
+      super *args
     end
+
     # Create a new numeric type vector
     # Parameters
     # [n]      Size
     # [val]    Value of each value
     # [&block] If block provided, is used to set the values of vector
+    # 
+    # == Deprecation Warning
+    # 
+    # Statsample::Vector is to be replaced by Daru::Vector soon. Use the 
+    # equivalent method Daru::Vector.[] for this purpose.
     def self.new_numeric(n,val=nil, &block)
       if block
-        vector=n.times.map {|i| block.call(i)}.to_numeric
+        Statsample::Vector.new(n.times.map {|i| block.call(i)})
       else
-        vector=n.times.map { val}.to_numeric
+        Statsample::Vector.new(n.times.map { val })
       end
-      vector.type=:numeric
-      vector
     end
 
     # Deprecated. Use new_numeric instead.
     def self.new_scale(n, val=nil,&block)
-      $stderr.puts "WARNING: .new_scale has been deprecated. Use .new_numeric instead."
       new_numeric n, val, &block
     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, :name=>@name)
-    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, :name=> @name)
-    end
-
-    if Statsample::STATSAMPLE__.respond_to?(:check_type)
-      # Raises an exception if type of vector is inferior to t type
-      def check_type(t)
-        Statsample::STATSAMPLE__.check_type(self,t)
-      end
-    else
-      def check_type(t) #:nodoc:
-        _check_type(t)
-      end
-    end
-
-
-    def _check_type(t) #:nodoc:
-      raise NoMethodError if (t == :numeric and @type == :object) or 
-                             (t == :date)   or (:date == @type)
-    end
-
-    def vector_standarized_compute(m,sd) # :nodoc:
-      @data_with_nils.collect{|x| x.nil? ? nil : (x.to_f - m).quo(sd) }.to_vector(:numeric)
-    end
-    # Return a vector usign the standarized values for data
-    # with sd with denominator n-1. With variance=0 or mean nil,
-    # returns a vector of equal size full of nils
-    #
-    def vector_standarized(use_population=false)
-      check_type :numeric
-      m=mean
-      sd=use_population ? sdp : sds
-      return ([nil]*size).to_numeric if mean.nil? or sd==0.0
-      vector=vector_standarized_compute(m,sd)
-      vector.name=_("%s(standarized)")  % @name
-      vector
-    end
-    def vector_centered_compute(m) #:nodoc:
-      @data_with_nils.collect {|x| x.nil? ? nil : x.to_f-m }.to_numeric
-    end
-    # Return a centered vector
-    def vector_centered
-      check_type :numeric
-      m=mean
-      return ([nil]*size).to_numeric if mean.nil?
-      vector=vector_centered_compute(m)
-      vector.name=_("%s(centered)") % @name
-      vector
-    end
-
-    alias_method :standarized, :vector_standarized
-    alias_method  :centered, :vector_centered
-    # Return a vector with values replaced with the percentiles
-    # of each values
-    def vector_percentil
-      check_type :numeric
-      c=@valid_data.size
-      vector=ranked.map {|i| i.nil? ? nil : (i.quo(c)*100).to_f }.to_vector(@type)
-      vector.name=_("%s(percentil)")  % @name
-      vector
-    end
-    def box_cox_transformation(lambda) # :nodoc:
-      raise "Should be a numeric" unless @type==:numeric
-      @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(:numeric)
-    end
-
-    # Vector equality.
-    # Two vector will be the same if their data, missing values, type, labels are equals
-    def ==(v2)
-      return false 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,'name'=>@name})
-    end
-
-    def self._load(data) # :nodoc:
-    h=Marshal.load(data)
-    Vector.new(h['data'], h['type'], :missing_values=> h['missing_values'], :labels=>h['labels'], :name=>h['name'])
-    end
-    # Returns a new vector, with data modified by block.
-    # Equivalent to create a Vector after #collect on data
-    def recode(type=nil)
-      type||=@type
-      @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
-    def push(v)
-      @data.push(v)
-      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)
-      low ||= factors.min
-
-      @data_with_nils.collect do |x|
-        if x.nil?
-          nil
-        elsif x > low
-          1
-        else
-          0
-        end
-      end.to_numeric
-    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
-      set_valid_data_intern
-      set_numeric_data if(@type==:numeric)
-      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
-    alias :flawed? :has_missing_data?
-
-    # 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
-    alias :label :labeling
-    # 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.
-    # set_valid_data is called after changes
-    def missing_values=(vals)
-      @missing_values = vals
-      set_valid_data
-    end
-    # Set data considered as "today" on data vectors
-    def today_values=(vals)
-      @today_values = vals
-      set_valid_data
-    end
-    # Set level of measurement.
-    def type=(t)
-      @type=t
-      set_numeric_data if(t==:numeric)
-      set_date_data if (t==:date)
-    end
-    def to_a
-      if @data.is_a? Array
-        @data.dup
-      else
-        @data.to_a
-      end
-    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
-
-    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)
-      raise ArgumentError, "The array/vector parameter (#{v.size}) should be of the same size of the original vector (#{@data.size})" unless v.size==@data.size
-      sum=[]
-      v.size.times {|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, :numeric)
-    elsif(v.respond_to? method )
-      Statsample::Vector.new(
-        @data.collect  {|x|
-          if(!x.nil?)
-            x.send(method,v)
-          else
-            nil
-          end
-        } , :numeric)
-    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::object:0x7f2dbcc09d88
-    #        @data=[1, 0, 1]>,
-    #       "b"=>#<Statsample::Type::object:0x7f2dbcc09c48
-    #        @data=[1, 1, 0]>,
-    #      "c"=>#<Statsample::Type::object: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 do |r|
-      if r.nil?
-        factors.each do |f|
-          out[f].push(nil)
-        end
-      else
-        factors.each do |f|
-          out[f].push(r.include?(f) ? 1:0)
-        end
-      end
-    end
-    out.inject({}){|s,v|
-      s[v[0]]=Vector.new(v[1],:object)
-      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
-
-    # == Bootstrap
-    # Generate +nr+ resamples (with replacement) of size  +s+
-    # from vector, computing each estimate from +estimators+
-    # over each resample.
-    # +estimators+ could be
-    # a) Hash with variable names as keys and lambdas as  values
-    #   a.bootstrap(:log_s2=>lambda {|v| Math.log(v.variance)},1000)
-    # b) Array with names of method to bootstrap
-    #   a.bootstrap([:mean, :sd],1000)
-    # c) A single method to bootstrap
-    #   a.jacknife(:mean, 1000)
-    # If s is nil, is set to vector size by default.
-    #
-    # Returns a dataset where each vector is an vector
-    # of length +nr+ containing the computed resample estimates.
-    def bootstrap(estimators, nr, s=nil)
-      s||=n
-
-      h_est, es, bss= prepare_bootstrap(estimators)
-
-
-      nr.times do |i|
-        bs=sample_with_replacement(s)
-        es.each do |estimator|
-          # Add bootstrap
-          bss[estimator].push(h_est[estimator].call(bs))
-        end
-      end
-
-      es.each do |est|
-        bss[est]=bss[est].to_numeric
-        bss[est].type=:numeric
-      end
-      bss.to_dataset
-
-    end
-
-    # == Jacknife
-    # Returns a dataset with jacknife delete-+k+ +estimators+
-    # +estimators+ could be:
-    # a) Hash with variable names as keys and lambdas as values
-    #   a.jacknife(:log_s2=>lambda {|v| Math.log(v.variance)})
-    # b) Array with method names to jacknife
-    #   a.jacknife([:mean, :sd])
-    # c) A single method to jacknife
-    #   a.jacknife(:mean)
-    # +k+ represent the block size for block jacknife. By default
-    # is set to 1, for classic delete-one jacknife.
-    #
-    # Returns a dataset where each vector is an vector
-    # of length +cases+/+k+ containing the computed jacknife estimates.
-    #
-    # == Reference:
-    # * Sawyer, S. (2005). Resampling Data: Using a Statistical Jacknife.
-    def jacknife(estimators, k=1)
-      raise "n should be divisible by k:#{k}" unless n%k==0
-
-      nb=(n / k).to_i
-
-
-      h_est, es, ps= prepare_bootstrap(estimators)
-
-      est_n=es.inject({}) {|h,v|
-        h[v]=h_est[v].call(self)
-        h
-      }
-
 
-      nb.times do |i|
-        other=@data_with_nils.dup
-        other.slice!(i*k,k)
-        other=other.to_numeric
-        es.each do |estimator|
-          # Add pseudovalue
-          ps[estimator].push( nb * est_n[estimator] - (nb-1) * h_est[estimator].call(other))
-        end
-      end
-
-
-      es.each do |est|
-        ps[est]=ps[est].to_numeric
-        ps[est].type=:numeric
-      end
-      ps.to_dataset
-    end
-
-
-    # For an array or hash of estimators methods, returns
-    # an array with three elements
-    # 1.- A hash with estimators names as keys and lambdas as values
-    # 2.- An array with estimators names
-    # 3.- A Hash with estimators names as keys and empty arrays as values
-    def prepare_bootstrap(estimators)
-      h_est=estimators
-
-      h_est=[h_est] unless h_est.is_a? Array or h_est.is_a? Hash
-
-      if h_est.is_a? Array
-        h_est=h_est.inject({}) {|h,est|
-          h[est]=lambda {|v| v.send(est)}
-          h
-        }
-      end
-
-      bss=h_est.keys.inject({}) {|h,v| h[v]=[];h}
-
-      [h_est,h_est.keys, bss]
-
-    end
-    private :prepare_bootstrap
-
-    # 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)
-      vds=@valid_data.size
-      (0...sample).collect{ @valid_data[rand(vds)] }
-    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)
-      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]}
-    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
+      raise NoMethodError, "This method is no longer supported."
     end
     # Return true if all data is Numeric or nil
     def can_be_numeric?
-      if @data.find {|v| !v.nil? and !v.is_a? Numeric and !@missing_values.include? v}
-        false
-      else
-        true
-      end
+      type == :numeric
     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==:numeric
-        @numeric_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
-
-    # Returns the most frequent item.
-    def mode
-      frequencies.max{|a,b| a[1]<=>b[1]}.first
-    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 report_building(b)
-      b.section(:name=>name) do |s|
-        s.text _("n :%d") % n
-        s.text _("n valid:%d") % n_valid
-        if @type==:object
-          s.text  _("factors:%s") % factors.join(",")
-          s.text   _("mode: %s") % mode
-
-          s.table(:name=>_("Distribution")) do |t|
-            frequencies.sort.each do |k,v|
-              key=labels.has_key?(k) ? labels[k]:k
-              t.row [key, v , ("%0.2f%%" % (v.quo(n_valid)*100))]
-            end
-          end
-        end
-
-        s.text _("median: %s") % median.to_s if(@type==:numeric or @type==:numeric)
-        if(@type==:numeric)
-          s.text _("mean: %0.4f") % mean
-          if sd
-            s.text _("std.dev.: %0.4f") % sd
-            s.text _("std.err.: %0.4f") % se
-            s.text _("skew: %0.4f") % skew
-            s.text _("kurtosis: %0.4f") % kurtosis
-          end
-        end
-      end
-    end
-
-      # 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
-
-      ######
-      ### numeric Methods
-      ######
-
-      # == Percentil
-      # Returns the value of the percentile q
-      #
-      # Accepts an optional second argument specifying the strategy to interpolate
-      # when the requested percentile lies between two data points a and b
-      # Valid strategies are:
-      # * :midpoint (Default): (a + b) / 2
-      # * :linear : a + (b - a) * d where d is the decimal part of the index between a and b.
-      # This is the NIST recommended method (http://en.wikipedia.org/wiki/Percentile#NIST_method)
-      #
-      def percentil(q, strategy = :midpoint)
-        check_type :numeric
-        sorted=@valid_data.sort
-
-        case strategy
-        when :midpoint
-          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
-        when :linear
-          index = (q / 100.0) * (n_valid + 1)
-
-          k = index.truncate
-          d = index % 1
-
-          if k == 0
-            sorted[0]
-          elsif k >= sorted.size
-            sorted[-1]
-          else
-            sorted[k - 1] + d * (sorted[k] - sorted[k - 1])
-          end
-        else
-          raise NotImplementedError.new "Unknown strategy #{strategy.to_s}"
-        end
-      end
-
-      # Returns a ranked vector.
-      def ranked(type=:numeric)
-        check_type :numeric
-        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 :numeric
-        percentil(50)
-      end
-      # Minimun value
-      def min
-        check_type :numeric
-        @valid_data.min
-      end
-        # Maximum value
-      def max
-        check_type :numeric
-        @valid_data.max
-      end
-
-    def set_date_data
-      @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
-
-    def set_numeric_data
-      @numeric_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
-    end
-
-    private :set_date_data, :set_numeric_data
-
-    # The range of the data (max - min)
-    def range;
-      check_type :numeric
-      @numeric_data.max - @numeric_data.min
-    end
-    # The sum of values for the data
-    def sum
-      check_type :numeric
-      @numeric_data.inject(0){|a,x|x+a} ;
-    end
-    # The arithmetical mean of data
-    def mean
-      check_type :numeric
-      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 :numeric
-      m||=mean
-      @numeric_data.inject(0){|a,x| a+(x-m).square}
-    end
-    # Sum of squared deviation
-    def sum_of_squared_deviation
-      check_type :numeric
-      @numeric_data.inject(0) {|a,x| x.square+a} - (sum.square.quo(n_valid))
-    end
-
-    # Population variance (denominator N)
-    def variance_population(m=nil)
-      check_type :numeric
-      m||=mean
-      squares=@numeric_data.inject(0){|a,x| x.square+a}
-      squares.quo(n_valid) - m.square
-    end
-
-
-    # Population Standard deviation (denominator N)
-    def standard_deviation_population(m=nil)
-      check_type :numeric
-      Math::sqrt( variance_population(m) )
-    end
-
-    # Population average deviation (denominator N)
-    # author: Al Chou
-
-    def average_deviation_population( m = nil )
-      check_type :numeric
-      m ||= mean
-      ( @numeric_data.inject( 0 ) { |a, x| ( x - m ).abs + a } ).quo( n_valid )
-    end
-    def median_absolute_deviation
-      med=median
-      recode {|x| (x-med).abs}.median
-    end
-    alias  :mad :median_absolute_deviation
-    # Sample Variance (denominator n-1)
-    def variance_sample(m=nil)
-      check_type :numeric
-      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 :numeric
-        m||=mean
-        Math::sqrt(variance_sample(m))
-    end
-    # Skewness of the sample
-    def skew(m=nil)
-        check_type :numeric
-        m||=mean
-        th=@numeric_data.inject(0){|a,x| a+((x-m)**3)}
-        th.quo((@numeric_data.size)*sd(m)**3)
-    end
-    # Kurtosis of the sample
-    def kurtosis(m=nil)
-        check_type :numeric
-        m||=mean
-        fo=@numeric_data.inject(0){|a,x| a+((x-m)**4)}
-        fo.quo((@numeric_data.size)*sd(m)**4)-3
-
-    end
-    # Product of all values on the sample
-    #
-    def product
-        check_type :numeric
-        @numeric_data.inject(1){|a,x| a*x }
-    end
-
-    # 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 :numeric
-
-      if bins.is_a? Array
-        #h=Statsample::Histogram.new(self, bins)
-        h=Statsample::Histogram.alloc(bins)
-      else
-        # ugly patch. The upper limit for a bin has the form
-        # x < range
-        #h=Statsample::Histogram.new(self, bins)
-        min,max=Statsample::Util.nice(@valid_data.min,@valid_data.max)
-        # fix last data
-        if max==@valid_data.max
-          max+=1e-10
-        end
-        h=Statsample::Histogram.alloc(bins,[min,max])
-        # Fix last bin
-
-      end
-      h.increment(@valid_data)
-      h
-    end
-
-    # Coefficient of variation
-    # Calculed with the sample standard deviation
-    def coefficient_of_variation
-        check_type :numeric
-        standard_deviation_sample.quo(mean)
-    end
-    # Standard error of the distribution mean
-    # Calculated using sd/sqrt(n)
-    def standard_error
-      standard_deviation_sample.quo(Math.sqrt(valid_data.size))
-    end
-    alias :se :standard_error
-
-    alias_method :sdp, :standard_deviation_population
-    alias_method :sds, :standard_deviation_sample
-    alias_method :adp, :average_deviation_population
-    alias_method :cov, :coefficient_of_variation
-    alias_method :variance, :variance_sample
-    alias_method :sd, :standard_deviation_sample
-    alias_method :ss, :sum_of_squares
-    include_aliasing Statsample::Vector::GSL_ if Statsample.has_gsl?
   end
 end