ruby-gsl-ng 0.2.3 → 0.2.4

data/History.txt

@@ -1,3 +1,14 @@
+=== 0.2.4
+* Features:
+  * Plotting support (using gnuplot) (Plotter class and associated methods on Matrix).
+  * Added Matrix#map_array (just like Vector#map_array)
+  * C version of operator []
+  * Support for some statistics operations in Vector
+  * Updated documentation to use YARD's @group feature
+* Internal Changes:
+  * GSL memory is managed by FFI::AutoPointer now
+* Fixes
+  * On some systems, with Ruby 1.8 the extension was missing libstdc++ support
 === 0.2.3
 * FIXES:
   * HUGE memory leak, no GSL object was ever freed.

data/Manifest

@@ -1,19 +1,20 @@
 History.txt
 README.rdoc
 Rakefile
-TODO
 ext/extconf.rb
 ext/gslng_extensions.cpp
+ext/plotting.cpp
 lib/gslng.rb
 lib/gslng/backend.rb
 lib/gslng/backend_components/error_handling.rb
 lib/gslng/backend_components/matrix.rb
 lib/gslng/backend_components/rng.rb
 lib/gslng/backend_components/special.rb
+lib/gslng/backend_components/stats.rb
 lib/gslng/backend_components/vector.rb
-lib/gslng/finalizer.rb
 lib/gslng/matrix.rb
 lib/gslng/matrix_view.rb
+lib/gslng/plotter.rb
 lib/gslng/rng/gaussian.rb
 lib/gslng/rng/rng.rb
 lib/gslng/rng/uniform.rb

data/Rakefile

@@ -6,9 +6,9 @@ require 'yard'
 
 Echoe.new('ruby-gsl-ng') do |p|
   p.author = 'v01d'
-  p.summary = "Ruby Object Oriented Graph LIbrary"
+  p.summary = "Ruby/GSL new-generation wrapper"
   p.url = "http://github.com/v01d/ruby-gsl-ng"
-  p.version = "0.2.3"
+  p.version = "0.2.4"
   p.dependencies = ['yard', 'ffi']
 #  p.eval = proc { s.has_rdoc = 'yard' }
 end

data/ext/extconf.rb

@@ -1,6 +1,14 @@
 #!/usr/bin/ruby
 require 'mkmf'
+
+extra_flags='-O4 -DHAVE_INLINE=1'
+
+## Check for GSL
 gsl_vars = pkg_config('gsl') or raise 'GSL not found!'
-extra_flags='-O4 -DHAVE_INLINE'
+
+# Configuration
+if (RUBY_VERSION =~ /^1\.8/) then $libs << ' -lstdc++' end # Seems necessary in some cases
+
+## Create Makefile
 with_cppflags("#{extra_flags}") { true }
 create_makefile('gslng_extensions')

data/ext/gslng_extensions.cpp

@@ -66,6 +66,13 @@ static VALUE gsl_vector_from_array(VALUE self, VALUE ptr, VALUE array) {
 	return self;
 }
 
+static VALUE gsl_vector_get_operator(VALUE self, VALUE ptr, VALUE element) {
+  gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+  long i = FIX2LONG(element);
+  if (i < 0) { i = v->size + i; }
+  return rb_float_new(gsl_vector_get(v, (size_t)i));
+}
+
 // Hide the view in a new vector (gsl_vector_subvector)
 extern "C" gsl_vector* gsl_vector_subvector_with_stride2(gsl_vector* v, size_t offset, size_t stride, size_t n) {
   gsl_vector_view view = gsl_vector_subvector_with_stride(v, offset, stride, n);
@@ -82,6 +89,10 @@ extern "C" gsl_vector* gsl_vector_subvector2(gsl_vector* v, size_t offset, size_
   return vector_view;
 }
 
+extern "C" double* gsl_vector_as_array(gsl_vector* v) {
+	return v->data;
+}
+
 /************************* Matrix functions *****************************/
 
 static VALUE gsl_matrix_map(VALUE self, VALUE ptr) {
@@ -96,6 +107,21 @@ static VALUE gsl_matrix_map(VALUE self, VALUE ptr) {
   return self;
 }
 
+static VALUE gsl_matrix_map_array(VALUE self, VALUE ptr) {
+  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+
+	VALUE array = rb_ary_new2(m->size1);
+	for (size_t i = 0; i < m->size1; i++) {
+    VALUE row = rb_ary_new2(m->size2);
+    for (size_t j = 0; j < m->size2; j++) {
+      rb_ary_store(row, j, rb_yield(rb_float_new(gsl_matrix_get(m, i, j))));
+    }
+    rb_ary_store(array, i, row);
+  }
+
+	return array;
+}
+
 static VALUE gsl_matrix_map_index(VALUE self, VALUE ptr) {
   gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
   size_t size1 = m->size1;
@@ -206,6 +232,7 @@ extern "C" void Init_gslng_extensions(void) {
 	VALUE Backend_module = rb_funcall(GSLng_module, rb_intern("backend"), 0);
 
 	// vector
+  rb_define_module_function(Backend_module, "gsl_vector_get_operator", (VALUE(*)(ANYARGS))gsl_vector_get_operator, 2);
 	rb_define_module_function(Backend_module, "gsl_vector_map!", (VALUE(*)(ANYARGS))gsl_vector_map, 1);
 	rb_define_module_function(Backend_module, "gsl_vector_map_index!", (VALUE(*)(ANYARGS))gsl_vector_map_index, 1);
 	rb_define_module_function(Backend_module, "gsl_vector_each_with_index", (VALUE(*)(ANYARGS))gsl_vector_each_with_index, 1);
@@ -215,10 +242,11 @@ extern "C" void Init_gslng_extensions(void) {
 
   // matrix
 	rb_define_module_function(Backend_module, "gsl_matrix_map!", (VALUE(*)(ANYARGS))gsl_matrix_map, 1);
+  rb_define_module_function(Backend_module, "gsl_matrix_map_array", (VALUE(*)(ANYARGS))gsl_matrix_map_array, 1);
 	rb_define_module_function(Backend_module, "gsl_matrix_map_index!", (VALUE(*)(ANYARGS))gsl_matrix_map_index, 1);
   rb_define_module_function(Backend_module, "gsl_matrix_map_with_index!", (VALUE(*)(ANYARGS))gsl_matrix_map_with_index, 1);
 	rb_define_module_function(Backend_module, "gsl_matrix_each_with_index", (VALUE(*)(ANYARGS))gsl_matrix_each_with_index, 1);
 	rb_define_module_function(Backend_module, "gsl_matrix_each", (VALUE(*)(ANYARGS))gsl_matrix_each, 1);
 	rb_define_module_function(Backend_module, "gsl_matrix_to_a", (VALUE(*)(ANYARGS))gsl_matrix_to_a, 1);
 	rb_define_module_function(Backend_module, "gsl_matrix_from_array", (VALUE(*)(ANYARGS))gsl_matrix_from_array, 2);
-}
+}

data/ext/plotting.cpp

@@ -0,0 +1,9 @@
+#include <gsl/gsl_matrix.h>
+#include <unistd.h>
+
+extern "C" int gsl_matrix_putdata(gsl_matrix* m, int fd) {
+  size_t bytes = m->size1 * m->size2 * sizeof(double);
+  long ret = write(fd, m->data, bytes);
+  if (ret == -1 || (ulong)ret < bytes) return errno;
+  else return 0;
+}

data/lib/gslng.rb

@@ -1,6 +1,6 @@
 require 'gslng/backend'
-require 'gslng/finalizer'
 
+require 'gslng/plotter'
 require 'gslng/vector'
 require 'gslng/vector_view'
 require 'gslng/matrix'

data/lib/gslng/backend.rb

@@ -20,3 +20,4 @@ require 'gslng/backend_components/matrix'
 require 'gslng/backend_components/error_handling'
 require 'gslng/backend_components/rng'
 require 'gslng/backend_components/special'
+require 'gslng/backend_components/stats'

data/lib/gslng/backend_components/matrix.rb

@@ -62,5 +62,8 @@ module GSLng
     enum :cblas_transpose_t, [ :no_transpose, 111, :transpose, :conjugate_transpose ]
     attach_function :gsl_blas_dgemv, [ :cblas_transpose_t, :double, :pointer, :pointer, :double, :pointer ], :int
     attach_function :gsl_blas_dgemm, [ :cblas_transpose_t, :cblas_transpose_t, :double, :pointer, :pointer, :double, :pointer ], :int
+
+    # communication to gnuplot
+    attach_function :gsl_matrix_putdata, [ :pointer, :int ], :int
   end
 end

data/lib/gslng/backend_components/stats.rb

@@ -0,0 +1,35 @@
+module GSLng
+  backend.instance_eval do
+    # mean, sd and variance
+    attach_function :gsl_stats_mean, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_variance, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_variance_m, [ :pointer, :size_t, :size_t, :double ], :double
+    attach_function :gsl_stats_sd, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_sd_m, [ :pointer, :size_t, :size_t, :double ], :double
+    attach_function :gsl_stats_tss, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_tss_m, [ :pointer, :size_t, :size_t, :double ], :double
+    attach_function :gsl_stats_variance_with_fixed_mean, [ :pointer, :size_t, :size_t, :double ], :double
+    attach_function :gsl_stats_sd_with_fixed_mean, [ :pointer, :size_t, :size_t, :double ], :double
+
+    # absolute deviation
+    attach_function :gsl_stats_absdev, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_absdev_m, [ :pointer, :size_t, :size_t, :double ], :double
+
+    # skewness and kurtosis
+    attach_function :gsl_stats_skew, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_skew_m_sd, [ :pointer, :size_t, :size_t, :double, :double ], :double
+    attach_function :gsl_stats_kurtosis, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_kurtosis_m_sd, [ :pointer, :size_t, :size_t, :double, :double ], :double
+
+    # autocorrelation
+    attach_function :gsl_stats_lag1_autocorrelation, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_lag1_autocorrelation_m, [ :pointer, :size_t, :size_t, :double ], :double
+
+    # covariance
+    attach_function :gsl_stats_covariance, [ :pointer, :size_t, :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_stats_covariance_m, [ :pointer, :size_t, :pointer, :size_t, :size_t, :double, :double ], :double
+
+    # correlation
+    attach_function :gsl_stats_correlation, [ :pointer, :size_t, :pointer, :size_t, :size_t ], :double
+  end
+end

data/lib/gslng/backend_components/vector.rb

@@ -59,5 +59,6 @@ module GSLng
     # views
     attach_function :gsl_vector_subvector2, [ :pointer, :size_t, :size_t ], :pointer
     attach_function :gsl_vector_subvector_with_stride2, [ :pointer, :size_t, :size_t, :size_t ], :pointer
+    attach_function :gsl_vector_as_array, [ :pointer ], :pointer
   end
 end

data/lib/gslng/matrix.rb

@@ -19,28 +19,30 @@ module GSLng
     # Shorthand for [{#rows},{#columns}]
     def size; [ @m, @n ] end
 
-    #--------------------- constructors -------------------------#
+    # @group Constructors
 
     # Create a Matrix of m-by-n (rows and columns). If zero is true, the Matrix is initialized with zeros.
     # Otherwise, the Matrix 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(m, n, zero = false)
-      @ptr = (zero ? GSLng.backend::gsl_matrix_calloc(m, n) : GSLng.backend::gsl_matrix_alloc(m, n))
-      GSLng.define_finalizer(self, :gsl_matrix_free, @ptr)
-
+      ptr = zero ? GSLng.backend::gsl_matrix_calloc(m, n) : GSLng.backend::gsl_matrix_alloc(m, n)
+      @ptr = FFI::AutoPointer.new(ptr, Matrix.method(:release))
       @m,@n = m,n
       if (block_given?) then self.map_index!(Proc.new) end
     end
 
     def initialize_copy(other) # @private
-      ObjectSpace.undefine_finalizer(self) # TODO: ruby bug?
-      @ptr = GSLng.backend::gsl_matrix_alloc(other.m, other.n)
-      GSLng.define_finalizer(self, :gsl_matrix_free, @ptr)
+      ptr = GSLng.backend::gsl_matrix_alloc(other.m, other.n)
+      @ptr = FFI::AutoPointer.new(ptr, Matrix.method(:release))
 
       @m,@n = other.size
       GSLng.backend::gsl_matrix_memcpy(@ptr, other.ptr)
     end
 
+    def Matrix.release(ptr) # @private
+      GSLng.backend.gsl_matrix_free(ptr)
+    end
+
     # Same as Matrix.new(m, n, true)
     def Matrix.zero(m, n); Matrix.new(m, n, true) end
 
@@ -79,20 +81,7 @@ module GSLng
     end
     class << self; alias_method :rand, :random end
 
-    #--------------------- setting values -------------------------#
-
-    # Set all values to _v_
-    def all!(v); GSLng.backend::gsl_matrix_set_all(@ptr, v); return self end
-    alias_method :set!, :all!
-    alias_method :fill!, :all!
-
-    # Set all values to zero
-    def zero!; GSLng.backend::gsl_matrix_set_zero(@ptr); return self end
-
-    # Set the identity matrix values
-    def identity; GSLng.backend::gsl_matrix_set_identity(@ptr); return self end
-
-    #--------------------- set/get -------------------------#
+    # @group Setting/getting values
 
     # Access the element (i,j), which means (row,column).
     # Symbols :* or :all can be used as wildcards for both dimensions.
@@ -104,17 +93,19 @@ module GSLng
     # @raise [RuntimeError] if out-of-bounds
     # @return [Numeric,Matrix] the element/sub-matrix
     def [](i, j = :*)
-      if (Symbol === i && Symbol === j) then return self
-      elsif (Symbol === i)
-        col = Vector.new(@m)
-        GSLng.backend::gsl_matrix_get_col(col.ptr, @ptr, j)
-        return col.to_matrix
-      elsif (Symbol === j)
-        row = Vector.new(@n)
-        GSLng.backend::gsl_matrix_get_row(row.ptr, @ptr, i)
-        return row.to_matrix
+      if (Integer === i && Integer === j)
+        GSLng.backend::gsl_matrix_get(self.ptr, i, j)
       else
-        GSLng.backend::gsl_matrix_get(@ptr, i, j)
+        if (Symbol === i && Symbol === j) then return self
+        elsif (Symbol === i)
+          col = Vector.new(@m)
+          GSLng.backend::gsl_matrix_get_col(col.ptr, self.ptr, j)
+          return col.to_matrix
+        elsif (Symbol === j)
+          row = Vector.new(@n)
+          GSLng.backend::gsl_matrix_get_row(row.ptr, self.ptr, i)
+          return row.to_matrix
+        end
       end
     end
 
@@ -127,26 +118,37 @@ module GSLng
         if (Numeric === value) then self.fill!(value)
         else
           x,y = self.coerce(value)
-          GSLng.backend::gsl_matrix_memcpy(@ptr, x.ptr)
+          GSLng.backend::gsl_matrix_memcpy(self.ptr, x.ptr)
         end
       elsif (Symbol === i)
         col = Vector.new(@m)
         x,y = col.coerce(value)
-        GSLng.backend::gsl_matrix_set_col(@ptr, j, x.ptr)
+        GSLng.backend::gsl_matrix_set_col(self.ptr, j, x.ptr)
         return col
       elsif (Symbol === j)
         row = Vector.new(@n)
         x,y = row.coerce(value)
-        GSLng.backend::gsl_matrix_set_row(@ptr, i, x.ptr)
+        GSLng.backend::gsl_matrix_set_row(self.ptr, i, x.ptr)
         return row
       else
-        GSLng.backend::gsl_matrix_set(@ptr, i, j, value)
+        GSLng.backend::gsl_matrix_set(self.ptr, i, j, value)
       end
 
       return self
     end
 
-    #--------------------- view -------------------------#
+    # Set all values to _v_
+    def all!(v); GSLng.backend::gsl_matrix_set_all(self.ptr, v); return self end
+    alias_method :set!, :all!
+    alias_method :fill!, :all!
+
+    # Set all values to zero
+    def zero!; GSLng.backend::gsl_matrix_set_zero(self.ptr); return self end
+
+    # Set the identity matrix values
+    def identity; GSLng.backend::gsl_matrix_set_identity(self.ptr); return self end
+
+    # @group Views
 
     # Create a {Matrix::View} from this Matrix.
     # If either _m_ or _n_ are nil, they're computed from _x_, _y_ and the Matrix's {#size}
@@ -181,7 +183,7 @@ module GSLng
     def row_vecview(i, offset = 0, size = nil)
       size = (@n - offset) if size.nil?
       ptr = GSLng.backend.gsl_matrix_row_view(self.ptr, i, offset, size)
-      Vector::View.new(ptr, self, offset, size)
+      Vector::View.new(ptr, self, size)
     end
 
     # Same as {#column_view}, but returns a {Vector::View}
@@ -189,11 +191,11 @@ module GSLng
     def column_vecview(i, offset = 0, size = nil)
       size = (@m - offset) if size.nil?
       ptr = GSLng.backend.gsl_matrix_column_view(self.ptr, i, offset, size)
-      Vector::View.new(ptr, self, offset, size)
+      Vector::View.new(ptr, self, size)
     end
 
     
-    #--------------------- operators -------------------------#
+    # @group Operators
 
     # Add other to self
     # @return [Matrix] self
@@ -286,7 +288,7 @@ module GSLng
       end
     end
 
-    #--------------------- swap rows/columns -------------------------#
+    # @group Row/column swapping
 
     # Transposes in-place. Only for square matrices
     def transpose!; GSLng.backend::gsl_matrix_transpose(self.ptr); return self end
@@ -303,24 +305,24 @@ module GSLng
     # Swap the i-th row with the j-th column. The Matrix must be square.
     def swap_rowcol(i, j); GSLng.backend::gsl_matrix_swap_rowcol(self.ptr, i, j); return self end
 
-    #--------------------- predicate methods -------------------------#
+    # @group Predicate methods
     
     # if all elements are zero
-    def zero?; GSLng.backend::gsl_matrix_isnull(@ptr) == 1 ? true : false end
+    def zero?; GSLng.backend::gsl_matrix_isnull(self.ptr) == 1 ? true : false end
 
     # if all elements are strictly positive (>0)
-    def positive?; GSLng.backend::gsl_matrix_ispos(@ptr) == 1 ? true : false end
+    def positive?; GSLng.backend::gsl_matrix_ispos(self.ptr) == 1 ? true : false end
 
     #if all elements are strictly negative (<0)
-    def negative?; GSLng.backend::gsl_matrix_isneg(@ptr) == 1 ? true : false end
+    def negative?; GSLng.backend::gsl_matrix_isneg(self.ptr) == 1 ? true : false end
     
     # if all elements are non-negative (>=0)
-    def nonnegative?; GSLng.backend::gsl_matrix_isnonneg(@ptr) == 1 ? true : false end
+    def nonnegative?; GSLng.backend::gsl_matrix_isnonneg(self.ptr) == 1 ? true : false end
 
     # If this is a column Matrix
     def column?; self.columns == 1 end
 
-    #--------------------- min/max -------------------------#
+    # @group Minimum/maximum
 
     # Maximum element of the Matrix
     def max; GSLng.backend::gsl_matrix_max(self.ptr) end
@@ -363,7 +365,7 @@ module GSLng
       return [i_max[0].get_ulong(0), j_max[0].get_ulong(0)]
     end
 
-    #--------------------- block handling -------------------------#
+    # @group High-order methods
 
     # Yields the specified block for each element going row-by-row
     # @yield [elem]
@@ -408,22 +410,27 @@ module GSLng
 
     # Efficient {#map!} implementation
     # @yield [elem]
-    def map!(block = Proc.new); GSLng.backend::gsl_matrix_map!(@ptr.to_i, &block); return self end
+    def map!(block = Proc.new); GSLng.backend::gsl_matrix_map!(self.ptr.to_i, &block); return self end
 
     # Alternate version of {#map!}, in this case the block receives the index (row, column) as a parameter.
     # @yield [i,j]
-    def map_index!(block = Proc.new); GSLng.backend::gsl_matrix_map_index!(@ptr.to_i, &block); return self end
+    def map_index!(block = Proc.new); GSLng.backend::gsl_matrix_map_index!(self.ptr.to_i, &block); return self end
 
     # Similar to {#map_index!}, in this case it receives both the element and the index to it
     # @yield [elem,i,j]
-    def map_with_index!(block = Proc.new); GSLng.backend::gsl_matrix_map_with_index!(@ptr.to_i, &block); return self end
+    def map_with_index!(block = Proc.new); GSLng.backend::gsl_matrix_map_with_index!(self.ptr.to_i, &block); return self end
 
     # @see #map!
     # @return [Matrix]
     # @yield [elem]
     def map(block = Proc.new); self.dup.map!(block) end
 
-    #--------------------- conversions -------------------------#
+    # @see #map
+    # @return [Array]
+    # @yield [elem]
+    def map_array(block = Proc.new); GSLng.backend.gsl_matrix_map_array(self.ptr.to_i, &block) end
+
+    # @group Type conversions
 
     # Same as {Array#join}
     # @example
@@ -479,7 +486,7 @@ module GSLng
       end
     end
 
-    #--------------------- equality -------------------------#
+    # @group Equality
 
     # Element-by-element comparison.
     def ==(other)

data/lib/gslng/matrix_view.rb

@@ -13,8 +13,13 @@ module GSLng
       def initialize(owner, x, y, m, n) # @private
         @owner = owner
         @m,@n = m,n
-        @ptr = GSLng.backend::gsl_matrix_submatrix2(owner.ptr, x, y, m, n)
-        GSLng.define_finalizer(self, :gsl_matrix_free, @ptr)
+
+        ptr = GSLng.backend::gsl_matrix_submatrix2(owner.ptr, x, y, m, n)
+        @ptr = FFI::AutoPointer.new(ptr, View.method(:release))
+      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,

data/lib/gslng/plotter.rb

@@ -0,0 +1,83 @@
+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
+      @io.close; @io = nil      
+    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/rng.rb

@@ -10,15 +10,16 @@ module GSLng
       if (@type.nil?) then @type = :mt19937 end # update comment above if changed
       
       type = GSLng.backend.send(:"gsl_rng_#{@type}")
-      @ptr = GSLng.backend.gsl_rng_alloc(type)
-      GSLng.define_finalizer(self, :gsl_rng_free, @ptr)
+      @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
-      ObjectSpace.undefine_finalizer(self)
       type = GSLng.backend.send(:"gsl_rng_#{@type}")
-      @ptr = GSLng.backend.gsl_rng_alloc(type)
-      GSLng.define_finalizer(self, :gsl_rng_free, @ptr)
+      @ptr = FFI::AutoPointer.new(GSLng.backend.gsl_rng_alloc(type), RNG.method(:release))
     end
   end
 end

data/lib/gslng/vector.rb

@@ -14,31 +14,34 @@ module GSLng
   class Vector
     include Enumerable
         
-    attr_reader :size
+    attr_reader :size, :stride
     attr_reader :ptr  # @private
 
-    #--------------------- constructors -------------------------#
+    # @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)
+      ptr = (zero ? GSLng.backend::gsl_vector_calloc(n) : GSLng.backend::gsl_vector_alloc(n))
+      @ptr = FFI::AutoPointer.new(ptr, Vector.method(:release))
       @size = n
-      @ptr = (zero ? GSLng.backend::gsl_vector_calloc(n) : GSLng.backend::gsl_vector_alloc(n))
-      GSLng.define_finalizer(self, :gsl_vector_free, @ptr)
+      @stride = 1
       if (block_given?) then self.map_index!(Proc.new) end
     end
 
     def initialize_copy(other) # @private
-      ObjectSpace.undefine_finalizer(self) # TODO: ruby bug?
-      
+      ptr = GSLng.backend::gsl_vector_alloc(other.size)
+      @ptr = FFI::AutoPointer.new(ptr, Vector.method(:release))
       @size = other.size
-      @ptr = GSLng.backend::gsl_vector_alloc(other.size)
-      GSLng.define_finalizer(self, :gsl_vector_free, @ptr)
-      
+      @stride = 1
       GSLng.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
 
@@ -67,20 +70,7 @@ module GSLng
     end
     class << self; alias_method :rand, :random end
 
-    #--------------------- setting values -------------------------#
-    
-    # Set all values to v
-    def all!(v); GSLng.backend::gsl_vector_set_all(self.ptr, v); return self end
-    alias_method :set!, :all!
-    alias_method :fill!, :all!
-    
-    # Set all values to zero
-    def zero!; GSLng.backend::gsl_vector_set_zero(self.ptr); return self end
-    
-    # Set all values to zero, except the i-th element, which is set to 1
-    def basis!(i); GSLng.backend::gsl_vector_set_basis(self.ptr, i); return self end
-
-    #--------------------- operators -------------------------#
+    # @group Operators
     
     # Add (element-by-element) other to self
     # @return [Vector] self
@@ -163,7 +153,7 @@ module GSLng
     # Invert sign on all elements
     def -@; self.map!(&:-@) end
 
-    #--------------------- other math -------------------------#
+    # @group Other mathematical operations
 
     # Dot product between self and other (uses BLAS's ddot)
     # @return [Float]
@@ -186,7 +176,7 @@ module GSLng
     # Optimized version of: self += other * alpha (where alpha is a Numeric). Uses BLAS's daxpy.
     def mul_add(other, alpha); GSLng.backend::gsl_blas_daxpy(alpha, other.ptr, self.ptr); return self end
 
-    #--------------------- misc -------------------------#
+    # @group Miscelaneous methods
     
     # Reverse the order of elements
     def reverse!; GSLng.backend::gsl_vector_reverse(self.ptr); return self end
@@ -223,14 +213,14 @@ module GSLng
       return delta
     end
 
-    #--------------------- set/get -------------------------#
+    # @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    
+    # @todo support ranges
     def [](index)
-      GSLng.backend::gsl_vector_get(self.ptr, (index < 0 ? @size + index : index))
+      GSLng.backend.gsl_vector_get_operator(self.ptr.to_i, index)
     end
 
     # Set the i-th element.
@@ -241,6 +231,8 @@ module GSLng
       GSLng.backend::gsl_vector_set(self.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)
@@ -254,14 +246,25 @@ module GSLng
 
       if (stride == 1) then ptr = GSLng.backend::gsl_vector_subvector2(self.ptr, offset, size)
       else ptr = GSLng.backend::gsl_vector_subvector_with_stride2(self.ptr, offset, stride, size) end
-      View.new(ptr, self, offset, size)
+      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
 
-    #------------ utility methods for 2D,3D and 4D vectors -----------#
+    # Set all values to v
+    def all!(v); GSLng.backend::gsl_vector_set_all(self.ptr, v); return self end
+    alias_method :set!, :all!
+    alias_method :fill!, :all!
+
+    # Set all values to zero
+    def zero!; GSLng.backend::gsl_vector_set_zero(self.ptr); return self end
+
+    # Set all values to zero, except the i-th element, which is set to 1
+    def basis!(i); GSLng.backend::gsl_vector_set_basis(self.ptr, i); return self end
+
+    # @group 2D/3D/4D utility vectors
 
     # Same as Vector#[0]
     def x; GSLng.backend::gsl_vector_get(self.ptr, 0) end
@@ -281,7 +284,7 @@ module GSLng
     # Same as Vector#[3]=
     def w=(v); GSLng.backend::gsl_vector_set(self.ptr, 3, v.to_f) end 
     
-    #--------------------- predicate methods -------------------------#
+    # @group Predicate methods
 
     # if all elements are zero
     def zero?; GSLng.backend::gsl_vector_isnull(self.ptr) == 1 ? true : false end
@@ -307,7 +310,7 @@ module GSLng
     # If each element of self is less-or-equal than other's elements
     def >=(other); (self - other).nonnegative? end
 
-    #--------------------- min/max -------------------------#
+    # @group Minimum/Maximum
 
     # Return maximum element of vector
     def max; GSLng.backend::gsl_vector_max(self.ptr) end
@@ -337,10 +340,81 @@ module GSLng
 
     # Same as {#max}, but returns the index to the element
     def max_index; GSLng.backend::gsl_vector_max_index(self.ptr) end
+    
+    # @group Statistics
+    
+    # Compute the mean of the vector
+    def mean; GSLng.backend.gsl_stats_mean(self.as_array, self.stride, self.size) 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 GSLng.backend.gsl_stats_variance(self.as_array, self.stride, self.size)
+      else
+        if (fixed_mean) then GSLng.backend.gsl_stats_variance_with_fixed_mean(self.as_array, self.stride, self.size, mean)
+        else GSLng.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 GSLng.backend.gsl_stats_sd(self.as_array, self.stride, self.size)
+      else
+        if (fixed_mean) then GSLng.backend.gsl_stats_sd_with_fixed_mean(self.as_array, self.stride, self.size, mean)
+        else GSLng.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 GSLng.backend.gsl_stats_tss(self.as_array, self.stride, self.size)
+      else GSLng.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 GSLng.backend.gsl_stats_absdev(self.as_array, self.stride, self.size)
+      else GSLng.backend.gsl_stats_absdev_m(self.as_array, self.stride, self.size, mean) end
+    end
+
+    # Compute the skew 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 GSLng.backend.gsl_stats_skew(self.as_array, self.stride, self.size)
+      else GSLng.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 GSLng.backend.gsl_stats_kurtosis(self.as_array, self.stride, self.size)
+      else GSLng.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 GSLng.backend.gsl_stats_lag1_autocorrelation(self.as_array, self.stride, self.size)
+      else GSLng.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 GSLng.backend.gsl_stats_covariance(self.as_array, self.stride, other.as_array, other.stride, self.size)
+      else GSLng.backend.gsl_stats_covariance(self.as_array, self.stride, other.as_array, other.stride, self.size, mean1, mean2) end
+    end
 
-    #--------------------- block handling -------------------------#
+    # Compute the correlation between self and other
+    def correlation(other)
+      GSLng.backend.gsl_stats_correlation(self.as_array, self.stride, other.as_array, other.stride, self.size)
+    end
+
+    # @group High-order methods
 
-    # Same as {#each}, but faster. The catch is that this method returns nothing.
     # @yield [elem]
     def each(block = Proc.new)
       GSLng.backend::gsl_vector_each(self.ptr.to_i, &block)
@@ -352,7 +426,7 @@ module GSLng
       GSLng.backend::gsl_vector_each_with_index(self.ptr.to_i, &block)
     end
 
-    # Efficient {#map!} implementation.
+    # @see #map
     def map!(block = Proc.new); GSLng.backend::gsl_vector_map!(self.ptr.to_i, &block); return self end
 
     # Similar to {#map!}, but passes the index to the element instead.
@@ -360,17 +434,23 @@ module GSLng
     def map_index!(block = Proc.new); GSLng.backend::gsl_vector_map_index!(self.ptr.to_i, &block); return self end
 
     # @return [Vector]
-    # @see map_index!
+    # @see #map_index!
     # @yield [i]
     def map_index(block = Proc.new); self.dup.map_index!(block) end
 
-    alias_method :map_array, :map
+    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
 
-    #--------------------- conversions -------------------------#
+    # @group Type conversions
 
     # @see Array#join
     # @return [String]
@@ -411,6 +491,10 @@ module GSLng
     def to_a
       GSLng.backend.gsl_vector_to_a(self.ptr.to_i)
     end
+    
+    def as_array # @private
+      GSLng.backend.gsl_vector_as_array(self.ptr)
+    end
 
     # Create a row matrix from this vector
     # @return [Matrix]
@@ -430,7 +514,7 @@ module GSLng
     end
     alias_method :to_column, :transpose
 
-    #--------------------- equality -------------------------#
+    # @group Equality test
 
     # Element-by-element comparison. Admits comparing to Array.
     def ==(other)

data/lib/gslng/vector_view.rb

@@ -10,9 +10,13 @@ module GSLng
       # @return [Vector,Matrix] The owner of the data this view accesses
       attr_reader :owner 
 
-      def initialize(ptr, owner, offset, size) # @private
-        @owner,@size,@ptr = owner,size,ptr
-        GSLng.define_finalizer(self, :gsl_vector_free, @ptr)
+      def initialize(ptr, owner, size, stride = 1) # @private
+        @owner,@size,@stride = owner,size,stride
+        @ptr = FFI::AutoPointer.new(ptr, View.method(:release))
+      end
+
+      def View.release(ptr)
+        GSLng.backend.gsl_vector_free(ptr)
       end
       
       # Returns a Vector (*NOT* a View) copied from this view. In other words,

data/ruby-gsl-ng.gemspec

@@ -2,29 +2,29 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruby-gsl-ng}
-  s.version = "0.2.3"
+  s.version = "0.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["v01d"]
-  s.date = %q{2010-06-09}
-  s.description = %q{Ruby Object Oriented Graph LIbrary}
+  s.date = %q{2010-09-21}
+  s.description = %q{Ruby/GSL new-generation wrapper}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]
-  s.extra_rdoc_files = ["README.rdoc", "TODO", "ext/extconf.rb", "ext/gslng_extensions.cpp", "lib/gslng.rb", "lib/gslng/backend.rb", "lib/gslng/backend_components/error_handling.rb", "lib/gslng/backend_components/matrix.rb", "lib/gslng/backend_components/rng.rb", "lib/gslng/backend_components/special.rb", "lib/gslng/backend_components/vector.rb", "lib/gslng/finalizer.rb", "lib/gslng/matrix.rb", "lib/gslng/matrix_view.rb", "lib/gslng/rng/gaussian.rb", "lib/gslng/rng/rng.rb", "lib/gslng/rng/uniform.rb", "lib/gslng/special.rb", "lib/gslng/vector.rb", "lib/gslng/vector_view.rb"]
-  s.files = ["History.txt", "README.rdoc", "Rakefile", "TODO", "ext/extconf.rb", "ext/gslng_extensions.cpp", "lib/gslng.rb", "lib/gslng/backend.rb", "lib/gslng/backend_components/error_handling.rb", "lib/gslng/backend_components/matrix.rb", "lib/gslng/backend_components/rng.rb", "lib/gslng/backend_components/special.rb", "lib/gslng/backend_components/vector.rb", "lib/gslng/finalizer.rb", "lib/gslng/matrix.rb", "lib/gslng/matrix_view.rb", "lib/gslng/rng/gaussian.rb", "lib/gslng/rng/rng.rb", "lib/gslng/rng/uniform.rb", "lib/gslng/special.rb", "lib/gslng/vector.rb", "lib/gslng/vector_view.rb", "ruby-gsl-ng.gemspec", "test/benchmark.rb", "test/benchmark_results", "test/matrix_test.rb", "test/rng_test.rb", "test/test_gsl.rb", "test/test_special.rb", "test/vector_test.rb", "Manifest"]
+  s.extra_rdoc_files = ["README.rdoc", "ext/extconf.rb", "ext/gslng_extensions.cpp", "ext/plotting.cpp", "lib/gslng.rb", "lib/gslng/backend.rb", "lib/gslng/backend_components/error_handling.rb", "lib/gslng/backend_components/matrix.rb", "lib/gslng/backend_components/rng.rb", "lib/gslng/backend_components/special.rb", "lib/gslng/backend_components/stats.rb", "lib/gslng/backend_components/vector.rb", "lib/gslng/matrix.rb", "lib/gslng/matrix_view.rb", "lib/gslng/plotter.rb", "lib/gslng/rng/gaussian.rb", "lib/gslng/rng/rng.rb", "lib/gslng/rng/uniform.rb", "lib/gslng/special.rb", "lib/gslng/vector.rb", "lib/gslng/vector_view.rb"]
+  s.files = ["History.txt", "README.rdoc", "Rakefile", "ext/extconf.rb", "ext/gslng_extensions.cpp", "ext/plotting.cpp", "lib/gslng.rb", "lib/gslng/backend.rb", "lib/gslng/backend_components/error_handling.rb", "lib/gslng/backend_components/matrix.rb", "lib/gslng/backend_components/rng.rb", "lib/gslng/backend_components/special.rb", "lib/gslng/backend_components/stats.rb", "lib/gslng/backend_components/vector.rb", "lib/gslng/matrix.rb", "lib/gslng/matrix_view.rb", "lib/gslng/plotter.rb", "lib/gslng/rng/gaussian.rb", "lib/gslng/rng/rng.rb", "lib/gslng/rng/uniform.rb", "lib/gslng/special.rb", "lib/gslng/vector.rb", "lib/gslng/vector_view.rb", "ruby-gsl-ng.gemspec", "test/benchmark.rb", "test/benchmark_results", "test/matrix_test.rb", "test/rng_test.rb", "test/test_gsl.rb", "test/test_special.rb", "test/vector_test.rb", "Manifest"]
   s.homepage = %q{http://github.com/v01d/ruby-gsl-ng}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Ruby-gsl-ng", "--main", "README.rdoc"]
   s.require_paths = ["lib", "ext"]
   s.rubyforge_project = %q{ruby-gsl-ng}
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Ruby Object Oriented Graph LIbrary}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby/GSL new-generation wrapper}
   s.test_files = ["test/test_special.rb", "test/vector_test.rb", "test/test_gsl.rb", "test/matrix_test.rb", "test/rng_test.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<yard>, [">= 0"])
       s.add_runtime_dependency(%q<ffi>, [">= 0"])
     else

data/test/benchmark.rb

@@ -7,14 +7,27 @@ require 'rbgsl'
 require 'narray'
 include Benchmark
 
+puts '#################################### Vector ####################################'
+
+n=500000
+size = 50000
+puts "Vector#[]"
+bmbm do |x|
+  v = GSLng::Vector.random(size)
+  gv = GSL::Vector.alloc(v.to_a)
+  x.report("rb-gsl :") {n.times {i=rand(size); gv[i]}}
+  x.report("GSLng  :") {n.times {i=rand(size); v[i]}}
+end
+puts
+
 n = 100
 size = 5000
 puts "Vector#each - vector of #{size} elements"
 bmbm do |x|
   v = GSLng::Vector.zero(size)
   gv = GSL::Vector.alloc(v.to_a)
-  x.report("rb-gsl each:") {n.times {s = 0; gv.each do |e| s += e end}}  
-  x.report("each       :") {n.times {s = 0; v.each do |e| s += e end}}
+  x.report("rb-gsl :") {n.times {s = 0; gv.each do |e| s += e end}}
+  x.report("GSLng  :") {n.times {s = 0; v.each do |e| s += e end}}
 end
 puts
 
@@ -77,7 +90,7 @@ end
 puts
 
 n=500
-size = 5000
+size = 50000
 puts "Vector::from_array"
 bmbm do |x|
   a = Array.new(size) { rand }
@@ -86,15 +99,15 @@ bmbm do |x|
 end
 puts
 
+puts '#################################### Matrix ####################################'
+
 n=500000
-size = 5000
-puts "Vector#[]"
+size = 50
+puts "Matrix#[] - 50 x 50"
 bmbm do |x|
-  v = GSLng::Vector.random(size)
-  gv = GSL::Vector.alloc(v.to_a)
-  i = rand(size)
-  x.report("rb-gsl :") {n.times {gv[i]}}
-  x.report("GSLng  :") {n.times {v[i]}}
+  v = GSLng::Matrix.random(size, size)
+  gv = GSL::Matrix.alloc(size, size)
+  x.report("rb-gsl :") {n.times {i,j=rand(size),rand(size); gv[i,j]}}
+  x.report("GSLng  :") {n.times {i,j=rand(size),rand(size); v[i,j]}}
 end
-puts
-
+puts

data/test/matrix_test.rb

@@ -127,4 +127,10 @@ class TestMatrix < Test::Unit::TestCase
     assert_equal(Matrix[[3],[2]], m.column_view(0))
     assert_equal(Matrix[3,2,3], m.row_view(0))
   end
+
+  def test_map
+    m = Matrix[[1,2,3],[2,3,4]]
+    assert_equal([['1.0','2.0','3.0'],['2.0','3.0','4.0']], m.map_array {|e| e.to_s})
+    assert_equal(Matrix[[2,3,4],[3,4,5]], m.map {|e| e+1})
+  end
 end

data/test/vector_test.rb

@@ -35,7 +35,9 @@ class VectorTest < Test::Unit::TestCase
 	end
 
   def test_each
-    assert_equal([1,2,4], Vector[1.1,2.1,3.8].map_array(&:round))
+    a = Vector[1.1,2.1,3.8].map_array(&:round)
+    assert_kind_of(Array, a)
+    assert_equal([1,2,4], a)
     assert_equal(Vector[1,2,4],Vector[1.1,2.1,3.8].map!(&:round))
   end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 3
-  version: 0.2.3
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
 - v01d
@@ -14,13 +14,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-09 00:00:00 -03:00
+date: 2010-09-21 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: yard
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -33,6 +34,7 @@ dependencies:
   name: ffi
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -41,7 +43,7 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id002
-description: Ruby Object Oriented Graph LIbrary
+description: Ruby/GSL new-generation wrapper
 email: ""
 executables: []
 
@@ -49,19 +51,20 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: 
 - README.rdoc
-- TODO
 - ext/extconf.rb
 - ext/gslng_extensions.cpp
+- ext/plotting.cpp
 - lib/gslng.rb
 - lib/gslng/backend.rb
 - lib/gslng/backend_components/error_handling.rb
 - lib/gslng/backend_components/matrix.rb
 - lib/gslng/backend_components/rng.rb
 - lib/gslng/backend_components/special.rb
+- lib/gslng/backend_components/stats.rb
 - lib/gslng/backend_components/vector.rb
-- lib/gslng/finalizer.rb
 - lib/gslng/matrix.rb
 - lib/gslng/matrix_view.rb
+- lib/gslng/plotter.rb
 - lib/gslng/rng/gaussian.rb
 - lib/gslng/rng/rng.rb
 - lib/gslng/rng/uniform.rb
@@ -72,19 +75,20 @@ files:
 - History.txt
 - README.rdoc
 - Rakefile
-- TODO
 - ext/extconf.rb
 - ext/gslng_extensions.cpp
+- ext/plotting.cpp
 - lib/gslng.rb
 - lib/gslng/backend.rb
 - lib/gslng/backend_components/error_handling.rb
 - lib/gslng/backend_components/matrix.rb
 - lib/gslng/backend_components/rng.rb
 - lib/gslng/backend_components/special.rb
+- lib/gslng/backend_components/stats.rb
 - lib/gslng/backend_components/vector.rb
-- lib/gslng/finalizer.rb
 - lib/gslng/matrix.rb
 - lib/gslng/matrix_view.rb
+- lib/gslng/plotter.rb
 - lib/gslng/rng/gaussian.rb
 - lib/gslng/rng/rng.rb
 - lib/gslng/rng/uniform.rb
@@ -116,6 +120,7 @@ require_paths:
 - lib
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -123,6 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -133,10 +139,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ruby-gsl-ng
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Ruby Object Oriented Graph LIbrary
+summary: Ruby/GSL new-generation wrapper
 test_files: 
 - test/test_special.rb
 - test/vector_test.rb

data/TODO

@@ -1,2 +0,0 @@
-Documentation:
-- usar cosas de Yard, tipo returns y eso?

data/lib/gslng/finalizer.rb

@@ -1,9 +0,0 @@
-module GSLng
-  def GSLng.define_finalizer(obj, func, ptr) # @private
-    ObjectSpace.define_finalizer(obj, self.get_finalizer(func, ptr))
-  end
-  
-  def GSLng.get_finalizer(func, ptr) # @private
-    lambda {|id| GSLng.backend.send(func, ptr)}
-  end
-end