statsample 0.18.0 → 1.0.0

data/lib/statsample/regression/multiple/matrixengine.rb

@@ -30,13 +30,13 @@ class MatrixEngine < BaseEngine
   
   # Number of cases
   attr_writer :cases
-  
+  attr_writer :digits
   # Create object
   #
   def initialize(matrix,y_var, opts=Hash.new)
     matrix.extend Statsample::CovariateMatrix
     raise "#{y_var} variable should be on data" unless matrix.fields.include? y_var
-    if matrix.type==:covariance
+    if matrix._type==:covariance
       @matrix_cov=matrix
       @matrix_cor=matrix.correlation
       @no_covariance=false
@@ -53,6 +53,8 @@ class MatrixEngine < BaseEngine
     @predictors_n=@n_predictors
     @matrix_x= @matrix_cor.submatrix(@fields)
     @matrix_x_cov= @matrix_cov.submatrix(@fields)
+    raise LinearDependency, "Regressors are linearly dependent" if @matrix_x.determinant<1e-15
+
     
     @matrix_y = @matrix_cor.submatrix(@fields, [y_var])
     @matrix_y_cov = @matrix_cov.submatrix(@fields, [y_var])
@@ -75,13 +77,14 @@ class MatrixEngine < BaseEngine
     @y_mean=0.0
     @name=_("Multiple reggresion of %s on %s") % [@fields.join(","), @y_var]
     
-    
+    opts_default={:digits=>3}
+    opts=opts_default.merge opts
     opts.each{|k,v|
         self.send("#{k}=",v) if self.respond_to? k
     }
       result_matrix=@matrix_x_cov.inverse * @matrix_y_cov
 
-    if matrix.type==:covariance
+    if matrix._type==:covariance
       @coeffs=result_matrix.column(0).to_a
       @coeffs_stan=coeffs.collect {|k,v|
         coeffs[k]*@x_sd[k].quo(@y_sd)
@@ -141,7 +144,7 @@ class MatrixEngine < BaseEngine
   # Tolerance for a given variable
   # defined as (1-R^2) of regression of other independent variables
   # over the selected
-  # Reference:
+  # == Reference:
   # * http://talkstats.com/showthread.php?t=5056
   def tolerance(var)
     return 1 if @matrix_x.column_size==1

data/lib/statsample/regression/multiple/rubyengine.rb

@@ -17,7 +17,7 @@ module Multiple
 
 class RubyEngine < MatrixEngine
   def initialize(ds,y_var, opts=Hash.new)
-    matrix=Statsample::Bivariate.correlation_matrix(ds)
+    matrix=ds.correlation_matrix
     fields_indep=ds.fields-[y_var]
     default={
       :y_mean=>ds[y_var].mean,

data/lib/statsample/regression/simple.rb

@@ -8,8 +8,10 @@ module Statsample
     # * <tt> SimpleRegression.new_from_gsl(gsl) </tt>
     #
     class Simple
+      include Summarizable
       attr_accessor :a,:b,:cov00, :cov01, :covx1, :chisq, :status
-
+      attr_accessor :name
+      attr_accessor :digits
       def initialize(init_method, *argv)
         self.send(init_method, *argv)
       end
@@ -61,15 +63,15 @@ module Statsample
           new(:init_gsl, *ar)
         end
         # Create a simple regression using two vectors
-        def new_from_vectors(vx,vy)
-          new(:init_vectors,vx,vy)
+        def new_from_vectors(vx,vy, opts=Hash.new)
+          new(:init_vectors,vx,vy, opts)
         end
         # Create a simple regression using a dataset and two vector names.
-        def new_from_dataset(ds,x,y)
-          new(:init_vectors,ds[x],ds[y])
+        def new_from_dataset(ds,x,y, opts=Hash.new)
+          new(:init_vectors,ds[x],ds[y], opts)
         end
       end
-      def init_vectors(vx,vy)
+      def init_vectors(vx,vy, opts=Hash.new)
         @vx,@vy=Statsample.only_valid_clone(vx,vy)
         x_m=@vx.mean
         y_m=@vy.mean
@@ -80,6 +82,17 @@ module Statsample
         }
         @b=num.to_f/den
         @a=y_m - @b*x_m
+        
+        opts_default={
+        :digits=>3, 
+        :name=>_("Regression of %s over %s") % [@vx.name, @vy.name]
+         }
+        @opts=opts_default.merge opts
+
+        @opts.each{|k,v|
+          self.send("#{k}=",v) if self.respond_to? k
+        }
+        
       end
       def init_gsl(a,b,cov00, cov01, covx1, chisq, status)
         @a=a
@@ -90,6 +103,18 @@ module Statsample
         @chisq=chisq
         @status=status
       end
+      def report_building(gen)
+      f="%0.#{digits}f"
+        gen.section(:name=>name) do |s|
+          s.table(:header=>[_("Variable"), _("Value")]) do |t|
+            t.row [_("r"), f % r]
+            t.row [_("r^2"), f % r2]
+            t.row [_("a"), f % a]
+            t.row [_("b"), f % a]
+            t.row [_("s.e"), f % standard_error]
+          end
+        end
+      end
       private :init_vectors, :init_gsl
     end
   end

data/lib/statsample/reliability.rb

@@ -5,6 +5,7 @@ module Statsample
       # only uses tuples without missing data
       def cronbach_alpha(ods)
         ds=ods.dup_only_valid
+        return nil if ds.vectors.any? {|k,v| v.variance==0}
         n_items=ds.fields.size
         return nil if n_items<=1
         s2_items=ds.vectors.inject(0) {|ac,v|
@@ -16,11 +17,18 @@ module Statsample
       # Calculate Chonbach's alpha for a given dataset
       # using standarized values for every vector.
       # Only uses tuples without missing data
-
+      # Return nil if one or more vectors has 0 variance
       def cronbach_alpha_standarized(ods)
-        ds=ods.dup_only_valid.fields.inject({}){|a,f|
-          a[f]=ods[f].standarized; a
+        
+        ds=ods.dup_only_valid
+        
+        return nil if ds.vectors.any? {|k,v| v.variance==0}
+        
+        ds=ds.fields.inject({}){|a,f|
+          a[f]=ods[f].standarized; 
+          a
         }.to_dataset
+        
         cronbach_alpha(ds)
       end
       # Predicted reliability of a test by replicating

data/lib/statsample/reliability/scaleanalysis.rb

@@ -53,12 +53,12 @@ module Statsample
         @variances=@k.times.map {|i| @cov_m[i,i]}.to_scale
         @variances_mean=@variances.mean
         @covariances_mean=(@variance-@variances.sum).quo(@k**2-@k)
-        begin
+        #begin
           @alpha = Statsample::Reliability.cronbach_alpha(@ds)
           @alpha_standarized = Statsample::Reliability.cronbach_alpha_standarized(@ds)
-        rescue => e
-          raise DatasetException.new(@ds,e), "Error calculating alpha"
-        end
+        #rescue => e
+        #  raise DatasetException.new(@ds,e), "Error calculating alpha"
+        #end
       end
       # Returns a hash with structure
       def item_characteristic_curve

data/lib/statsample/shorthand.rb

@@ -0,0 +1,81 @@
+module Statsample
+  # Module which provide shorthands for many methods.
+  module Shorthand
+    ###
+    # :section: R like methods
+    ###
+    
+    # Retrieve names (fields) from dataset
+    def names(ds)
+      ds.fields
+    end
+    # Create a correlation matrix from a dataset
+    def cor(ds)
+      Statsample::Bivariate.correlation_matrix(ds)
+    end
+    # Create a variance/covariance matrix from a dataset
+    def cov(ds)
+      Statsample::Bivariate.covariate_matrix(ds)
+    end
+    # Create a Statsample::Vector
+    # Analog to R's c
+    def c(*args)
+      Statsample::Vector[*args]
+    end
+    # Random generation for the normal distribution
+    def rnorm(n,mean=0,sd=1)
+      rng=Distribution::Normal.rng(mean,sd)
+      Statsample::Vector.new_scale(n) { rng.call}
+    end
+    # Creates a new Statsample::Dataset
+    # Each key is transformed into string
+    def dataset(vectors=Hash.new)
+      vectors=vectors.inject({}) {|ac,v| ac[v[0].to_s]=v[1];ac}
+      Statsample::Dataset.new(vectors)
+    end
+    alias :data_frame :dataset
+    # Returns a Statsample::Graph::Boxplot
+    def boxplot(*args)
+      Statsample::Graph::Boxplot.new(*args)
+    end
+    # Returns a Statsample::Graph::Histogram
+    def histogram(*args)
+      Statsample::Graph::Histogram.new(*args)
+    end
+    
+    # Returns a Statsample::Graph::Scatterplot
+    def scatterplot(*args)
+      Statsample::Graph::Scatterplot.new(*args)
+    end
+    # Returns a Statsample::Test::Levene
+    def levene(*args)
+      Statsample::Test::Levene.new(*args)
+    end
+    def principal_axis(*args)
+      Statsample::Factor::PrincipalAxis.new(*args)
+      
+    end
+    def polychoric(*args)
+      Statsample::Bivariate::Polychoric.new(*args)
+    end
+    def tetrachoric(*args)
+      Statsample::Bivariate::Tetrachoric.new(*args)
+    end
+
+    ###
+    # Other Shortcuts
+    ###
+    def lr(*args)
+      Statsample::Regression.multiple(*args)
+    end
+    def pca(ds,opts=Hash.new)
+      Statsample::Factor::PCA.new(ds,opts)
+    end
+    def dominance_analysis(*args)
+      Statsample::DominanceAnalysis.new(*args)
+    end
+    def dominance_analysis_bootstrap(*args)
+      Statsample::DominanceAnalysis::Bootstrap.new(*args)
+    end
+  end
+end

data/lib/statsample/test/chisquare.rb

@@ -26,7 +26,7 @@ module Statsample
           @value
         end
         def probability
-          1-Distribution::ChiSquare.cdf(@value,@df)
+          1-Distribution::ChiSquare.cdf(@value.to_f,@df)
         end
         def compute_chi
             sum=0

data/lib/statsample/vector.rb

@@ -1,17 +1,31 @@
 require 'date'
-class Array
-    # Creates a new Statsample::Vector object
-    # Argument should be equal to Vector.new
-	def to_vector(*args)
+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)
 	end
-    # Creates a new Statsample::Vector object of type :scale
-    def to_scale(*args)
-        Statsample::Vector.new(self, :scale,*args)
-    end
+  # Creates a new Statsample::Vector object of type :scale
+  def to_scale(*args)
+    Statsample::Vector.new(self, :scale, *args)
+  end
+end
+
+class Array
+  include Statsample::VectorShorthands
 end
 
+if Statsample.has_gsl?
+  module GSL
+    class Vector
+      include Statsample::VectorShorthands
+    end
+  end
+end
 module Statsample
+
  
   # Collection of values on one dimension. Works as a column on a Spreadsheet.
   # 
@@ -41,26 +55,21 @@ module Statsample
     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
     # Name of vector. Should be used for output by many classes
     attr_accessor :name
     
-    #
     # Creates a new Vector object.
-    # * <tt>data</tt> Array of data.
+    # * <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=:nominal, opts=Hash.new)
-      raise "Data should be an array" unless data.is_a? Array
-      @data=data
+      @data=data.is_a?(Array) ? data : data.to_a
       @type=type
       opts_default={
         :missing_values=>[],
@@ -84,9 +93,46 @@ module Statsample
       @missing_data=[]
       @has_missing_data=nil
       @scale_data=nil
-      set_valid_data_intern
+      set_valid_data
       self.type=type
     end
+    # Create a vector using (almost) any object
+    # * Array: flattened
+    # * Range: transformed using to_a
+    # * Statsample::Vector
+    # * Numeric and string values
+    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=:scale if vector.can_be_scale?
+      vector
+    end
+    # Create a new scale type vector
+    # Parameters
+    # [n]      Size
+    # [val]    Value of each value
+    # [&block] If block provided, is used to set the values of vector 
+    def self.new_scale(n,val=nil, &block)
+      if block
+        vector=n.times.map {|i| block.call(i)}.to_scale
+      else
+        vector=n.times.map { val}.to_scale
+      end
+      vector.type=:scale
+      vector
+    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.
@@ -98,40 +144,48 @@ module Statsample
     def dup_empty
       Vector.new([],@type, :missing_values => @missing_values.dup, :labels => @labels.dup, :name=> @name)
     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)
+    
+    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==:scale and @type!=:scale) or (t==:ordinal and @type==:nominal) or (t==:date) or (:date==@type)
     end
-    private :check_type
 
+    def vector_standarized_compute(m,sd) # :nodoc:
+      @data_with_nils.collect{|x| x.nil? ? nil : (x.to_f - m).quo(sd) }.to_vector(:scale)
+    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 :scale
-      return ([nil]*size).to_scale if mean.nil?
       m=mean
       sd=use_population ? sdp : sds
-      return ([nil]*size).to_scale if sd==0.0
-      vector=@data_with_nils.collect{|x|
-        if !x.nil?
-          (x.to_f - m).quo(sd)
-        else
-          nil
-        end
-      }.to_vector(:scale)
+      return ([nil]*size).to_scale 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_scale
+    end
     # Return a centered vector
     def vector_centered
       check_type :scale
       m=mean
-      vector=@data_with_nils.collect {|x|
-        x.nil? ? nil : x.to_f-m
-      }.to_scale
+      return ([nil]*size).to_scale if mean.nil?
+      vector=vector_centered_compute(m)
       vector.name=_("%s(centered)") % @name
       vector
     end
@@ -148,18 +202,18 @@ module Statsample
       vector
     end
     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)
+      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
-        (x**lambda-1).quo(lambda)
+        nil
       end
-    else
-      nil
-    end
-    }.to_vector(:scale)
+      }.to_vector(:scale)
     end
     
     # Vector equality.
@@ -193,6 +247,10 @@ module Statsample
     }
     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
@@ -250,7 +308,6 @@ module Statsample
       @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)
@@ -281,11 +338,14 @@ module Statsample
     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|
@@ -317,8 +377,7 @@ module Statsample
       !(x.nil? or @missing_values.include? x)
     end
     # Set missing_values.
-    # if update_valid = false, you should use
-    # set_valid_data after all changes
+    # set_valid_data is called after changes
     def missing_values=(vals)
       @missing_values = vals
       set_valid_data
@@ -335,7 +394,11 @@ module Statsample
       set_date_data if (t==:date)
     end
     def to_a
-      @data.dup
+      if @data.is_a? Array
+        @data.dup
+      else
+        @data.to_a
+      end
     end
     alias_method :to_ary, :to_a 
     
@@ -357,6 +420,10 @@ module Statsample
     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
@@ -370,20 +437,16 @@ module Statsample
     end
     def _vector_ari(method,v) # :nodoc:
     if(v.is_a? Vector or v.is_a? Array)
-      if v.size==@data.size
-      #                    i=0
+      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=[]
-      0.upto(v.size-1) {|i|
+      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, :scale  )
-      else
-      raise ArgumentError, "The array/vector parameter should be of the same size of the original vector"
-      end
+      Statsample::Vector.new(sum, :scale)
     elsif(v.respond_to? method )
       Statsample::Vector.new(
         @data.collect  {|x|
@@ -451,10 +514,10 @@ module Statsample
     }
     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
-    }
+      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,
@@ -463,13 +526,8 @@ module Statsample
     # In all the trails, every item have the same probability
     # of been selected.
     def sample_with_replacement(sample=1)
-      if(@type!=:scale or !Statsample.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
+      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.
@@ -479,7 +537,6 @@ module Statsample
     # A sample of the same size of the vector is the vector itself.
       
     def sample_without_replacement(sample=1)
-    if(@type!=:scale or !Statsample.has_gsl?)
       raise ArgumentError, "Sample size couldn't be greater than n" if sample>@valid_data.size
       out=[]
       size=@valid_data.size
@@ -487,11 +544,7 @@ module Statsample
         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
+      out.collect{|i| @data[i]}
     end
     # Retrieves number of cases which comply condition.
     # If block given, retrieves number of instances where
@@ -535,11 +588,11 @@ module Statsample
     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
+      if @data.find {|v| !v.nil? and !v.is_a? Numeric and !@missing_values.include? v}
+        false
+      else
+        true
+      end
     end
     
     def to_s
@@ -560,13 +613,13 @@ module Statsample
     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
+      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
@@ -579,6 +632,8 @@ module Statsample
         _frequencies
       end
     end
+    
+    
     def _frequencies #:nodoc:
       @valid_data.inject(Hash.new) {|a,x|
         a[x]||=0
@@ -589,7 +644,7 @@ module Statsample
     
     # Returns the most frequent item.
     def mode
-      frequencies.max{|a,b| a[1]<=>b[1]}[0]
+      frequencies.max{|a,b| a[1]<=>b[1]}.first
     end
     # The numbers of item with valid data.
     def n_valid
@@ -678,22 +733,17 @@ module Statsample
       # Return the median (percentil 50)
       def median
         check_type :ordinal
-        if Statsample.has_gsl? and @type==:scale
-          sorted=GSL::Vector.alloc(@scale_data.sort)
-          GSL::Stats::median_from_sorted_data(sorted)
-        else
-          percentil(50)
-        end
+        percentil(50)
       end
       # Minimun value
       def min 
         check_type :ordinal
-        @valid_data.min;
+        @valid_data.min
       end
         # Maximum value
       def max
         check_type :ordinal
-        @valid_data.max;
+        @valid_data.max
       end
     
     def set_date_data
@@ -722,9 +772,6 @@ module Statsample
           x.to_f
         end
       end
-      if Statsample.has_gsl?
-        @gsl=GSL::Vector.alloc(@scale_data) if @scale_data.size>0
-      end
     end
     
     private :set_date_data, :set_scale_data
@@ -791,7 +838,6 @@ module Statsample
     # Sample Standard deviation (denominator n-1)
     def standard_deviation_sample(m=nil)
         check_type :scale
-        
         m||=mean
         Math::sqrt(variance_sample(m))
     end
@@ -816,76 +862,30 @@ module Statsample
         check_type :scale
         @scale_data.inject(1){|a,x| a*x }
     end
-    if Statsample.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:
+    
+    # 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
-        @gsl.nil? ? nil : @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
-          return nil if @gsl.nil?
-          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=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
-
+      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.increment(@valid_data)
-        h
+        h=Statsample::Histogram.alloc(bins,[min,max])
+        # Fix last bin
+
       end
-      
+      h.increment(@valid_data)
+      h
     end
       
     # Coefficient of variation
@@ -894,7 +894,6 @@ module Statsample
         check_type :scale
         standard_deviation_sample.quo(mean)
     end
-    
     alias_method :sdp, :standard_deviation_population
     alias_method :sds, :standard_deviation_sample
     alias_method :adp, :average_deviation_population
@@ -902,5 +901,6 @@ module Statsample
     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