ruby-gsl-ngx 0.2.6.1

data/lib/gslng/matrix_view.rb

@@ -0,0 +1,47 @@
+module GSLng
+  class Matrix
+    # A View of a Matrix.
+    #
+    # Views reference an existing Matrix and can be used to access parts of it without having to copy
+    # it entirely. You can treat a View just like a Matrix.
+    # But note that modifying elements of a View will modify the elements of the original matrix.
+    #
+    class View < Matrix
+      attr_reader :owner # The Matrix owning the data this View uses
+
+      # Create a Matrix::View of the sub-matrix starting at (x,y), of size (m,n)
+      def initialize(owner, x, y, m, n) # @private
+        @owner = owner
+        @m,@n = m,n
+
+        @backend = GSLng.backend
+        ptr = GSLng.backend::gsl_matrix_submatrix2(owner.ptr, x, y, m, n)
+        @ptr = FFI::AutoPointer.new(ptr, View.method(:release))
+        @ptr_value = @ptr.to_i
+      end
+
+      def View.release(ptr)
+        GSLng.backend.gsl_matrix_free(ptr)
+      end
+
+      # Returns a Matrix (*NOT* a View) copied from this view. In other words,
+      # you'll get a Matrix which you can modify without modifying #owner elements.
+      # @return [Matrix]
+      def dup
+        matrix = Matrix.new(@m, @n)
+        GSLng.backend::gsl_matrix_memcpy(matrix.ptr, @ptr)
+        return matrix
+      end
+      alias_method :clone, :dup
+      alias_method :to_matrix, :dup
+
+      def view  # @private
+        raise "Can't create a View from a View"
+      end
+
+      def inspect # @private
+        "#{self}:MatrixView"
+      end
+    end
+  end
+end

data/lib/gslng/plotter.rb

@@ -0,0 +1,88 @@
+require 'singleton'
+require 'ffi'
+
+module GSLng
+  # This class encapsulates the communication with the plotting backend: gnuplot.
+  #
+  # Plot data is always represented as a {Matrix}, so you can use {Matrix#plot} to do a single plot.
+  # Otherwise, you can use {Matrix#define_plot} (taking the same parameters as the previous method) which returns a {Plotter::Plot}
+  # object. By defining multiple plot objects you can then use {Plotter#plot} passing all plot objects as parameters effectively
+  # creating a single output of all plots.
+  #
+  # This class works as {Singleton}, so when you instantiate it the gnuplot process is started. You can also send arbitrary commands
+  # to the gnuplot process by using the {Plotter#<<} operator. Read the gnuplot documentation on what are the possible commands you can send.
+  # 
+  class Plotter
+    include Singleton
+
+    attr_reader :io
+
+    # Creates the singleton Plotter object
+    def initialize
+      @io = IO.popen('gnuplot', 'w')
+      @io.sync = true
+      self << "set datafile nofpe_trap"
+    end
+    
+    # Close the pipe. It is desireable to call this in an "ensure" section, to avoid
+    # leaving the child gnuplot process there if the main ruby process dies
+    def close
+      pid = @io.pid
+      @io.flush; @io.close; @io = nil
+      begin
+      Process.kill 'TERM', pid
+      rescue Errno::ESRCH
+      end
+    end
+
+    # Send a command to the gnuplot process
+    # @example Setting the xrange
+    #  Plotter.instance << "set xrange [0:1]"
+    def <<(cmd)
+      @io.puts(cmd)
+    end
+
+    # Expects a variable number of {Plot} objects and creates a single plot out of them
+    def plot(*plots)
+      self << 'plot ' + plots.map(&:command).join(', ')
+      plots.each {|p| self.put_data(p.matrix)}
+    end
+
+    def put_data(matrix) # @private
+      ret = GSLng.backend.gsl_matrix_putdata(matrix.ptr, @io.to_i)
+      if (ret != 0) then raise SystemCallError.new("Problem sending data to gnuplot", ret) end
+    end
+
+    # Yields the given block enabling and disabling multiplot mode, before and after the yield respectively
+    def multiplot
+      self << 'set multiplot'
+      yield(self)
+    ensure
+      self << 'unset multiplot'
+    end
+
+    # This class holds a "plot" command and the associated matrix
+    class Plot < Struct.new(:command, :matrix); end
+  end
+
+  class Matrix
+    # Create a single plot out of the data contained in this Matrix
+    # @param [String] with The value of the 'with' option in gnuplot's plot command (i.e.: lines, linespoints, image, etc.)
+    # @param [String] extra_cmds Other variables/modifiers you can optionally pass to the "plot" command
+    def plot(with, extra_cmds = '')
+      Plotter.instance.plot(define_plot(with, extra_cmds))
+    end
+
+    # Works the same as {#plot} but returns a {Plotter::Plot} object you can store and then pass (along with other plot objects)
+    # to {Plotter#plot} and create a single plot out of them
+    # @return [Plot] The plot object you can pass to {Plotter#plot}
+    def define_plot(with, extra_cmds = '')
+      if (with == 'image')
+        cmd = "'-' binary array=(#{self.m},#{self.n}) format='%double' #{extra_cmds} with #{with}"
+      else
+        cmd = "'-' binary record=(#{self.m}) format=\"#{Array.new(self.n,'%double').join('')}\" #{extra_cmds} with #{with}"
+      end
+      Plotter::Plot.new(cmd, self)
+    end
+  end
+end

data/lib/gslng/rng/gaussian.rb

@@ -0,0 +1,34 @@
+module GSLng
+  class RNG
+    class Gaussian < RNG
+      attr_reader :ptr # @private
+
+      attr_reader :mu, :sigma
+      
+      # Creates a new Gaussian distribution
+      # @param [Float] mu mean
+      # @param [Float] sigma standard deviation
+      # @param [Symbol] sample_method The method to use to sample numbers. Can be either :boxmuller, :ziggurat or :ratio_method
+      # @param generator_type (see GSLng::RNG#initialize)
+      # @see http://www.gnu.org/software/gsl/manual/html_node/The-Gaussian-Distribution.html
+      def initialize(mu = 0, sigma = 1, sample_method = :boxmuller, generator_type = nil)
+        super(generator_type)
+        @mu,@sigma = mu,sigma
+
+        case sample_method
+        when :boxmuller; @function = :gsl_ran_gaussian
+        when :ziggurat; @function = :gsl_ran_gaussian_ziggurat
+        when :ratio_method; @function = :gsl_ran_ratio_method
+        else raise "Unsupported method"
+        end
+      end
+
+      # Obtain a sample from this distribution
+      # @return [Float]
+      def sample
+        GSLng.backend.send(@function, self.ptr, @sigma) + @mu
+      end
+      alias_method :get, :sample
+    end
+  end
+end

data/lib/gslng/rng/rng.rb

@@ -0,0 +1,28 @@
+module GSLng
+  # Random Number Generator class
+  # @abstract You should use any of the descendant classes which implement the {#sample} method.
+  class RNG
+    # Create a Generator of the given type
+    # @param [Symbol] generator_type the algorithm to use (without the +gsl_rng+ prefix). Default is :mt19937.
+    # @see http://www.gnu.org/software/gsl/manual/html_node/Random-number-generator-algorithms.html
+    def initialize(generator_type = nil)
+      @type = generator_type
+      if (@type.nil?) then @type = :mt19937 end # update comment above if changed
+      
+      type = GSLng.backend.send(:"gsl_rng_#{@type}")
+      @ptr = FFI::AutoPointer.new(GSLng.backend.gsl_rng_alloc(type), RNG.method(:release))
+    end
+    
+    def self.release(ptr)
+      GSLng.backend.gsl_rng_free(ptr)
+    end
+
+    def initialize_copy
+      type = GSLng.backend.send(:"gsl_rng_#{@type}")
+      @ptr = FFI::AutoPointer.new(GSLng.backend.gsl_rng_alloc(type), RNG.method(:release))
+    end
+  end
+end
+
+require 'gslng/rng/gaussian'
+require 'gslng/rng/uniform'

data/lib/gslng/rng/uniform.rb

@@ -0,0 +1,23 @@
+module GSLng
+  class RNG
+    class Uniform < RNG
+      attr_reader :ptr # @private
+      
+      # Creates a new Uniform distribution with values in [min,max)
+      # @param [Float] min
+      # @param [Float] max
+      # @param generator_type (see GSLng::RNG#initialize)
+      def initialize(min, max, generator_type = nil)
+        super(generator_type)
+        @min,@max = min,max
+      end
+
+      # Obtain a sample from this distribution
+      # @return [Float]
+      def sample
+        GSLng.backend.gsl_ran_flat(self.ptr, @min, @max)
+      end
+      alias_method :get, :sample
+    end
+  end
+end

data/lib/gslng/special.rb

@@ -0,0 +1,22 @@
+module GSLng
+  # A group of several different special functions.
+  #
+  # =Notes
+  # You can use this module simply by acessing its functions. Optionally, you can also extend the +Math+ standard module
+  # with these methods by doing:
+  #  Math.extend(GSLng::Special)
+  #
+  module Special
+    extend self # allow this module to be used as such, and as a mixin
+
+    # Restrict the given angle to the interval (-pi,pi]
+    def angle_restrict_symm(theta)
+      GSLng.backend.gsl_sf_angle_restrict_symm(theta)
+    end
+
+    # Restrict the given angle to the interval (0,2pi]
+    def angle_restrict_pos(theta)
+      GSLng.backend.gsl_sf_angle_restrict_pos(theta)
+    end
+  end
+end

data/lib/gslng/vector.rb

@@ -0,0 +1,553 @@
+module GSLng
+  # A fixed-size n-dimensional vector.
+  #
+  # =Notes
+  # * {#each}, {#map} and similar methods are implemented with C versions which should be fast.
+  # * {#map} returns a Vector, not an Array. Use {#map_array} for that.
+  # * While this class includes Enumerable, certain methods are redefined (like {#max} and {#min})
+  #   so they use internal GSL methods.
+  # * Some functions (like {#sum}, {#dot}, and others) use BLAS functions (through GSLng's CBLAS interface).
+  # * In contrary to Array, operators {#[]} and {#[]=} will raise an exception when accessing out-of-bounds elements.
+  # * Operator {#*} multiplies two vectors element-by-element. To perform a dot product use the {#^} operator instead (or the {#dot} alias).
+  # * Operands are coerced to vectors so you can do vector + scalar, etc. (see {#coerce})
+  #
+  class Vector
+    include Enumerable
+        
+    attr_reader :size, :stride
+    attr_reader :ptr  # @private
+    attr_reader :ptr_value # @private
+
+    # @group Constructors
+    
+    # Create a Vector of size n. If zero is true, the vector is initialized with zeros.
+    # Otherwise, the vector will contain garbage.
+    # You can optionally pass a block, in which case {#map_index!} will be called with it (i.e.: it works like {Array.new}).
+    def initialize(n, zero = false)
+      @backend = GSLng.backend
+      ptr = (zero ? @backend.gsl_vector_calloc(n) : @backend.gsl_vector_alloc(n))
+      @ptr = FFI::AutoPointer.new(ptr, Vector.method(:release))
+      @ptr_value = @ptr.to_i
+      @size = n
+      @stride = 1
+      if (block_given?) then self.map_index!(Proc.new) end
+    end
+
+    def initialize_copy(other) # @private
+      @backend = GSLng.backend
+      ptr = @backend.gsl_vector_alloc(other.size)
+      @ptr = FFI::AutoPointer.new(ptr, Vector.method(:release))
+      @ptr_value = @ptr.to_i
+      @size = other.size
+      @stride = 1
+      @backend.gsl_vector_memcpy(@ptr, other.ptr)
+    end
+
+    def Vector.release(ptr) # @private
+      GSLng.backend.gsl_vector_free(ptr)
+    end
+
+    # Same as Vector.new(n, true)
+    def Vector.zero(n); Vector.new(n, true) end
+
+    # Create a vector from an Array.
+    def Vector.from_array(array)
+      if (array.empty?) then raise "Can't create empty vector" end
+      v = Vector.new(array.size)
+      GSLng.backend.gsl_vector_from_array(v.ptr_value, array)
+      return v
+    end
+
+    # Creates a Vector with linearly distributed values between +start+ and +stop+, separated by +delta+.
+    def Vector.linspace(start, stop, delta)
+      if (start > stop || delta <= 0) then raise 'Invalid values' end
+      Vector.new(((stop - start) / delta).floor.to_i + 1) {|i| start + delta * i}
+    end
+
+    # Creates a Vector from an Array or a Range
+    # @see Vector::from_array    
+    # @example
+    #   Vector[1,2,3]
+    #   Vector[1..3]
+    def Vector.[](*args)
+      array = (args.size == 1 && Range === args[0] ? args[0].to_a : args)
+      Vector.from_array(array)
+    end
+
+    # Generates a Vector of n random numbers between 0 and 1.
+    # NOTE: This simply uses {Kernel::rand}
+    def Vector.random(n)
+      Vector.new(n).map!{|x| Kernel::rand}
+    end
+    class << self; alias_method :rand, :random end
+
+    # @group Operators
+    
+    # Add (element-by-element) other to self
+    # @return [Vector] self
+    def add!(other)
+      case other
+      when Numeric; @backend.gsl_vector_add_constant(@ptr, other.to_f)
+      when Vector; @backend.gsl_vector_add(@ptr, other.ptr)
+      else
+        x,y = other.coerce(self)
+        x.add!(y)
+      end
+      return self
+    end
+    
+    # Substract (element-by-element) other from self
+    # @return [Vector] self    
+    def substract!(other)
+      case other
+      when Numeric; @backend.gsl_vector_add_constant(@ptr, -other.to_f)
+      when Vector; @backend.gsl_vector_sub(@ptr, other.ptr)
+      else
+        x,y = other.coerce(self)
+        x.sub!(y)
+      end
+      return self
+    end
+    alias_method :sub!, :substract!
+    
+    # Multiply (element-by-element) other with self
+    # @return [Vector] self
+    def multiply!(other)
+      case other
+      when Numeric; @backend.gsl_blas_dscal(other.to_f, @ptr)
+      when Vector; @backend.gsl_vector_mul(@ptr, other.ptr)
+      else
+        x,y = other.coerce(self)
+        x.mul!(y)
+      end
+      return self
+    end
+    alias_method :mul!, :multiply!
+    
+    # Divide (element-by-element) self by other
+    # @return [Vector] self
+    def divide!(other)
+      case other
+      when Numeric; @backend.gsl_blas_dscal(1.0 / other, @ptr)
+      when Vector;  @backend.gsl_vector_div(@ptr, other.ptr)
+      else
+        x,y = other.coerce(self)
+        x.div!(y)
+      end
+      return self
+    end
+    alias_method :div!, :divide!
+
+    # Element-by-element addition
+    def +(other); self.dup.add!(other) end
+
+    # Element-by-element substraction
+    def -(other); self.dup.sub!(other) end
+
+    # Element-by-element product
+    # @example
+    #  Vector[1,2,3] * 2 => [2.0, 4.0, 6.0]:Vector
+    #  Vector[1,2,3] * Vector[0,1,2] => [0.0, 2.0, 6.0]:Vector    
+    def *(other)
+      case other
+      when Numeric; self.dup.mul!(other)
+      when Vector; self.dup.mul!(other)
+      else
+        x,y = other.coerce(self)
+        x * y
+      end
+    end
+
+    # Element-by-element division
+    def /(other); self.dup.div!(other) end
+
+    # Invert sign on all elements
+    def -@; self.map!(&:-@) end
+
+    # @group Other mathematical operations
+
+    # Dot product between self and other (uses BLAS's ddot)
+    # @return [Float]
+    # @example
+    #  Vector[1,2,3] ^ Vector[0,1,2] => 8.0
+    def dot(other)
+      out = FFI::Buffer.new(:double)
+      @backend.gsl_blas_ddot(@ptr, other.ptr, out)
+      return out[0].get_double(0)
+    end
+    alias_method :^, :dot
+    
+    # Norm 2 of the vector (uses BLAS's dnrm2)
+    def norm; @backend.gsl_blas_dnrm2(@ptr) end
+    alias_method :length, :norm
+
+    # Returns the sum of all elements (uses BLAS's dasum)
+    def sum; @backend.gsl_blas_dasum(@ptr) end
+
+    # Optimized version of: self += other * alpha (where alpha is a Numeric). Uses BLAS's daxpy.
+    def mul_add(other, alpha); @backend.gsl_blas_daxpy(alpha, other.ptr, @ptr); return self end
+
+    # @group Miscelaneous methods
+    
+    # Reverse the order of elements
+    def reverse!; @backend.gsl_vector_reverse(@ptr); return self end
+    
+    # Swap the i-th element with the j-th element
+    def swap(i,j); @backend.gsl_vector_swap_elements(@ptr, i, j); return self end
+
+    def sort!; @backend.gsl_sort_vector(@ptr); return self end
+    def sort; self.dup.sort! end
+
+    # Copy other's values into self
+    def copy(other); @backend.gsl_vector_memcpy(@ptr, other.ptr); return self end
+
+    # Wraps self into the interval [0,up_to). NOTE: this value must be > 0
+    # @param [Vector,Numeric] up_to
+    # @return [Vector] a vector of values -1, 1 or 0, if (max-min) was substracted, added to the coordinate,
+    # or not modified, respectively.
+    # @example Assuming that +v = Vector[-8,2,8]+
+    #  v.wrap(5) => [1.0 0.0 -1.0]:Vector
+    #  v => [-3.0 2.0 3.0]:Vector
+    def wrap!(up_to)
+      delta = Vector.new(self.size)
+      self.map_index! do |i|
+        a,b = self[i].divmod(up_to)
+        delta[i] = -a
+        b
+      end
+      return delta
+    end
+    
+    # Compute hash value for this Vector.
+    # Note: this may be a bit inefficient for now
+    def hash
+      self.to_a.hash
+    end
+
+    # @group Setting/getting values
+
+    # Access the i-th element.
+    # If _index_ is negative, it counts from the end (-1 is the last element).
+    # @raise [RuntimeError] if out-of-bounds
+    # @todo support ranges
+    def [](index)
+      @backend.gsl_vector_get_operator(@ptr_value, index)
+    end
+
+    # Set the i-th element.
+    # If _index_ is negative, it counts from the end (-1 is the last element).
+    # @raise [RuntimeError] if out-of-bounds
+    # @todo support ranges    
+    def []=(index, value)
+      @backend.gsl_vector_set_operator(@ptr_value, index, value.to_f)
+      #@backend.gsl_vector_set(@ptr, (index < 0 ? @size + index : index), value.to_f)
+    end
+
+    # @group Views
+
+    # Create a {Vector::View} from this Vector.
+    # If _size_ is nil, it is computed automatically from _offset_ and _stride_
+    def view(offset = 0, size = nil, stride = 1)
+      if (stride <= 0) then raise 'stride must be positive' end
+      
+      if (size.nil?)
+        size = @size - offset
+        k,m = size.divmod(stride)
+        size = k + (m == 0 ? 0 : 1)
+      end
+
+      if (stride == 1) then ptr = @backend.gsl_vector_subvector2(@ptr, offset, size)
+      else ptr = @backend.gsl_vector_subvector_with_stride2(@ptr, offset, stride, size) end
+      View.new(ptr, self, size, stride)
+    end
+    alias_method :subvector_view, :view
+
+    # Shorthand for #subvector_view(..).to_vector.
+    def subvector(*args); subvector_view(*args).to_vector end
+
+    # Set all values to v
+    def all!(v); @backend.gsl_vector_set_all(@ptr, v); return self end
+    alias_method :set!, :all!
+    alias_method :fill!, :all!
+
+    # Set all values to zero
+    def zero!; @backend.gsl_vector_set_zero(@ptr); return self end
+
+    # Set all values to zero, except the i-th element, which is set to 1
+    def basis!(i); @backend.gsl_vector_set_basis(@ptr, i); return self end
+
+    # @group 2D/3D/4D utility vectors
+
+    # Same as Vector#[0]
+    def x; @backend.gsl_vector_get(@ptr, 0) end
+    # Same as Vector#[1]
+    def y; @backend.gsl_vector_get(@ptr, 1) end
+    # Same as Vector#[2]
+    def z; @backend.gsl_vector_get(@ptr, 2) end
+    # Same as Vector#[3]
+    def w; @backend.gsl_vector_get(@ptr, 3) end
+
+    # Same as Vector#[0]=
+    def x=(v); @backend.gsl_vector_set(@ptr, 0, v.to_f) end
+    # Same as Vector#[1]=
+    def y=(v); @backend.gsl_vector_set(@ptr, 1, v.to_f) end
+    # Same as Vector#[2]=
+    def z=(v); @backend.gsl_vector_set(@ptr, 2, v.to_f) end
+    # Same as Vector#[3]=
+    def w=(v); @backend.gsl_vector_set(@ptr, 3, v.to_f) end
+    
+    # @group Predicate methods
+
+    # if all elements are zero
+    def zero?; @backend.gsl_vector_isnull(@ptr) == 1 ? true : false end
+
+    # if all elements are strictly positive (>0)
+    def positive?; @backend.gsl_vector_ispos(@ptr) == 1 ? true : false end
+
+    #if all elements are strictly negative (<0)
+    def negative?; @backend.gsl_vector_isneg(@ptr) == 1 ? true : false end
+    
+    # if all elements are non-negative (>=0)
+    def nonnegative?; @backend.gsl_vector_isnonneg(@ptr) == 1 ? true : false end
+
+    # If each element of self is less than other's elements
+    def <(other); (other - self).positive? end
+
+    # If each element of self is greater than other's elements
+    def >(other); (other - self).negative? end
+
+    # If each element of self is less-or-equal than other's elements
+    def <=(other); (other - self).nonnegative? end
+
+    # If each element of self is less-or-equal than other's elements
+    def >=(other); (self - other).nonnegative? end
+
+    # @group Minimum/Maximum
+
+    # Return maximum element of vector
+    def max; @backend.gsl_vector_max(@ptr) end
+    
+    # Return minimum element of vector
+    def min; @backend.gsl_vector_min(@ptr) end
+
+    # Same as {Array#minmax}
+    def minmax
+      min = FFI::Buffer.new(:double)
+      max = FFI::Buffer.new(:double)
+      @backend.gsl_vector_minmax(@ptr, min, max)
+      return [min[0].get_float64(0),max[0].get_float64(0)]
+    end
+
+    # Same as {#minmax}, but returns the indices to the elements
+    def minmax_index
+      min = FFI::Buffer.new(:size_t)
+      max = FFI::Buffer.new(:size_t)
+      @backend.gsl_vector_minmax_index(@ptr, min, max)
+      #return [min[0].get_size_t(0),max[0].get_size_t(0)]
+      return [min[0].get_ulong(0),max[0].get_ulong(0)]
+    end
+    
+    # Same as {#min}, but returns the index to the element
+    def min_index; @backend.gsl_vector_min_index(@ptr) end
+
+    # Same as {#max}, but returns the index to the element
+    def max_index; @backend.gsl_vector_max_index(@ptr) end
+    
+    # @group Statistics
+    
+    # Compute the mean of the vector
+    def mean; @backend.gsl_stats_mean(self.as_array, self.stride, self.size) end
+    
+    # Compute the median of the vector
+    # *Note* it assumes sorted data!
+    def median; @backend.gsl_stats_median_from_sorted_data(self.as_array, self.stride, self.size) end
+
+    # Compute the median of the vector
+    # *Note* it assumes sorted data!
+    # @param [Float] f A number between 0 and 1 indicating the percentile
+    def quantile(f); @backend.gsl_stats_quantile_from_sorted_data(self.as_array, self.stride, self.size, f) end
+
+    # Compute the variance of the vector
+    # @param [Float] mean Optionally supply the mean if you already computed it previously with {self#mean}
+    # @param [Boolean] fixed_mean If true, the passed mean is taken to be known a priori (see GSL documentation)
+    def variance(mean = nil, fixed_mean = false)
+      if (mean.nil?) then @backend.gsl_stats_variance(self.as_array, self.stride, self.size)
+      else
+        if (fixed_mean) then @backend.gsl_stats_variance_with_fixed_mean(self.as_array, self.stride, self.size, mean)
+        else @backend.gsl_stats_variance_m(self.as_array, self.stride, self.size, mean) end
+      end
+    end
+    
+    # Compute the standard deviation of the vector
+    # @see #variance
+    def standard_deviation(mean = nil, fixed_mean = false)
+      if (mean.nil?) then @backend.gsl_stats_sd(self.as_array, self.stride, self.size)
+      else
+        if (fixed_mean) then @backend.gsl_stats_sd_with_fixed_mean(self.as_array, self.stride, self.size, mean)
+        else @backend.gsl_stats_sd_m(self.as_array, self.stride, self.size, mean) end
+      end
+    end    
+
+    # Compute the total sum of squares of the vector
+    # @see #variance
+    def total_sum_squares(mean = nil)
+      if (mean.nil?) then @backend.gsl_stats_tss(self.as_array, self.stride, self.size)
+      else @backend.gsl_stats_tss_m(self.as_array, self.stride, self.size, mean) end
+    end
+
+    # Compute the absolute deviation of the vector
+    # @see #variance
+    def absolute_deviation(mean = nil)
+      if (mean.nil?) then @backend.gsl_stats_absdev(self.as_array, self.stride, self.size)
+      else @backend.gsl_stats_absdev_m(self.as_array, self.stride, self.size, mean) end
+    end
+
+    # Compute the skewness of the vector. You can optionally provide the mean *and* the standard deviation if you already computed them
+    def skew(mean = nil, sd = nil)
+      if (mean.nil? || sd.nil?) then @backend.gsl_stats_skew(self.as_array, self.stride, self.size)
+      else @backend.gsl_stats_skew_sd_m(self.as_array, self.stride, self.size, mean, sd) end
+    end
+
+    # Compute the kurtosis of the vector
+    # @see #skew
+    def kurtosis(mean = nil, sd = nil)
+      if (mean.nil? || sd.nil?) then @backend.gsl_stats_kurtosis(self.as_array, self.stride, self.size)
+      else @backend.gsl_stats_kurtosis_sd_m(self.as_array, self.stride, self.size, mean, sd) end
+    end
+
+    # Compute the autocorrelation of the vector
+    # @see #variance
+    def autocorrelation(mean = nil)
+      if (mean.nil?) then @backend.gsl_stats_lag1_autocorrelation(self.as_array, self.stride, self.size)
+      else @backend.gsl_stats_lag1_autocorrelation(self.as_array, self.stride, self.size, mean) end
+    end
+
+    # Compute the covariance between self and other. You can optionally pass the mean of both vectors if you already computed them
+    # @see #variance
+    def covariance(other, mean1 = nil, mean2 = nil)
+      if (mean1.nil? || mean2.nil?) then @backend.gsl_stats_covariance(self.as_array, self.stride, other.as_array, other.stride, self.size)
+      else @backend.gsl_stats_covariance(self.as_array, self.stride, other.as_array, other.stride, self.size, mean1, mean2) end
+    end
+
+    # Compute the correlation between self and other
+    def correlation(other)
+      @backend.gsl_stats_correlation(self.as_array, self.stride, other.as_array, other.stride, self.size)
+    end
+
+    # @group High-order methods
+
+    # @yield [elem]
+    def each(block = Proc.new)
+      @backend.gsl_vector_each(@ptr_value, &block)
+    end
+
+    # @see #each
+    # @yield [elem,i]
+    def each_with_index(block = Proc.new)
+      @backend.gsl_vector_each_with_index(@ptr_value, &block)
+    end
+
+    # @see #map
+    def map!(block = Proc.new); @backend.gsl_vector_map!(@ptr_value, &block); return self end
+
+    # Similar to {#map!}, but passes the index to the element instead.
+    # @yield [i]
+    def map_index!(block = Proc.new); @backend.gsl_vector_map_index!(@ptr_value, &block); return self end
+
+    # @return [Vector]
+    # @see #map_index!
+    # @yield [i]
+    def map_index(block = Proc.new); self.dup.map_index!(block) end
+
+    alias_method :map_old, :map
+
+    # Acts like the normal 'map' method from Enumerator
+    # @return [Array]
+    # @see #map
+    # @yield [i]
+    def map_array(block = Proc.new); self.map_old(&block); end
+
+    # @return [Vector]
+    # @yield [elem]
+    def map(block = Proc.new); self.dup.map!(block) end
+
+    # @group Type conversions
+
+    # @see Array#join
+    # @return [String]
+    def join(sep = $,)
+      s = ''
+      self.each do |e|
+        s += (s.empty?() ? e.to_s : "#{sep}#{e}")
+      end
+      return s
+    end
+
+    # Coerces _other_ to be a Vector. 
+    # @example
+    #  Vector[1,2].coerce(5) => [[5.0, 5.0]:Vector, [1.0, 2.0]:Vector]
+    def coerce(other)
+      case other
+      when Vector
+        [ other, self ]
+      when Numeric
+        [ Vector.new(@size).set!(other), self ]
+      else
+        raise TypeError, "Can't coerce #{other.class} into #{self.class}"
+      end
+    end
+
+    # @return [String] same format as {Array#to_s}
+    # @example
+    #  Vector[1,2,3].to_s => "[1.0, 2.0, 3.0]"
+    def to_s
+      "[" + self.join(', ') + "]"
+    end
+
+    def inspect # @private
+      "#{self}:Vector"
+    end
+
+    # @return [Array]
+    def to_a
+      @backend.gsl_vector_to_a(@ptr_value)
+    end
+    
+    def as_array # @private
+      @backend.gsl_vector_as_array(@ptr)
+    end
+
+    # Create a row matrix from this vector
+    # @return [Matrix]
+    def to_matrix
+      m = Matrix.new(1, @size)
+      @backend.gsl_matrix_set_row(m.ptr, 0, @ptr)
+      return m
+    end
+    alias_method :to_row, :to_matrix
+
+    # Create a column matrix from this vector
+    # @return [Matrix]
+    def transpose
+      m = Matrix.new(@size, 1)
+      @backend.gsl_matrix_set_col(m.ptr, 0, @ptr)
+      return m
+    end
+    alias_method :to_column, :transpose
+
+    # @group Equality test
+
+    # Element-by-element comparison. Admits comparing to Array.
+    def ==(other)
+      if (self.size != other.size) then return false end
+      self.each_with_index do |elem,i|
+        if (elem != other[i]) then return false end
+      end
+      return true
+    end
+
+    def eql?(other)
+      @backend.gsl_vector_eql?(@ptr_value, other.ptr_value)
+    end
+  end
+end