ruby-gsl-ng 0.1.0 → 0.2.0

data/History.txt

@@ -1,4 +1,9 @@
-=== 0.0.1 / 2009-12-09
+=== 0.2.0
+* Completed Vector
+* Added Matrix (mostly complete)
+* Added Vector::View and Matrix::View
+
+=== 0.1.0 / 2009-12-09
 
 * Initial version
   * Only class Vector (but completely documented and implemented)

data/Manifest.txt

@@ -5,10 +5,18 @@ README.txt
 Rakefile
 ext/extconf.rb
 ext/gslng_extensions.cpp
-lib/gsl.rb
-lib/gsl/backend.rb
-lib/gsl/finalizer.rb
-lib/gsl/vector.rb
+lib/gslng.rb
+lib/gslng/backend.rb
+lib/gslng/backend_components/error_handling.rb
+lib/gslng/backend_components/matrix.rb
+lib/gslng/backend_components/vector.rb
+lib/gslng/finalizer.rb
+lib/gslng/matrix.rb
+lib/gslng/matrix_view.rb
+lib/gslng/vector.rb
+lib/gslng/vector_view.rb
+test/benchmark.rb
+test/matrix_test.rb
 test/test_gsl.rb
 test/vector_test.rb
 

data/README.txt

@@ -2,7 +2,10 @@
 
 * http://ruby-gsl-ng.googlecode.com
 
-= Description
-* New-generation Ruby/GSL wrapper.
+== DESCRIPTION:
 
+New-generation Ruby/GSL wrapper.
 
+== LICENSE:
+
+GPLv2

data/Rakefile

@@ -7,6 +7,7 @@ Hoe.spec('ruby-gsl-ng') do
   developer('v01d', 'phreakuencies@gmail.com')
   spec_extras[:extensions] = ["ext/extconf.rb"]
   extra_deps << [ 'ffi', '>=0' ]
+  ENV['NODOT'] = '1'
 end
 
 # vim: syntax=ruby

data/ext/extconf.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/ruby
 require 'mkmf'
 gsl_vars = pkg_config('gsl') or raise 'GSL not found!'
+extra_flags='-O3 -march=native'
+with_cppflags("#{$CPPFLAGS} #{extra_flags}") { true }
 create_makefile('gslng_extensions')

data/ext/gslng_extensions.cpp

@@ -5,6 +5,7 @@
  */
 
 #include <gsl/gsl_vector.h>
+#include <gsl/gsl_matrix.h>
 
 extern "C" void Init_gslng_extensions(void) { }
 
@@ -26,3 +27,79 @@ extern "C" void gsl_vector_map_index(gsl_vector* v, gsl_vector_index_callback_t
 		*gsl_vector_ptr(v, i) = (*callback)(i);
 }
 
+// A fast "each" for cases where there's no expected return value from the block
+typedef void (*gsl_vector_each_callback_t)(double);
+
+extern "C" void gsl_vector_each(gsl_vector* v, gsl_vector_each_callback_t callback) {
+	for (size_t i = 0; i < v->size; i++)
+		(*callback)(*gsl_vector_const_ptr(v, i));
+}
+
+// A fast "each_with_index" for cases where there's no expected return value from the block
+typedef void (*gsl_vector_each_with_index_callback_t)(double, size_t);
+
+extern "C" void gsl_vector_each_with_index(gsl_vector* v, gsl_vector_each_with_index_callback_t callback) {
+	for (size_t i = 0; i < v->size; i++)
+		(*callback)(*gsl_vector_const_ptr(v, i), 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);
+  gsl_vector* vector_view = gsl_vector_alloc(view.vector.size);
+  *vector_view = view.vector;
+  return vector_view;
+}
+
+// Hide the view in a new vector (gsl_vector_subvector)
+extern "C" gsl_vector* gsl_vector_subvector2(gsl_vector* v, size_t offset, size_t n) {
+  gsl_vector_view view = gsl_vector_subvector(v, offset, n);
+  gsl_vector* vector_view = gsl_vector_alloc(view.vector.size);
+  *vector_view = view.vector;
+  return vector_view;
+}
+
+/***** Matrix *****/
+// For Matrix::map!
+typedef double (*gsl_matrix_callback_t)(double);
+
+extern "C" void gsl_matrix_map(gsl_matrix* m, gsl_matrix_callback_t callback) {
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++)
+    for (size_t j = 0; j < size2; j++)
+      *gsl_matrix_ptr(m, i, j) = (*callback)(*gsl_matrix_const_ptr(m, i, j));
+}
+
+// For Matrix::map_index!
+typedef double (*gsl_matrix_index_callback_t)(size_t, size_t);
+
+extern "C" void gsl_matrix_map_index(gsl_matrix* m, gsl_matrix_index_callback_t callback) {
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++)
+    for (size_t j = 0; j < size2; j++)
+  		*gsl_matrix_ptr(m, i, j) = (*callback)(i, j);
+}
+
+// A fast "each" for cases where there's no expected return value from the block
+typedef void (*gsl_matrix_each_callback_t)(double);
+
+extern "C" void gsl_matrix_each(gsl_matrix* m, gsl_matrix_each_callback_t callback) {
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++)
+    for (size_t j = 0; j < size2; j++)
+  		(*callback)(*gsl_matrix_const_ptr(m, i, j));
+}
+
+// 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);
+  gsl_matrix* matrix_view = gsl_matrix_alloc(view.matrix.size1, view.matrix.size2);
+  *matrix_view = view.matrix;
+  return matrix_view;
+}

data/lib/gslng/backend.rb

@@ -0,0 +1,19 @@
+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
+  end
+
+  # Returns the internal backend module
+	def GSLng.backend
+    @backend
+  end
+end
+
+require 'gslng_extensions'
+require 'gslng/backend_components/vector'
+require 'gslng/backend_components/matrix'
+require 'gslng/backend_components/error_handling'

data/lib/gslng/backend_components/error_handling.rb

@@ -0,0 +1,12 @@
+module GSLng #:nodoc:
+	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,73 @@
+module GSLng
+	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
+		callback :gsl_matrix_callback, [ :double ], :double
+		attach_function :gsl_matrix_map, [ :pointer, :gsl_matrix_callback ], :void
+
+		callback :gsl_matrix_index_callback, [ :size_t, :size_t ], :double
+		attach_function :gsl_matrix_map_index, [ :pointer, :gsl_matrix_index_callback ], :void
+
+		callback :gsl_matrix_each_callback, [ :double ], :void
+		attach_function :gsl_matrix_each, [ :pointer, :gsl_matrix_each_callback ], :void
+
+    # views
+    attach_function :gsl_matrix_submatrix2, [ :pointer, :size_t, :size_t, :size_t, :size_t ], :pointer
+
+    # 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
+	end
+end

data/lib/{gsl/backend.rb → gslng/backend_components/vector.rb}

@@ -1,22 +1,15 @@
-require 'ffi'
-
-module GSL
-  # TODO: get a way to properly define the type of size_t (assumed to be :uint)
-  # 
-  module Backend
-    extend FFI::Library
-    
-    ##----- Vector ------##
-    # memory handling
+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
@@ -24,17 +17,17 @@ module GSL
     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
@@ -42,15 +35,14 @@ module GSL
     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
-    attach_function :gsl_vector_swap, [ :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
@@ -60,24 +52,24 @@ module GSL
     attach_function :gsl_blas_daxpy, [ :double, :pointer, :pointer ], :int
     attach_function :gsl_blas_dscal, [ :double, :pointer ], :void
 
+    # 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
+
 		# From local extension
-		callback :gsl_vector_callback, [ :double ], :double		
+		callback :gsl_vector_callback, [ :double ], :double
 		attach_function :gsl_vector_map, [ :pointer, :gsl_vector_callback ], :void
 
 		callback :gsl_vector_index_callback, [ :size_t ], :double
 		attach_function :gsl_vector_map_index, [ :pointer, :gsl_vector_index_callback ], :void
 
+		callback :gsl_vector_each_callback, [ :double ], :void
+		attach_function :gsl_vector_each, [ :pointer, :gsl_vector_each_callback ], :void
+
+		callback :gsl_vector_each_with_index_callback, [ :double, :size_t ], :void
+		attach_function :gsl_vector_each_with_index, [ :pointer, :gsl_vector_each_with_index_callback ], :void
+
 		# Sorting
 		attach_function :gsl_sort_vector, [ :pointer ], :void
-    
-    ##----- Error handling ------##
-    callback :error_handler_callback, [ :string, :string, :int, :int ], :void
-    attach_function :gsl_set_error_handler, [ :error_handler_callback ], :error_handler_callback
-    
-    # TODO: pop this block from the exception stack so that it seems to be coming from the original gsl function
-    ErrorHandlerCallback = Proc.new {|reason, file, line, errno|
-      raise RuntimeError, "#{reason} at #{file}:#{line} (errno: #{errno})"      
-    }
-    gsl_set_error_handler(ErrorHandlerCallback)
-  end
-end
+	end
+end

data/lib/gslng/finalizer.rb

@@ -0,0 +1,5 @@
+module GSLng
+  def GSLng.set_finalizer(obj, func, ptr) #:nodoc:
+    ObjectSpace.define_finalizer(obj, lambda {|id| GSLng.backend.send(func, ptr)})
+  end
+end