ruby-gsl-ngx 0.2.6.1

data/ext/plotting.cpp

@@ -0,0 +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) {
+    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

@@ -0,0 +1,11 @@
+require 'gslng/backend'
+
+require 'gslng/plotter'
+require 'gslng/vector'
+require 'gslng/vector_view'
+require 'gslng/matrix'
+require 'gslng/matrix_view'
+require 'gslng/rng/rng'
+require 'gslng/special'
+
+require 'core_extensions/array'

data/lib/gslng/backend.rb

@@ -0,0 +1,23 @@
+require 'ffi'
+
+module GSLng
+  # Anonymous module: avoids exposing this internal module when doing "include GSLng" at the top-level.
+  # If ruby had "private" modules I wouldn't have to do this.
+  @backend = Module.new do
+    extend FFI::Library
+    ffi_lib(FFI::CURRENT_PROCESS)
+  end
+
+  # Returns the internal backend module
+  def GSLng.backend # @private
+    @backend
+  end
+end
+
+require 'gslng_extensions'
+require 'gslng/backend_components/vector'
+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/error_handling.rb

@@ -0,0 +1,12 @@
+module GSLng
+  backend.instance_eval do
+    # All of this raises an exception when GSL registers an error
+    callback :error_handler_callback, [ :string, :string, :int, :int ], :void
+    attach_function :gsl_set_error_handler, [ :error_handler_callback ], :error_handler_callback
+
+    ErrorHandlerCallback = Proc.new {|reason, file, line, errno|
+      raise RuntimeError, "#{reason} (errno: #{errno})", caller[2..-1]
+    }
+    gsl_set_error_handler(ErrorHandlerCallback)
+  end
+end

data/lib/gslng/backend_components/matrix.rb

@@ -0,0 +1,83 @@
+module GSLng
+
+  class GSLmatrix < FFI::Struct
+    layout :size1, :size_t,
+      :size2, :size_t,
+      :tda, :size_t,
+      :data, :pointer,
+      :block, :pointer,
+      :owner, :int
+  end
+
+  backend.instance_eval do
+
+    # memory handling
+    attach_function :gsl_matrix_alloc, [ :size_t, :size_t ], :pointer
+    attach_function :gsl_matrix_calloc, [ :size_t, :size_t ], :pointer
+    attach_function :gsl_matrix_free, [ :pointer ], :void
+
+    # initializing
+    attach_function :gsl_matrix_set_all, [ :pointer, :double ], :void
+    attach_function :gsl_matrix_set_zero, [ :pointer ], :void
+    attach_function :gsl_matrix_set_identity, [ :pointer ], :void
+
+    # copying
+    attach_function :gsl_matrix_memcpy, [ :pointer, :pointer ], :int
+
+    # operations
+    attach_function :gsl_matrix_add, [ :pointer, :pointer ], :int
+    attach_function :gsl_matrix_sub, [ :pointer, :pointer ], :int
+    attach_function :gsl_matrix_mul_elements, [ :pointer, :pointer ], :int
+    attach_function :gsl_matrix_div_elements, [ :pointer, :pointer ], :int
+    attach_function :gsl_matrix_scale, [ :pointer, :double ], :int
+    attach_function :gsl_matrix_add_constant, [ :pointer, :double ], :int
+
+    # copy rows/columns into
+    attach_function :gsl_matrix_get_row, [ :pointer, :pointer, :size_t ], :int
+    attach_function :gsl_matrix_get_col, [ :pointer, :pointer, :size_t ], :int
+    attach_function :gsl_matrix_set_row, [ :pointer, :size_t, :pointer ], :int
+    attach_function :gsl_matrix_set_col, [ :pointer, :size_t, :pointer ], :int
+
+    # element access
+    attach_function :gsl_matrix_get, [ :pointer, :size_t, :size_t ], :double
+    attach_function :gsl_matrix_set, [ :pointer, :size_t, :size_t, :double ], :void
+    
+    # properties
+    attach_function :gsl_matrix_isnull, [ :pointer ], :int
+    attach_function :gsl_matrix_ispos, [ :pointer ], :int
+    attach_function :gsl_matrix_isneg, [ :pointer ], :int
+    attach_function :gsl_matrix_isnonneg, [ :pointer ], :int
+
+    # max and min
+    attach_function :gsl_matrix_max, [ :pointer ], :double
+    attach_function :gsl_matrix_min, [ :pointer ], :double
+    attach_function :gsl_matrix_minmax, [ :pointer, :buffer_out, :buffer_out ], :void
+    attach_function :gsl_matrix_max_index, [ :pointer, :buffer_out, :buffer_out ], :void
+    attach_function :gsl_matrix_min_index, [ :pointer, :buffer_out, :buffer_out ], :void
+    attach_function :gsl_matrix_minmax_index, [ :pointer, :buffer_out, :buffer_out, :buffer_out, :buffer_out ], :void
+
+    # exchange elements
+    attach_function :gsl_matrix_swap_rows, [ :pointer, :size_t, :size_t ], :int
+    attach_function :gsl_matrix_swap_columns, [ :pointer, :size_t, :size_t ], :int
+    attach_function :gsl_matrix_swap_rowcol, [ :pointer, :size_t, :size_t ], :int
+    attach_function :gsl_matrix_transpose_memcpy, [ :pointer, :pointer ], :int
+    attach_function :gsl_matrix_transpose, [ :pointer ], :int
+    
+    # From local extension    
+    # views
+    attach_function :gsl_matrix_submatrix2, [ :pointer, :size_t, :size_t, :size_t, :size_t ], :pointer
+    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
+    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/rng.rb

@@ -0,0 +1,22 @@
+module GSLng
+  backend.instance_eval do
+    # memory handling
+    attach_function :gsl_rng_alloc, [ :pointer ], :pointer
+    attach_function :gsl_rng_free, [ :pointer ], :void
+
+    # RNG types
+    algorithms = %w(mt19937 ranlxs0 ranlxs1 ranlxs2 ranlxd1 ranlxd2 ranlux ranlux389 cmrg mrg taus taus2 gfsr4)
+    algorithms.each do |alg|
+      attach_variable :"gsl_rng_#{alg}", :pointer
+    end
+
+    # Uniform
+    attach_function :gsl_ran_flat, [ :pointer, :double, :double ], :double
+    attach_function :gsl_ran_flat_pdf, [ :double, :double, :double ], :double
+
+    # Gaussian
+    attach_function :gsl_ran_gaussian, [ :pointer, :double ], :double
+    attach_function :gsl_ran_gaussian_ziggurat, [ :pointer, :double ], :double
+    attach_function :gsl_ran_gaussian_ratio_method, [ :pointer, :double ], :double
+  end
+end

data/lib/gslng/backend_components/special.rb

@@ -0,0 +1,7 @@
+module GSLng
+  backend.instance_eval do
+    # trigonometric
+    attach_function :gsl_sf_angle_restrict_symm, [ :double ], :double
+    attach_function :gsl_sf_angle_restrict_pos, [ :double ], :double
+  end
+end

data/lib/gslng/backend_components/stats.rb

@@ -0,0 +1,36 @@
+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
+    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

@@ -0,0 +1,64 @@
+module GSLng
+  backend.instance_eval do
+    # memory handling
+    attach_function :gsl_vector_alloc, [ :size_t ], :pointer
+    attach_function :gsl_vector_calloc, [ :size_t ], :pointer
+    attach_function :gsl_vector_free, [ :pointer ], :void
+
+    # initializing
+    attach_function :gsl_vector_set_all, [ :pointer, :double ], :void
+    attach_function :gsl_vector_set_zero, [ :pointer ], :void
+    attach_function :gsl_vector_set_basis, [ :pointer, :size_t ], :int
+
+    # operations
+    attach_function :gsl_vector_add, [ :pointer, :pointer ], :int
+    attach_function :gsl_vector_sub, [ :pointer, :pointer ], :int
+    attach_function :gsl_vector_mul, [ :pointer, :pointer ], :int
+    attach_function :gsl_vector_div, [ :pointer, :pointer ], :int
+    attach_function :gsl_vector_scale, [ :pointer, :double ], :int
+    attach_function :gsl_vector_add_constant, [ :pointer, :double ], :int
+
+    # element access
+    attach_function :gsl_vector_get, [ :pointer, :size_t ], :double
+    attach_function :gsl_vector_set, [ :pointer, :size_t, :double ], :void
+
+    # properties
+    attach_function :gsl_vector_isnull, [ :pointer ], :int
+    attach_function :gsl_vector_ispos, [ :pointer ], :int
+    attach_function :gsl_vector_isneg, [ :pointer ], :int
+    attach_function :gsl_vector_isnonneg, [ :pointer ], :int
+
+    # max and min
+    attach_function :gsl_vector_max, [ :pointer ], :double
+    attach_function :gsl_vector_min, [ :pointer ], :double
+    attach_function :gsl_vector_minmax, [ :pointer, :buffer_out, :buffer_out ], :void
+    attach_function :gsl_vector_max_index, [ :pointer ], :size_t
+    attach_function :gsl_vector_min_index, [ :pointer ], :size_t
+    attach_function :gsl_vector_minmax_index, [ :pointer, :buffer_out, :buffer_out ], :void
+
+    # copying
+    attach_function :gsl_vector_memcpy, [ :pointer, :pointer ], :int
+
+    # exchanging elements
+    attach_function :gsl_vector_swap_elements, [ :pointer, :size_t, :size_t ], :int
+    attach_function :gsl_vector_reverse, [ :pointer ], :int
+
+    # BLAS functions
+    attach_function :gsl_blas_ddot, [ :pointer, :pointer, :buffer_out ], :int
+    attach_function :gsl_blas_dnrm2, [ :pointer ], :double
+    attach_function :gsl_blas_dasum, [ :pointer ], :double
+    #attach_function :gsl_blas_idamax, [ :pointer ], clbas_index??
+    #attach_function :gsl_blas_dcopy, use this instead of memcpy?
+    attach_function :gsl_blas_daxpy, [ :double, :pointer, :pointer ], :int
+    attach_function :gsl_blas_dscal, [ :double, :pointer ], :void
+
+    # Sorting
+    attach_function :gsl_sort_vector, [ :pointer ], :void
+    
+    # From local extension
+    # 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

@@ -0,0 +1,528 @@
+module GSLng
+  # A fixed-size MxN matrix.
+  #
+  # =Notes
+  # See Vector notes. Everything applies with the following *differences/additions*:
+  # * The {#*} operator performs actual matrix-matrix and matrix-vector products. To perform element-by-element
+  #   multiplication use the {#^} operator (or {#multiply} method) instead. The rest of the operators work element-by-element.
+  # * Operators can handle matrix-matrix, matrix-vector and matrix-scalar (also in reversed order). See {#coerce}.
+  # * The {#[]} and {#[]=} operators can handle a "wildcard" value for any dimension, just like MATLAB's colon (:).
+  class Matrix
+    attr_reader :m, :n    
+    attr_reader :ptr # @private
+    attr_reader :ptr_value # @private
+
+    alias_method :height, :m
+    alias_method :width, :n
+    alias_method :rows, :m
+    alias_method :columns, :n
+
+    # Shorthand for [{#rows},{#columns}]
+    def size; [ @m, @n ] end
+
+    # @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)
+      @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
+      @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
+      @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
+
+    # Create a matrix from an Array
+    # @see Matrix::[]
+    def Matrix.from_array(array)
+      if (array.empty?) then raise "Can't create empty matrix" end
+
+      if (Numeric === array[0])
+        m = Matrix.new(1, array.size)
+        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_value, array)
+        return m
+      else
+        Matrix.new(array.size, array[0].to_a.size) {|i,j| array[i].to_a[j]}
+      end
+    end
+
+    # Create a Matrix from an Array/Array of Arrays/Range
+    # @example
+    #  Matrix[[1,2],[3,4]] => [1.0 2.0; 3.0 4.0]:Matrix
+    #  Matrix[1,2,3] => [1.0 2.0 3.0]:Matrix
+    #  Matrix[[1..3],[5..7]] => [1.0 2.0 3.0; 5.0 6.0 7.0]:Matrix
+    # @see Matrix::from_array    
+    def Matrix.[](*args)
+      Matrix.from_array(args)
+    end
+    
+    # Generates a Matrix of m by n, of random numbers between 0 and 1.
+    # NOTE: This simply uses {Kernel::rand}
+    def Matrix.random(m, n)
+      Matrix.new(m, n).map!{|x| Kernel::rand}
+    end
+    class << self; alias_method :rand, :random end
+
+    # @group Setting/getting values
+
+    # Access the element (i,j), which means (row,column).
+    # Symbols :* or :all can be used as wildcards for both dimensions.
+    # @example If +m = Matrix[[1,2],[3,4]]+
+    #  m[0,0] => 1.0
+    #  m[0,:*] => [1.0, 2.0]:Matrix
+    #  m[:*,0] => [1.0, 3.0]:Matrix
+    #  m[:*,:*] => [1.0, 2.0; 3.0, 4.0]:Matrix
+    # @raise [RuntimeError] if out-of-bounds
+    # @return [Numeric,Matrix] the element/sub-matrix
+    def [](i, j = :*)
+      if (Integer === i && Integer === 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)
+          @backend.gsl_matrix_get_col(col.ptr, @ptr, j)
+          return col.to_matrix
+        elsif (Symbol === j)
+          row = Vector.new(@n)
+          @backend.gsl_matrix_get_row(row.ptr, @ptr, i)
+          return row.to_matrix
+        end
+      end
+    end
+
+    # Set the element (i,j), which means (row,column).
+    # @param [Numeric,Vector,Matrix] value depends on indexing
+    # @raise [RuntimeError] if out-of-bounds
+    # @see #[]
+    def []=(i, j, value)
+      if (Symbol === i && Symbol === j) then
+        if (Numeric === value) then self.fill!(value)
+        else
+          x,y = self.coerce(value)
+          @backend.gsl_matrix_memcpy(@ptr, x.ptr)
+        end
+      elsif (Symbol === i)
+        col = Vector.new(@m)
+        x,y = col.coerce(value)
+        @backend.gsl_matrix_set_col(@ptr, j, x.ptr)
+        return col
+      elsif (Symbol === j)
+        row = Vector.new(@n)
+        x,y = row.coerce(value)
+        @backend.gsl_matrix_set_row(@ptr, i, x.ptr)
+        return row
+      else
+        @backend.gsl_matrix_set_operator(@ptr_value, i, j, value)
+      end
+
+      return self
+    end
+
+    # Set all values to _v_
+    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!; @backend.gsl_matrix_set_zero(@ptr); return self end
+
+    # Set the identity matrix values
+    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
+
+    # 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}
+    # @return [Matrix::View]
+    def view(x = 0, y = 0, m = nil, n = nil)
+      View.new(self, x, y, (m or @m - x), (n or @n - y))
+    end
+    alias_method :submatrix_view, :view
+    
+    # Shorthand for #submatrix_view(..).to_matrix.
+    # @return [Matrix]
+    def submatrix(*args); self.submatrix_view(*args).to_matrix end
+
+    # Creates a {Matrix::View} for the i-th column
+    # @return [Matrix::View]
+    def column_view(i, offset = 0, size = nil); self.view(offset, i, (size or (@m - offset)), 1) end
+
+    # Analogous to {#submatrix}
+    # @return [Matrix]
+    def column(*args); self.column_view(*args).to_matrix end
+
+    # Creates a {Matrix::View} for the i-th row
+    # @return [Matrix::View]
+    def row_view(i, offset = 0, size = nil); self.view(i, offset, 1, (size or (@n - offset))) end
+
+    # Analogous to {#submatrix}
+    # @return [Matrix]
+    def row(*args); self.row_view(*args).to_matrix end
+
+    # Same as {#row_view}, but returns a {Vector::View}
+    # @return [Vector::View]
+    def row_vecview(i, offset = 0, size = nil)
+      size = (@n - offset) if size.nil?
+      ptr = @backend.gsl_matrix_row_view(@ptr, i, offset, size)
+      Vector::View.new(ptr, self, size)
+    end
+
+    # Same as {#column_view}, but returns a {Vector::View}
+    # @return [Vector::View]
+    def column_vecview(i, offset = 0, size = nil)
+      size = (@m - offset) if size.nil?
+      ptr = @backend.gsl_matrix_column_view(@ptr, i, offset, size)
+      Vector::View.new(ptr, self, size, self.columns)
+    end
+
+    
+    # @group Operators
+
+    # Add other to self
+    # @return [Matrix] self
+    def add!(other)
+      case other
+      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)
+      end
+      return self
+    end
+
+    # Substract other from self
+    # @return [Matrix] self    
+    def substract!(other)
+      case other
+      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)
+      end
+      return self
+    end
+    alias_method :sub!, :substract!
+
+    # Multiply (element-by-element) other with self
+    # @return [Matrix] self    
+    def multiply!(other)
+      case other
+      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)
+      end
+      return self
+    end
+    alias_method :mul!, :multiply!
+
+    # Divide (element-by-element) self by other
+    # @return [Matrix] self    
+    def divide!(other)
+      case other
+      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)
+      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.substract!(other) end
+
+    # Element-by-element division
+    def /(other); self.dup.divide!(other) end
+
+    # Element-by-element product. Both matrices should have same dimensions.
+    def ^(other); self.dup.multiply!(other) end
+    alias_method :multiply, :^
+    alias_method :mul, :^
+
+    # Matrix Product. self.n should equal other.m (or other.size, if a Vector).
+    # @example
+    #  Matrix[[1,2],[2,3]] * 2 => [2.0 4.0; 4.0 6.0]:Matrix
+    # @todo some cases could be optimized when doing Matrix-Matrix, by using dgemv
+    def *(other)
+      case other
+      when Numeric
+        self.multiply(other)
+      when Vector
+        matrix = Matrix.new(self.m, other.size)
+        @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)
+        @backend.gsl_blas_dgemm(:no_transpose, :no_transpose, 1, @ptr, other.ptr, 0, matrix.ptr)
+        return matrix
+      else
+        x,y = other.coerce(self)
+        x * y
+      end
+    end
+
+    # @group Row/column swapping
+
+    # Transposes in-place. Only for square matrices
+    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); @backend.gsl_matrix_transpose_memcpy(matrix.ptr, @ptr); return matrix end
+
+    # Swap the i-th and j-th columnos
+    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); @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); @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?; @backend.gsl_matrix_isnull(@ptr) == 1 ? true : false end
+
+    # if all elements are strictly positive (>0)
+    def positive?; @backend.gsl_matrix_ispos(@ptr) == 1 ? true : false end
+
+    #if all elements are strictly negative (<0)
+    def negative?; @backend.gsl_matrix_isneg(@ptr) == 1 ? true : false end
+    
+    # if all elements are non-negative (>=0)
+    def nonnegative?; @backend.gsl_matrix_isnonneg(@ptr) == 1 ? true : false end
+
+    # If this is a column Matrix
+    def column?; self.columns == 1 end
+
+    # @group Minimum/maximum
+
+    # Maximum element of the Matrix
+    def max; @backend.gsl_matrix_max(@ptr) end
+
+    # Minimum element of the Matrix
+    def min; @backend.gsl_matrix_min(@ptr) end
+
+    # Same as {Array#minmax}
+    def minmax
+      min = FFI::Buffer.new(:double)
+      max = FFI::Buffer.new(:double)
+      @backend.gsl_matrix_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 i-th and j-th min, and i-th and j-th max.
+    def minmax_index
+      i_min = FFI::Buffer.new(:size_t)
+      j_min = FFI::Buffer.new(:size_t)
+      i_max = FFI::Buffer.new(:size_t)
+      j_max = FFI::Buffer.new(:size_t)
+      @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
+
+    # Same as {#min}, but returns the indices to the i-th and j-th minimum elements
+    def min_index
+      i_min = FFI::Buffer.new(:size_t)
+      j_min = FFI::Buffer.new(:size_t)
+      @backend.gsl_matrix_min_index(@ptr, i_min, j_min)
+      return [i_min[0].get_ulong(0), j_min[0].get_ulong(0)]
+    end
+
+    # Same as {#max}, but returns the indices to the i-th and j-th maximum elements
+    def max_index
+      i_max = FFI::Buffer.new(:size_t)
+      j_max = FFI::Buffer.new(:size_t)
+      @backend.gsl_matrix_max_index(@ptr, i_max, j_max)
+      return [i_max[0].get_ulong(0), j_max[0].get_ulong(0)]
+    end
+
+    # @group High-order methods
+
+    # Yields the specified block for each element going row-by-row
+    # @yield [elem]
+    def each 
+      @m.times {|i| @n.times {|j| yield(self[i,j]) } }
+    end
+
+    # Yields the specified block for each element going row-by-row
+    # @yield [elem, i, j]
+    def each_with_index 
+      @m.times {|i| @n.times {|j| yield(self[i,j], i, j) } }
+    end
+
+    # Calls the block on each element of the matrix
+    # @yield [elem]
+    # @return [void]
+    def each(block = Proc.new) 
+      @backend.gsl_matrix_each(@ptr_value, &block)
+    end
+    
+    # @see #each
+    # @yield [elem,i,j]
+    def each_with_index(block = Proc.new) 
+      @backend.gsl_matrix_each_with_index(@ptr_value, &block)
+    end    
+
+    # Yields the block for each row *view* ({Matrix::View}).
+    # @yield [view]
+    def each_row; self.rows.times {|i| yield(row_view(i))} end
+
+    # Same as {#each_row}, but yields {Vector::View}'s
+    # @yield [vector_view]    
+    def each_vec_row; self.rows.times {|i| yield(row_vecview(i))} end
+
+    # Same as #each_column, but yields {Vector::View}'s
+    # @yield [vector_view]    
+    def each_vec_column; self.columns.times {|i| yield(column_vecview(i))} end
+
+    # Yields the block for each column *view* ({Matrix::View}).
+    # @yield [view]    
+    def each_column; self.columns.times {|i| yield(column_view(i))} end
+
+    # Efficient {#map!} implementation
+    # @yield [elem]
+    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); @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); @backend.gsl_matrix_map_with_index!(@ptr_value, &block); return self end
+
+    # @see #map!
+    # @return [Matrix]
+    # @yield [elem]
+    def map(block = Proc.new); self.dup.map!(block) end
+
+    # @see #map
+    # @return [Array]
+    # @yield [elem]
+    def map_array(block = Proc.new); @backend.gsl_matrix_map_array(@ptr_value, &block) end
+
+    # @group Type conversions
+
+    # Same as {Array#join}
+    # @example
+    #  Matrix[[1,2],[2,3]].join => "1.0 2.0 2.0 3.0"
+    def join(sep = $,)
+      s = ''
+      self.each do |e|
+        s += (s.empty?() ? e.to_s : "#{sep}#{e}")
+      end
+      return s
+    end
+
+    # Converts the matrix to a String, separating each element with a space and each row with a ';' and a newline.
+    # @example
+    #  Matrix[[1,2],[2,3]] => "[1.0 2.0;\n 2.0 3.0]"
+    def to_s
+      s = '['
+      @m.times do |i|
+        s += ' ' unless i == 0
+        @n.times do |j|
+          s += (j == 0 ? self[i,j].to_s : ' ' + self[i,j].to_s)
+        end
+        s += (i == (@m-1) ? ']' : ";\n")
+      end
+
+      return s
+    end
+    
+    # Converts the matrix to an Array (of Arrays).
+    # @example
+    #  Matrix[[1,2],[2,3]] => [[1.0,2.0],[2.0,3.0]]
+    def to_a
+      @backend.gsl_matrix_to_a(@ptr_value)
+    end
+
+    def inspect # @private
+      "#{self}:Matrix"
+    end
+
+    # Coerces _other_ to be of Matrix class.
+    # If _other_ is a scalar (Numeric) a Matrix filled with _other_ values is created.
+    # Vectors are coerced using {Vector#to_matrix} (which results in a row matrix).
+    def coerce(other)
+      case other
+      when Matrix
+        [ other, self ]
+      when Numeric
+        [ Matrix.new(@m, @n).fill!(other), self ]
+      when Vector
+        [ other.to_matrix, self ]
+      else
+        raise TypeError, "Can't coerce #{other.class} into #{self.class}"
+      end
+    end
+
+    # @group Equality
+
+    # Element-by-element comparison.
+    def ==(other)
+      if (self.m != other.m || self.n != other.n) then return false end
+
+      @m.times do |i|
+        @n.times do |j|
+          if (self[i,j] != other[i,j]) then return false end
+        end
+      end
+      
+      return true
+    end
+
+    # @group FFI
+
+    # Returns the FFI::Pointer to the underlying C data memory; can be used to
+    # pass the data directly to/from other FFI libraries, without needing
+    # to go through Ruby conversion
+    def data_ptr
+      GSLmatrix.new(ptr)[:data]
+    end
+  end
+end