ruby-gsl-ng 0.2.4.1 → 0.2.6

data/History.txt

@@ -1,3 +1,16 @@
+=== 0.2.6
+* Features:
+  * Improved Vector#wrap
+  * Performance improvements
+  * Check for pkg-config, to avoid problems
+  * Vector#median (bdigital)
+  * Added Vector.linspace, Vector#hash, Matrix#set, Vector#eql?, Matrix#slide, Vector#quantile
+  * Extend Array to include #to_v and #to_m (bdigital)
+* Fixes:
+  * Better plotter process closing
+  * Clear C/CXXFLAGS
+  * Pointer conversion bug causing random segfaults
+  * Problem while trying to free GSL memory
 === 0.2.4.1
 * Fixes:
   * Gnuplot not being correctly executed

data/Manifest

@@ -1,9 +1,11 @@
 History.txt
+Manifest
 README.rdoc
 Rakefile
 ext/extconf.rb
 ext/gslng_extensions.cpp
 ext/plotting.cpp
+lib/core_extensions/array.rb
 lib/gslng.rb
 lib/gslng/backend.rb
 lib/gslng/backend_components/error_handling.rb
@@ -29,4 +31,3 @@ test/rng_test.rb
 test/test_gsl.rb
 test/test_special.rb
 test/vector_test.rb
-Manifest

data/Rakefile

@@ -8,7 +8,7 @@ Echoe.new('ruby-gsl-ng') do |p|
   p.author = 'v01d'
   p.summary = "Ruby/GSL new-generation wrapper"
   p.url = "http://github.com/v01d/ruby-gsl-ng"
-  p.version = "0.2.4.1"
+  p.version = "0.2.6"
   p.dependencies = ['yard', 'ffi']
 #  p.eval = proc { s.has_rdoc = 'yard' }
 end

data/ext/extconf.rb

@@ -4,6 +4,7 @@ require 'mkmf'
 extra_flags='-O4 -DHAVE_INLINE=1'
 
 ## Check for GSL
+find_executable('pkg-config') or raise 'pkg-config should be installed'
 gsl_vars = pkg_config('gsl') or raise 'GSL not found!'
 
 # Configuration
@@ -11,4 +12,9 @@ if (RUBY_VERSION =~ /^1\.8/) then $libs << ' -lstdc++' end # Seems necessary in
 
 ## Create Makefile
 with_cppflags("#{extra_flags}") { true }
+with_cflags('') { true }
+CONFIG['CXXFLAGS']=''
+
 create_makefile('gslng_extensions')
+
+

data/ext/gslng_extensions.cpp

@@ -7,11 +7,13 @@
 #include <ruby.h>
 #include <gsl/gsl_vector.h>
 #include <gsl/gsl_matrix.h>
+#include <iostream>
+using namespace std;
 
 /************************* Vector functions *****************************/
 
 static VALUE gsl_vector_map(VALUE self, VALUE ptr) {
-	gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
 	for (size_t i = 0; i < v->size; i++)
 		gsl_vector_set(v, i, NUM2DBL(rb_yield(rb_float_new(gsl_vector_get(v, i)))));
 	
@@ -19,7 +21,7 @@ static VALUE gsl_vector_map(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_vector_map_index(VALUE self, VALUE ptr) {
-	gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
 	for (size_t i = 0; i < v->size; i++) {
 		VALUE vi = ULONG2NUM(i);
 		gsl_vector_set(v, i, NUM2DBL(rb_yield(vi)));
@@ -29,7 +31,7 @@ static VALUE gsl_vector_map_index(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_vector_each_with_index(VALUE self, VALUE ptr) {
-	gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
 	for (size_t i = 0; i < v->size; i++) {
 		VALUE vi = ULONG2NUM(i);
 		rb_yield_values(2, rb_float_new(gsl_vector_get(v, i)), vi);
@@ -39,7 +41,7 @@ static VALUE gsl_vector_each_with_index(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_vector_each(VALUE self, VALUE ptr) {
-	gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
 	for (size_t i = 0; i < v->size; i++)
 		rb_yield(rb_float_new(gsl_vector_get(v, i)));
 	
@@ -47,7 +49,7 @@ static VALUE gsl_vector_each(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_vector_to_a(VALUE self, VALUE ptr) {
-	gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
 	
 	VALUE array = rb_ary_new2(v->size);
 	for (size_t i = 0; i < v->size; i++)
@@ -57,7 +59,7 @@ static VALUE gsl_vector_to_a(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_vector_from_array(VALUE self, VALUE ptr, VALUE array) {
-	gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
 	if (v->size != RARRAY_LEN(array)) rb_raise(rb_eRuntimeError, "Sizes differ!");
 	
 	for (size_t i = 0; i < v->size; i++)
@@ -67,12 +69,30 @@ static VALUE gsl_vector_from_array(VALUE self, VALUE ptr, VALUE array) {
 }
 
 static VALUE gsl_vector_get_operator(VALUE self, VALUE ptr, VALUE element) {
-  gsl_vector* v = (gsl_vector*)FIX2ULONG(ptr);
+  gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
   long i = FIX2LONG(element);
   if (i < 0) { i = v->size + i; }
   return rb_float_new(gsl_vector_get(v, (size_t)i));
 }
 
+static VALUE gsl_vector_set_operator(VALUE self, VALUE ptr, VALUE element, VALUE value) {
+  gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+  long i = FIX2LONG(element);
+  if (i < 0) { i = v->size + i; }
+  gsl_vector_set(v, (size_t)i, NUM2DBL(value));
+  return Qnil;
+}
+
+static VALUE gsl_vector_eql(VALUE self, VALUE ptr, VALUE other_ptr) {
+  gsl_vector* v1 = (gsl_vector*)NUM2ULONG(ptr);
+  gsl_vector* v2 = (gsl_vector*)NUM2ULONG(other_ptr);
+  if (v1->size != v2->size) return Qfalse;
+  for (size_t i = 0; i < v1->size; i++) {
+    if (gsl_vector_get(v1, i) != gsl_vector_get(v2, i)) return Qfalse;
+  }
+  return Qtrue;
+}
+
 // 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);
@@ -96,7 +116,7 @@ extern "C" double* gsl_vector_as_array(gsl_vector* v) {
 /************************* Matrix functions *****************************/
 
 static VALUE gsl_matrix_map(VALUE self, VALUE ptr) {
-  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
   size_t size1 = m->size1;
   size_t size2 = m->size2;
 
@@ -108,7 +128,7 @@ static VALUE gsl_matrix_map(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_matrix_map_array(VALUE self, VALUE ptr) {
-  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
 
 	VALUE array = rb_ary_new2(m->size1);
 	for (size_t i = 0; i < m->size1; i++) {
@@ -123,7 +143,7 @@ static VALUE gsl_matrix_map_array(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_matrix_map_index(VALUE self, VALUE ptr) {
-  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
   size_t size1 = m->size1;
   size_t size2 = m->size2;
 
@@ -135,7 +155,7 @@ static VALUE gsl_matrix_map_index(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_matrix_map_with_index(VALUE self, VALUE ptr) {
-  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
   size_t size1 = m->size1;
   size_t size2 = m->size2;
 
@@ -147,7 +167,7 @@ static VALUE gsl_matrix_map_with_index(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_matrix_each(VALUE self, VALUE ptr) {
-  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
   size_t size1 = m->size1;
   size_t size2 = m->size2;
 
@@ -159,7 +179,7 @@ static VALUE gsl_matrix_each(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_matrix_each_with_index(VALUE self, VALUE ptr) {
-  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
   size_t size1 = m->size1;
   size_t size2 = m->size2;
 
@@ -173,7 +193,7 @@ static VALUE gsl_matrix_each_with_index(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_matrix_to_a(VALUE self, VALUE ptr) {
-	gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+	gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
 
 	VALUE array = rb_ary_new2(m->size1);
 	for (size_t i = 0; i < m->size1; i++) {
@@ -188,7 +208,7 @@ static VALUE gsl_matrix_to_a(VALUE self, VALUE ptr) {
 }
 
 static VALUE gsl_matrix_from_array(VALUE self, VALUE ptr, VALUE array) {
-  gsl_matrix* m = (gsl_matrix*)FIX2ULONG(ptr);
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
   if (m->size1 != RARRAY_LEN(array)) rb_raise(rb_eRuntimeError, "Sizes differ!");
 
 	for (size_t i = 0; i < m->size1; i++) {
@@ -202,6 +222,21 @@ static VALUE gsl_matrix_from_array(VALUE self, VALUE ptr, VALUE array) {
 	return self;
 }
 
+static VALUE gsl_matrix_get_operator(VALUE self, VALUE ptr, VALUE element_i, VALUE element_j) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t i = NUM2ULONG(element_i);
+  size_t j = NUM2ULONG(element_j);
+  return rb_float_new(gsl_matrix_get(m, i, j));
+}
+
+static VALUE gsl_matrix_set_operator(VALUE self, VALUE ptr, VALUE element_i, VALUE element_j, VALUE value) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t i = NUM2ULONG(element_i);
+  size_t j = NUM2ULONG(element_j);
+  gsl_matrix_set(m, i, j, NUM2DBL(value));
+  return Qnil;
+}
+
 // Hide the view in a new matrix (gsl_matrix_submatrix)
 extern "C" gsl_matrix* gsl_matrix_submatrix2(gsl_matrix* m_ptr, size_t x, size_t y, size_t n, size_t m) {
   gsl_matrix_view view = gsl_matrix_submatrix(m_ptr, x, y, n, m);
@@ -224,6 +259,22 @@ extern "C" gsl_vector* gsl_matrix_column_view(gsl_matrix* m_ptr, size_t column,
   return vector_view;
 }
 
+extern "C" void gsl_matrix_slide(gsl_matrix* m, ssize_t slide_i, ssize_t slide_j)
+{
+  gsl_matrix* m2 = gsl_matrix_calloc(m->size1, m->size2);
+
+  for (ssize_t i = 0; (size_t)i < m->size1; i++) {
+    for (ssize_t j = 0; (size_t)j < m->size2; j++) {
+      if (i - slide_i >= 0 && (size_t)(i - slide_i) < m->size1 && j - slide_j >= 0 && (size_t)(j - slide_j) < m->size2) {
+        double v = gsl_matrix_get(m, (size_t)(i - slide_i), (size_t)(j - slide_j));
+        gsl_matrix_set(m2, (size_t)i, (size_t)j, v);
+      }            
+    }
+  }
+
+  gsl_matrix_memcpy(m, m2);
+  gsl_matrix_free(m2);
+}
 
 /************************* Module initialization *****************************/
 
@@ -233,12 +284,14 @@ extern "C" void Init_gslng_extensions(void) {
 
 	// 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_set_operator", (VALUE(*)(ANYARGS))gsl_vector_set_operator, 3);
 	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);
 	rb_define_module_function(Backend_module, "gsl_vector_each", (VALUE(*)(ANYARGS))gsl_vector_each, 1);
 	rb_define_module_function(Backend_module, "gsl_vector_to_a", (VALUE(*)(ANYARGS))gsl_vector_to_a, 1);
 	rb_define_module_function(Backend_module, "gsl_vector_from_array", (VALUE(*)(ANYARGS))gsl_vector_from_array, 2);
+  rb_define_module_function(Backend_module, "gsl_vector_eql?", (VALUE(*)(ANYARGS))gsl_vector_eql, 2);
 
   // matrix
 	rb_define_module_function(Backend_module, "gsl_matrix_map!", (VALUE(*)(ANYARGS))gsl_matrix_map, 1);
@@ -249,4 +302,6 @@ extern "C" void Init_gslng_extensions(void) {
 	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);
+  rb_define_module_function(Backend_module, "gsl_matrix_get_operator", (VALUE(*)(ANYARGS))gsl_matrix_get_operator, 3);
+  rb_define_module_function(Backend_module, "gsl_matrix_set_operator", (VALUE(*)(ANYARGS))gsl_matrix_set_operator, 4);
 }

data/ext/plotting.cpp

@@ -1,9 +1,22 @@
 #include <gsl/gsl_matrix.h>
 #include <unistd.h>
+#include <iostream>
+using namespace std;
 
 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 || (unsigned long)ret < bytes) return errno;
+  if (ret == -1 || (unsigned long)ret < bytes) {
+    if (errno == EINTR) {
+      cout << "retrying write" << endl;
+      long written;
+      if (ret == -1) written = 0;
+      else written = ret;
+      
+      ret = write(fd, m->data + written, bytes - written);
+      if (ret == -1 || (unsigned long)ret < (bytes - written)) return errno;
+      else return 0;
+    }
+  }
   else return 0;
 }

data/lib/core_extensions/array.rb

@@ -0,0 +1,14 @@
+# 
+# Convenience extensions for core array
+#
+class Array
+
+  def to_v
+    GSLng::Vector.from_array self
+  end
+
+  def to_m
+    GSLng::Matrix.from_array self
+  end
+
+end

data/lib/gslng.rb

@@ -7,3 +7,5 @@ require 'gslng/matrix'
 require 'gslng/matrix_view'
 require 'gslng/rng/rng'
 require 'gslng/special'
+
+require 'core_extensions/array'

data/lib/gslng/backend_components/matrix.rb

@@ -58,6 +58,9 @@ module GSLng
     attach_function :gsl_matrix_row_view, [ :pointer, :size_t, :size_t, :size_t ], :pointer
     attach_function :gsl_matrix_column_view, [ :pointer, :size_t, :size_t, :size_t ], :pointer
 
+    # slide
+    attach_function :gsl_matrix_slide, [ :pointer, :ssize_t, :ssize_t ], :void
+
     # BLAS interface
     enum :cblas_transpose_t, [ :no_transpose, 111, :transpose, :conjugate_transpose ]
     attach_function :gsl_blas_dgemv, [ :cblas_transpose_t, :double, :pointer, :pointer, :double, :pointer ], :int

data/lib/gslng/backend_components/stats.rb

@@ -2,6 +2,7 @@ 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_median_from_sorted_data, [ :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

data/lib/gslng/matrix.rb

@@ -10,6 +10,7 @@ module GSLng
   class Matrix
     attr_reader :m, :n    
     attr_reader :ptr # @private
+    attr_reader :ptr_value # @private
 
     alias_method :height, :m
     alias_method :width, :n
@@ -25,18 +26,22 @@ module GSLng
     # 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)
+      @backend = GSLng.backend
+      ptr = zero ? @backend.gsl_matrix_calloc(m, n) : @backend.gsl_matrix_alloc(m, n)
       @ptr = FFI::AutoPointer.new(ptr, Matrix.method(:release))
+      @ptr_value = @ptr.to_i
       @m,@n = m,n
       if (block_given?) then self.map_index!(Proc.new) end
     end
 
     def initialize_copy(other) # @private
-      ptr = GSLng.backend::gsl_matrix_alloc(other.m, other.n)
+      @backend = GSLng.backend
+      ptr = @backend.gsl_matrix_alloc(other.m, other.n)
       @ptr = FFI::AutoPointer.new(ptr, Matrix.method(:release))
+      @ptr_value = @ptr.to_i
 
       @m,@n = other.size
-      GSLng.backend::gsl_matrix_memcpy(@ptr, other.ptr)
+      @backend.gsl_matrix_memcpy(@ptr, other.ptr)
     end
 
     def Matrix.release(ptr) # @private
@@ -53,11 +58,11 @@ module GSLng
 
       if (Numeric === array[0])
         m = Matrix.new(1, array.size)
-        GSLng.backend.gsl_matrix_from_array(m.ptr.to_i, [ array ])
+        GSLng.backend.gsl_matrix_from_array(m.ptr_value, [ array ])
         return m
       elsif (Array === array[0])
         m = Matrix.new(array.size, array[0].size)
-        GSLng.backend.gsl_matrix_from_array(m.ptr.to_i, array)
+        GSLng.backend.gsl_matrix_from_array(m.ptr_value, array)
         return m
       else
         Matrix.new(array.size, array[0].to_a.size) {|i,j| array[i].to_a[j]}
@@ -94,16 +99,16 @@ module GSLng
     # @return [Numeric,Matrix] the element/sub-matrix
     def [](i, j = :*)
       if (Integer === i && Integer === j)
-        GSLng.backend::gsl_matrix_get(self.ptr, i, j)
+        @backend.gsl_matrix_get_operator(@ptr_value, i, j)
       else
         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)
+          @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, self.ptr, i)
+          @backend.gsl_matrix_get_row(row.ptr, @ptr, i)
           return row.to_matrix
         end
       end
@@ -118,35 +123,38 @@ module GSLng
         if (Numeric === value) then self.fill!(value)
         else
           x,y = self.coerce(value)
-          GSLng.backend::gsl_matrix_memcpy(self.ptr, x.ptr)
+          @backend.gsl_matrix_memcpy(@ptr, x.ptr)
         end
       elsif (Symbol === i)
         col = Vector.new(@m)
         x,y = col.coerce(value)
-        GSLng.backend::gsl_matrix_set_col(self.ptr, j, x.ptr)
+        @backend.gsl_matrix_set_col(@ptr, j, x.ptr)
         return col
       elsif (Symbol === j)
         row = Vector.new(@n)
         x,y = row.coerce(value)
-        GSLng.backend::gsl_matrix_set_row(self.ptr, i, x.ptr)
+        @backend.gsl_matrix_set_row(@ptr, i, x.ptr)
         return row
       else
-        GSLng.backend::gsl_matrix_set(self.ptr, i, j, value)
+        @backend.gsl_matrix_set_operator(@ptr_value, i, j, value)
       end
 
       return self
     end
 
     # Set all values to _v_
-    def all!(v); GSLng.backend::gsl_matrix_set_all(self.ptr, v); return self end
+    def all!(v); @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(self.ptr); return self end
+    def zero!; @backend.gsl_matrix_set_zero(@ptr); return self end
 
     # Set the identity matrix values
-    def identity; GSLng.backend::gsl_matrix_set_identity(self.ptr); return self end
+    def identity; @backend.gsl_matrix_set_identity(@ptr); return self end
+
+    # Copy matrix values from +other+ to +self+
+    def set(other); @backend.gsl_matrix_memcpy(@ptr, other.ptr); return self end
 
     # @group Views
 
@@ -182,7 +190,7 @@ module GSLng
     # @return [Vector::View]
     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)
+      ptr = @backend.gsl_matrix_row_view(@ptr, i, offset, size)
       Vector::View.new(ptr, self, size)
     end
 
@@ -190,8 +198,8 @@ module GSLng
     # @return [Vector::View]
     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, size)
+      ptr = @backend.gsl_matrix_column_view(@ptr, i, offset, size)
+      Vector::View.new(ptr, self, size, self.columns)
     end
 
     
@@ -201,8 +209,8 @@ module GSLng
     # @return [Matrix] self
     def add!(other)
       case other
-      when Numeric; GSLng.backend::gsl_matrix_add_constant(self.ptr, other.to_f)
-      when Matrix; GSLng.backend::gsl_matrix_add(self.ptr, other.ptr)
+      when Numeric; @backend.gsl_matrix_add_constant(@ptr, other.to_f)
+      when Matrix; @backend.gsl_matrix_add(@ptr, other.ptr)
       else
         x,y = other.coerce(self)
         x.add!(y)
@@ -214,8 +222,8 @@ module GSLng
     # @return [Matrix] self    
     def substract!(other)
       case other
-      when Numeric; GSLng.backend::gsl_matrix_add_constant(self.ptr, -other.to_f)
-      when Matrix; GSLng.backend::gsl_matrix_sub(self.ptr, other.ptr)
+      when Numeric; @backend.gsl_matrix_add_constant(@ptr, -other.to_f)
+      when Matrix; @backend.gsl_matrix_sub(@ptr, other.ptr)
       else
         x,y = other.coerce(self)
         x.substract!(y)
@@ -228,8 +236,8 @@ module GSLng
     # @return [Matrix] self    
     def multiply!(other)
       case other
-      when Numeric; GSLng.backend::gsl_matrix_scale(self.ptr, other.to_f)
-      when Matrix; GSLng.backend::gsl_matrix_mul_elements(self.ptr, other.ptr)
+      when Numeric; @backend.gsl_matrix_scale(@ptr, other.to_f)
+      when Matrix; @backend.gsl_matrix_mul_elements(@ptr, other.ptr)
       else
         x,y = other.coerce(self)
         x.multiply!(y)
@@ -242,8 +250,8 @@ module GSLng
     # @return [Matrix] self    
     def divide!(other)
       case other
-      when Numeric; GSLng.backend::gsl_matrix_scale(self.ptr, 1.0 / other)
-      when Matrix;  GSLng.backend::gsl_matrix_div_elements(self.ptr, other.ptr)
+      when Numeric; @backend.gsl_matrix_scale(@ptr, 1.0 / other)
+      when Matrix;  @backend.gsl_matrix_div_elements(@ptr, other.ptr)
       else
         x,y = other.coerce(self)
         x.divide!(y)
@@ -276,11 +284,11 @@ module GSLng
         self.multiply(other)
       when Vector
         matrix = Matrix.new(self.m, other.size)
-        GSLng.backend::gsl_blas_dgemm(:no_transpose, :no_transpose, 1, self.ptr, other.to_matrix.ptr, 0, matrix.ptr)
+        @backend.gsl_blas_dgemm(:no_transpose, :no_transpose, 1, @ptr, other.to_matrix.ptr, 0, matrix.ptr)
         return matrix
       when Matrix
         matrix = Matrix.new(self.m, other.n)
-        GSLng.backend::gsl_blas_dgemm(:no_transpose, :no_transpose, 1, self.ptr, other.ptr, 0, matrix.ptr)
+        @backend.gsl_blas_dgemm(:no_transpose, :no_transpose, 1, @ptr, other.ptr, 0, matrix.ptr)
         return matrix
       else
         x,y = other.coerce(self)
@@ -291,33 +299,40 @@ module GSLng
     # @group Row/column swapping
 
     # Transposes in-place. Only for square matrices
-    def transpose!; GSLng.backend::gsl_matrix_transpose(self.ptr); return self end
+    def transpose!; @backend.gsl_matrix_transpose(@ptr); return self end
 
     # Returns the transpose of self, in a new matrix
-    def transpose; matrix = Matrix.new(@n, @m); GSLng.backend::gsl_matrix_transpose_memcpy(matrix.ptr, self.ptr); return matrix end
+    def transpose; matrix = Matrix.new(@n, @m); @backend.gsl_matrix_transpose_memcpy(matrix.ptr, @ptr); return matrix end
 
     # Swap the i-th and j-th columnos
-    def swap_columns(i, j); GSLng.backend::gsl_matrix_swap_columns(self.ptr, i, j); return self end
+    def swap_columns(i, j); @backend.gsl_matrix_swap_columns(@ptr, i, j); return self end
     
     # Swap the i-th and j-th rows
-    def swap_rows(i, j); GSLng.backend::gsl_matrix_swap_rows(self.ptr, i, j); return self end
+    def swap_rows(i, j); @backend.gsl_matrix_swap_rows(@ptr, i, j); return self end
     
     # 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
+    def swap_rowcol(i, j); @backend.gsl_matrix_swap_rowcol(@ptr, i, j); return self end
+
+    # Discards rows and columns as necessary (fill them with zero), to "slide" the values of the matrix
+    # @param [Integer] i If > 0, slides all values to the bottom (adds +i+ rows of zeros at the top). If < 0,
+    #  slides all values to the top and adds zeros in the bottom.
+    # @param [Integer] j Analogous to parameter +i+, in this case a value < 0 adds zeros to the right (slides to the left),
+    #  and a value > 0 adds zeros to the left (slides to the right).
+    def slide(i, j); @backend.gsl_matrix_slide(@ptr, i, j); return self end
 
     # @group Predicate methods
     
     # if all elements are zero
-    def zero?; GSLng.backend::gsl_matrix_isnull(self.ptr) == 1 ? true : false end
+    def zero?; @backend.gsl_matrix_isnull(@ptr) == 1 ? true : false end
 
     # if all elements are strictly positive (>0)
-    def positive?; GSLng.backend::gsl_matrix_ispos(self.ptr) == 1 ? true : false end
+    def positive?; @backend.gsl_matrix_ispos(@ptr) == 1 ? true : false end
 
     #if all elements are strictly negative (<0)
-    def negative?; GSLng.backend::gsl_matrix_isneg(self.ptr) == 1 ? true : false end
+    def negative?; @backend.gsl_matrix_isneg(@ptr) == 1 ? true : false end
     
     # if all elements are non-negative (>=0)
-    def nonnegative?; GSLng.backend::gsl_matrix_isnonneg(self.ptr) == 1 ? true : false end
+    def nonnegative?; @backend.gsl_matrix_isnonneg(@ptr) == 1 ? true : false end
 
     # If this is a column Matrix
     def column?; self.columns == 1 end
@@ -325,16 +340,16 @@ module GSLng
     # @group Minimum/maximum
 
     # Maximum element of the Matrix
-    def max; GSLng.backend::gsl_matrix_max(self.ptr) end
+    def max; @backend.gsl_matrix_max(@ptr) end
 
     # Minimum element of the Matrix
-    def min; GSLng.backend::gsl_matrix_min(self.ptr) end
+    def min; @backend.gsl_matrix_min(@ptr) end
 
     # Same as {Array#minmax}
     def minmax
       min = FFI::Buffer.new(:double)
       max = FFI::Buffer.new(:double)
-      GSLng.backend::gsl_matrix_minmax(self.ptr, min, max)
+      @backend.gsl_matrix_minmax(@ptr, min, max)
       return [min[0].get_float64(0),max[0].get_float64(0)]
     end
 
@@ -344,7 +359,7 @@ module GSLng
       j_min = FFI::Buffer.new(:size_t)
       i_max = FFI::Buffer.new(:size_t)
       j_max = FFI::Buffer.new(:size_t)
-      GSLng.backend::gsl_matrix_minmax_index(self.ptr, i_min, j_min, i_max, j_max)
+      @backend.gsl_matrix_minmax_index(@ptr, i_min, j_min, i_max, j_max)
       #return [min[0].get_size_t(0),max[0].get_size_t(0)]
       return [i_min[0].get_ulong(0),j_min[0].get_ulong(0),i_max[0].get_ulong(0),j_max[0].get_ulong(0)]
     end
@@ -353,7 +368,7 @@ module GSLng
     def min_index
       i_min = FFI::Buffer.new(:size_t)
       j_min = FFI::Buffer.new(:size_t)
-      GSLng.backend::gsl_matrix_min_index(self.ptr, i_min, j_min)
+      @backend.gsl_matrix_min_index(@ptr, i_min, j_min)
       return [i_min[0].get_ulong(0), j_min[0].get_ulong(0)]
     end
 
@@ -361,7 +376,7 @@ module GSLng
     def max_index
       i_max = FFI::Buffer.new(:size_t)
       j_max = FFI::Buffer.new(:size_t)
-      GSLng.backend::gsl_matrix_max_index(self.ptr, i_max, j_max)
+      @backend.gsl_matrix_max_index(@ptr, i_max, j_max)
       return [i_max[0].get_ulong(0), j_max[0].get_ulong(0)]
     end
 
@@ -383,13 +398,13 @@ module GSLng
     # @yield [elem]
     # @return [void]
     def each(block = Proc.new) 
-      GSLng.backend::gsl_matrix_each(self.ptr.to_i, &block)
+      @backend.gsl_matrix_each(@ptr_value, &block)
     end
     
     # @see #each
     # @yield [elem,i,j]
     def each_with_index(block = Proc.new) 
-      GSLng.backend::gsl_matrix_each_with_index(self.ptr.to_i, &block)
+      @backend.gsl_matrix_each_with_index(@ptr_value, &block)
     end    
 
     # Yields the block for each row *view* ({Matrix::View}).
@@ -410,15 +425,15 @@ module GSLng
 
     # Efficient {#map!} implementation
     # @yield [elem]
-    def map!(block = Proc.new); GSLng.backend::gsl_matrix_map!(self.ptr.to_i, &block); return self end
+    def map!(block = Proc.new); @backend.gsl_matrix_map!(@ptr_value, &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!(self.ptr.to_i, &block); return self end
+    def map_index!(block = Proc.new); @backend.gsl_matrix_map_index!(@ptr_value, &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!(self.ptr.to_i, &block); return self end
+    def map_with_index!(block = Proc.new); @backend.gsl_matrix_map_with_index!(@ptr_value, &block); return self end
 
     # @see #map!
     # @return [Matrix]
@@ -428,7 +443,7 @@ module GSLng
     # @see #map
     # @return [Array]
     # @yield [elem]
-    def map_array(block = Proc.new); GSLng.backend.gsl_matrix_map_array(self.ptr.to_i, &block) end
+    def map_array(block = Proc.new); @backend.gsl_matrix_map_array(@ptr_value, &block) end
 
     # @group Type conversions
 
@@ -463,7 +478,7 @@ module GSLng
     # @example
     #  Matrix[[1,2],[2,3]] => [[1.0,2.0],[2.0,3.0]]
     def to_a
-      GSLng.backend.gsl_matrix_to_a(self.ptr.to_i)
+      @backend.gsl_matrix_to_a(@ptr_value)
     end
 
     def inspect # @private