ruby-gsl-ng 0.1.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,5 @@
+=== 0.0.1 / 2009-12-09
+
+* Initial version
+  * Only class Vector (but completely documented and implemented)
+

data/Manifest.txt

@@ -0,0 +1,14 @@
+.autotest
+History.txt
+Manifest.txt
+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
+test/test_gsl.rb
+test/vector_test.rb
+

data/README.txt

@@ -0,0 +1,8 @@
+= Ruby/GSL-ng
+
+* http://ruby-gsl-ng.googlecode.com
+
+= Description
+* New-generation Ruby/GSL wrapper.
+
+

data/Rakefile

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

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+require 'mkmf'
+gsl_vars = pkg_config('gsl') or raise 'GSL not found!'
+create_makefile('gslng_extensions')

data/ext/gslng_extensions.cpp

@@ -0,0 +1,28 @@
+/**
+ * gsl_extension module: provides some simple C functions in cases where a faster version of some
+ * Ruby method is really necessary.
+ * This could actually a standard C library (not a Ruby extension), but it's easier this way.
+ */
+
+#include <gsl/gsl_vector.h>
+
+extern "C" void Init_gslng_extensions(void) { }
+
+/**** Vector *****/
+
+// For Vector::map!
+typedef double (*gsl_vector_callback_t)(double);
+
+extern "C" void gsl_vector_map(gsl_vector* v, gsl_vector_callback_t callback) {
+	for (size_t i = 0; i < v->size; i++)
+		*gsl_vector_ptr(v, i) = (*callback)(*gsl_vector_const_ptr(v, i));
+}
+
+// For Vector::map_index!
+typedef double (*gsl_vector_index_callback_t)(size_t);
+
+extern "C" void gsl_vector_map_index(gsl_vector* v, gsl_vector_index_callback_t callback) {
+	for (size_t i = 0; i < v->size; i++)
+		*gsl_vector_ptr(v, i) = (*callback)(i);
+}
+

data/lib/gsl.rb

@@ -0,0 +1,8 @@
+require 'gslng_extensions'
+require 'gsl/backend'
+require 'gsl/finalizer'
+require 'gsl/vector'
+
+module GSL
+  VERSION = "0.1.0"
+end

data/lib/gsl/backend.rb

@@ -0,0 +1,83 @@
+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
+    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
+    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
+    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
+
+		# From local extension
+		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
+
+		# 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

data/lib/gsl/finalizer.rb

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

data/lib/gsl/vector.rb

@@ -0,0 +1,236 @@
+module GSL
+  # A fixed-size n-dimensional vector.
+  #
+  # =Examples
+	#  Vector[1,2,3] + Vector[2,3,4] => Vector[3,5,7]
+	#  Vector[1,2,3] + 0.5 => Vector[1.5,2.5,3.5]
+	# Same goes for *, /, and - operators. The are also self-modifying versions (#add, #mul, #div, #sub).
+	#
+  # Note also that operator ^ produces the #dot product:
+	#  Vector[1,2,3] ^ Vector[2,3,4] => 20
+	#
+  # =Notes
+  # * This class includes Enumerable, but certain methods are redefined (like #max and #min)
+  #   for fast versions that don't use #each. Calling #each (and therefore, any other Enumerable's method) is slower.
+	# * #each is implemented through calls to #[], which can be relatively slow (compared to direct C pointer access)
+	#   for big Vectors. It would be possible to have a faster version that iterates on the C-side and calls a block for each
+	#   element, but in that case it wouldn't be possible to expect a return value of any type. This complicates things for methods like
+	#   #any? which expect a boolean value.
+	# * Some functions (like #sum, #dot, and others) use BLAS functions (through GSL's CBLAS interface).
+	#--
+  # TODO: add type coercions
+	#
+  class Vector
+    include Enumerable
+    
+    attr_reader :ptr	# :nodoc:
+    attr_reader :size # Vector size
+    
+    # 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)
+      if (zero) then @ptr = GSL::Backend::gsl_vector_calloc(n)
+      else @ptr = GSL::Backend::gsl_vector_alloc(n) end
+      GSL.set_finalizer(self, :gsl_vector_free, @ptr)
+      
+      @size = n # TODO: extract from @ptr
+
+			if (block_given?) then self.map_index! {|i| yield(i)} end
+    end
+
+    def initialize_copy(other) #:nodoc:
+      ObjectSpace.undefine_finalizer(self) # TODO: ruby bug?
+      @ptr = GSL::Backend::gsl_vector_alloc(other.size)
+      GSL.set_finalizer(self, :gsl_vector_free, @ptr)
+      
+      @size = other.size
+      GSL::Backend::gsl_vector_memcpy(@ptr, other.ptr)
+    end
+
+		# Same as Vector.new(n, true)
+		def Vector.zero(n); Vector.new(n, true) end
+
+		# Create a vector from an Array
+		def Vector.from_array(array)
+			if (array.empty?) then raise "Can't create empty vector" end
+			Vector.new(array.size) {|i| array[i]}
+		end
+
+		# See #from_array
+		def Vector.[](*args)
+			Vector.from_array(args)
+		end
+
+    # Generates a Vector of n random numbers between 0 and 1.
+    # NOTE: This simply uses Kernel::rand
+    def Vector.random(n); Vector.new(n).map!{|x| Kernel::rand} end
+		class << self; alias_method :rand, :random end
+    
+    # Copy other's values into self
+    def copy(other); GSL::Backend::gsl_vector_memcpy(@ptr, other.ptr); return self end
+    
+    # Set all values to v
+    def all!(v); GSL::Backend::gsl_vector_set_all(@ptr, v); return self end
+		alias_method :set!, :all!
+    
+    # Set all values to zero
+    def zero!; GSL::Backend::gsl_vector_set_zero(@ptr); return self end
+    
+    # Set all values to zero, except the i-th element, which is set to 1
+    def basis!(i); GSL::Backend::gsl_vector_set_basis(@ptr, i); return self end
+    
+    # Add other to self
+    def add(other)
+      case other
+      when Numeric; GSL::Backend::gsl_vector_add_constant(@ptr, other.to_f)
+      when Vector; GSL::Backend::gsl_vector_add(@ptr, other.ptr)
+      else raise TypeError, "Unsupported type: #{other.class}" end
+			return self
+    end
+    
+    # Substract other from self
+    def sub(other)
+      case other
+      when Numeric; GSL::Backend::gsl_vector_add_constant(@ptr, -other.to_f)
+      when Vector; GSL::Backend::gsl_vector_sub(@ptr, other.ptr)
+      else raise TypeError, "Unsupported type: #{other.class}" end
+			return self
+    end
+    
+    # Multiply (element-by-element) other with self
+    def mul(other)
+      case other
+      when Numeric; GSL::Backend::gsl_blas_dscal(other.to_f, @ptr)
+      when Vector; GSL::Backend::gsl_vector_mul(@ptr, other.ptr)
+      else raise TypeError, "Unsupported type: #{other.class}" end
+			return self
+    end
+    
+    # Divide (element-by-element) self by other
+    def div(other)
+      case other
+      when Numeric; GSL::Backend::gsl_blas_dscal(1.0 / other, @ptr)
+      when Vector;  GSL::Backend::gsl_vector_div(@ptr, other.ptr)
+      else raise TypeError, "Unsupported type: #{other.class}" end
+			return self
+    end
+
+    def +(other); self.dup.add(other) end
+    def -(other); self.dup.sub(other) end
+    def *(other); self.dup.mul(other) end
+    def /(other); self.dup.div(other) end
+    
+    # Reverse the order of elements
+    def reverse!; GSL::Backend::gsl_vector_reverse(@ptr); return self end
+    
+    # Swap the i-th element with the j-th element
+    def swap(i,j); GSL::Backend::gsl_vector_swap_elements(@ptr, i, j); return self end
+
+		# Access the i-th element (throws exception if out-of-bounds)
+    def [](i); GSL::Backend::gsl_vector_get(@ptr, i) end
+
+		# set the i-th element (throws exception if out-of-bounds)
+    def []=(i, v); GSL::Backend::gsl_vector_set(@ptr, i, v.to_f) end
+    
+    # if all elements are zero
+    def zero?; GSL::Backend::gsl_vector_isnull(@ptr) == 1 ? true : false end
+
+    # if all elements are strictly positive (>0)
+    def positive?; GSL::Backend::gsl_vector_ispos(@ptr) == 1 ? true : false end
+
+    #if all elements are strictly negative (<0)
+    def negative?; GSL::Backend::gsl_vector_isneg(@ptr) == 1 ? true : false end
+		
+    # if all elements are non-negative (>=0)
+    def nonnegative?; GSL::Backend::gsl_vector_isnonneg(@ptr) == 1 ? true : false end
+    
+    def max; GSL::Backend::gsl_vector_max(@ptr) end
+
+    def min; GSL::Backend::gsl_vector_min(@ptr) end
+
+		# Same as Array#minmax
+    def minmax
+      min = FFI::Buffer.new(:double)
+      max = FFI::Buffer.new(:double)
+      GSL::Backend::gsl_vector_minmax(@ptr, min, max)      
+      return [min[0].get_float64(0),max[0].get_float64(0)]
+    end
+
+		# Same as #minmax, but returns the indices to the elements
+    def minmax_index
+      min = FFI::Buffer.new(:size_t)
+      max = FFI::Buffer.new(:size_t)
+      GSL::Backend::gsl_vector_minmax_index(@ptr, min, max)      
+      #return [min[0].get_size_t(0),max[0].get_size_t(0)]
+			return [min[0].get_ulong(0),max[0].get_ulong(0)]
+    end
+    
+    # Same as #min, but returns the index to the element
+    def min_index; GSL::Backend::gsl_vector_min_index(@ptr) end
+
+    # Same as #max, but returns the index to the element    
+    def max_index; GSL::Backend::gsl_vector_max_index(@ptr) end
+    
+    # Dot product between self and other (uses BLAS's ddot)
+    def dot(other)
+      out = FFI::MemoryPointer.new(:double)
+      GSL::Backend::gsl_blas_ddot(@ptr, other.ptr, out)
+      return out[0].get_double(0)
+    end
+    alias_method :^, :dot
+    
+    # Norm 2 of the vector (uses BLAS's dnrm2)
+    def norm; GSL::Backend::gsl_blas_dnrm2(@ptr) end
+    alias_method :length, :norm
+
+    # Returns the sum of all elements (uses BLAS's dasum)
+    def sum; GSL::Backend::gsl_blas_dasum(@ptr) end
+
+    # Optimized version of: self += other * alpha (where alpha is a Numeric). Uses BLAS's daxpy.
+    def mul_add(other, alpha); GSL::Backend::gsl_blas_daxpy(alpha, other.ptr, @ptr); return self end
+    
+    # Yields the block for each element in the Vector
+		def each # :yield: obj
+			@size.times {|i| yield(self[i])}
+		end
+
+		# Efficient map! implementation
+		def map!(&block); GSL::Backend::gsl_vector_map(@ptr, block); return self end
+
+		# Alternate version of #map!, in this case the block receives the index as a parameter.
+		def map_index!(&block); GSL::Backend::gsl_vector_map_index(@ptr, block); return self end
+
+		# See #map!. Returns a Vector.
+		def map(&block); self.dup.map!(block) end
+
+		def sort!; GSL::Backend::gsl_sort_vector(@ptr); return self end
+		def sort; self.dup.sort! end
+
+		def join(sep = $,)
+			s = "#{self[0]}"
+			(1..(@size-1)).each do |e|
+				s += sep + self[e].to_s
+			end
+			return s
+		end
+
+		def to_s
+			"[" + self.join(', ') + "]"
+		end
+
+		def to_a
+			Array.new(@size) {|i| self[i]}
+		end
+
+		# Element-by-element comparison (uses #each_with_index)
+		# Admits comparing to Array
+		def ==(other)
+			if (self.size != other.size) then return false end
+			self.each_with_index do |elem,i|
+				if (elem != other[i]) then return false end
+			end
+			return true
+		end
+  end
+end

data/test/test_gsl.rb

@@ -0,0 +1,9 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require 'test/unit' 
+
+# Add your testcases here
+
+require 'vector_test'
+

data/test/vector_test.rb

@@ -0,0 +1,75 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'..','ext')
+
+require 'test/unit'
+require 'gsl'
+
+class VectorTest < Test::Unit::TestCase
+  def test_initialize
+		assert_equal(10, GSL::Vector.new(10).size)
+		assert_equal(10, GSL::Vector.zero(10).size)
+		assert(GSL::Vector.zero(10).zero?)
+		assert_nothing_raised { GSL::Vector.random(10) }
+  end
+
+	def test_to_s
+		assert_equal("[0.0]", GSL::Vector.zero(1).to_s)
+		assert_equal("[0.0, 0.0, 0.0]", GSL::Vector.zero(3).to_s)
+		assert_equal("[0.0, 1.0, 2.0]", GSL::Vector.new(3) {|i| i}.to_s)
+		assert_equal("[1.0, 2.0, 3.0]", GSL::Vector[1,2,3].to_s)
+	end
+
+	def test_equal
+		assert_equal(GSL::Vector[1,2,3], [1,2,3])
+		assert_equal(GSL::Vector[1,2,3], GSL::Vector[1,2,3])
+		assert_equal(GSL::Vector.zero(3), GSL::Vector.zero(3))
+		assert_not_equal(GSL::Vector.zero(4), GSL::Vector.zero(3))		
+	end
+
+	def test_copies
+		v1 = GSL::Vector[1,2,3]
+		v2 = GSL::Vector[2,3,4]
+		assert_not_equal(v1, v2)
+		assert_equal(v1.copy(v2), v2)
+		assert_equal(v1.dup, v2)
+	end
+
+	def test_sets
+		assert_equal(GSL::Vector.zero(3).set!(1), GSL::Vector[1,1,1])
+		assert_equal(GSL::Vector.zero(3).set!(1).zero!, GSL::Vector.zero(3))
+		assert_equal(GSL::Vector.zero(3).basis!(1), GSL::Vector[0,1,0])
+	end
+
+	def test_operators
+		assert_equal(GSL::Vector[2,3,4],GSL::Vector[1,2,3] + GSL::Vector[1,1,1])
+		assert_equal(GSL::Vector[1,0,3],GSL::Vector[1,2,3] * GSL::Vector[1,0,1])
+		assert_equal(GSL::Vector[0,1,2],GSL::Vector[1,2,3] - GSL::Vector[1,1,1])
+		assert_equal(GSL::Vector[0.5,1,1.5],GSL::Vector[1,2,3] / GSL::Vector[2,2,2])
+
+		assert_equal(GSL::Vector[3,6,9],GSL::Vector[1,2,3] * 3)
+		assert_equal(GSL::Vector[4,5,6],GSL::Vector[1,2,3] + 3)
+		assert_equal(GSL::Vector[-2,-1,0],GSL::Vector[1,2,3] - 3)
+		assert_equal(GSL::Vector[0.5,1,1.5],GSL::Vector[1,2,3] / 2)
+	end
+
+	def test_other
+		assert_equal(GSL::Vector[1,2,3], GSL::Vector[1,2,3].to_a)
+		assert_equal(GSL::Vector[1,2,3], GSL::Vector[3,1,2].sort)
+		assert_equal(6, GSL::Vector[3,1,2].sum)
+		assert_equal(GSL::Vector[3,1,2].mul_add(GSL::Vector[1,0,1],0.5), GSL::Vector[3.5,1,2.5])
+		assert_equal(3, GSL::Vector[2,1,2].norm)
+		assert_equal(5, GSL::Vector[3,1,2] ^ GSL::Vector[1,0,1])
+	end
+
+	def test_minmax
+		assert_equal(1, GSL::Vector[1,2,3].min)
+		assert_equal(3, GSL::Vector[1,2,3].max)
+		assert_equal([1,3], GSL::Vector[1,2,3].minmax)
+		assert_equal(0, (GSL::Vector[1,2,3]).min_index)
+		assert_equal(2, (GSL::Vector[1,2,3]).max_index)
+		assert_equal([0,2], GSL::Vector[1,2,3].minmax_index)
+	end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-gsl-ng
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- v01d
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-09 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: "* New-generation Ruby/GSL wrapper."
+email: 
+- phreakuencies@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- 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
+- test/test_gsl.rb
+- test/vector_test.rb
+has_rdoc: true
+homepage: http://ruby-gsl-ng.googlecode.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-gsl-ng
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: "* New-generation Ruby/GSL wrapper."
+test_files: 
+- test/test_gsl.rb