ruby-gsl-ng 0.1.0 → 0.2.0

data/test/vector_test.rb

@@ -5,71 +5,104 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 $:.unshift File.join(File.dirname(__FILE__),'..','ext')
 
 require 'test/unit'
-require 'gsl'
+require 'gslng'
+
+include GSLng
 
 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) }
+		assert_equal(10, Vector.new(10).size)
+		assert_equal(10, Vector.zero(10).size)
+		assert(Vector.zero(10).zero?)
+		assert_nothing_raised { 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)
+		assert_equal("[0.0]", Vector.zero(1).to_s)
+		assert_equal("[0.0, 0.0, 0.0]", Vector.zero(3).to_s)
+		assert_equal("[0.0, 1.0, 2.0]", Vector.new(3) {|i| i}.to_s)
+		assert_equal("[1.0, 2.0, 3.0]", Vector[1,2,3].to_s)
+    assert_equal("1.0 2.0 3.0", Vector[1,2,3].join(' '))
 	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))		
+		assert_equal(Vector[1,2,3], [1,2,3])
+		assert_equal(Vector[1,2,3], Vector[1,2,3])
+    assert_equal(Vector[0...3], [0,1,2])
+		assert_equal(Vector.zero(3), Vector.zero(3))
+		assert_not_equal(Vector.zero(4), Vector.zero(3))		
 	end
 
 	def test_copies
-		v1 = GSL::Vector[1,2,3]
-		v2 = GSL::Vector[2,3,4]
+		v1 = Vector[1,2,3]
+		v2 = 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])
+		assert_equal(Vector.zero(3).set!(1), Vector[1,1,1])
+		assert_equal(Vector.zero(3).set!(1).zero!, Vector.zero(3))
+		assert_equal(Vector.zero(3).basis!(1), 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)
+		assert_equal(Vector[2,3,4],Vector[1,2,3] + Vector[1,1,1])
+		assert_equal(Vector[1,0,3],Vector[1,2,3] * Vector[1,0,1])
+		assert_equal(Vector[0,1,2],Vector[1,2,3] - Vector[1,1,1])
+		assert_equal(Vector[0.5,1,1.5],Vector[1,2,3] / Vector[2,2,2])
+		assert_equal(Vector[3,6,9],Vector[1,2,3] * 3)
+		assert_equal(Vector[4,5,6],3 + Vector[1,2,3])
+		assert_equal(Vector[4,5,6],Vector[1,2,3] + 3)
+    assert_equal(Vector[2,1,0],3 - Vector[1,2,3])
+		assert_equal(Vector[-2,-1,0],Vector[1,2,3] - 3)
+		assert_equal(Vector[3,6,9],3 * Vector[1,2,3])
+		assert_equal(Vector[0.5,1,1.5],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])
+    assert_equal(Matrix[1,2,3], Vector[1,2,3].to_matrix)
+		assert_equal(Vector[1,2,3], Vector[1,2,3].to_a)
+		assert_equal(Vector[1,2,3], Vector[3,1,2].sort)
+		assert_equal(6, Vector[3,1,2].sum)
+		assert_equal(Vector[3,1,2].mul_add(Vector[1,0,1],0.5), Vector[3.5,1,2.5])
+		assert_equal(3, Vector[2,1,2].norm)
+		assert_equal(5, Vector[3,1,2] ^ 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)
+		assert_equal(1, Vector[1,2,3].min)
+		assert_equal(3, Vector[1,2,3].max)
+		assert_equal([1,3], Vector[1,2,3].minmax)
+		assert_equal(0, (Vector[1,2,3]).min_index)
+		assert_equal(2, (Vector[1,2,3]).max_index)
+		assert_equal([0,2], Vector[1,2,3].minmax_index)
 	end
+
+	def test_set_get
+		assert_equal(2, Vector[1,2,3][1])
+		assert_raise { Vector[1,2,3][3] }
+		assert_equal(3, Vector[1,2,3][-1])
+		assert_raise { Vector[1,2,3][-5] }
+
+		v = Vector[1,2,3]
+		v[1] = 3
+		assert_equal(Vector[1,3,3], v)
+		v[-1] = 0
+		assert_equal(Vector[1,3,0], v)
+	end
+
+  def test_view
+    v,view = nil,nil
+    assert_nothing_raised {
+      v = Vector[1,2,3]
+      view = v.view
+      view[1] = 3
+    }
+    assert_equal(Vector[1,3,3], v)
+    assert_equal(Vector[1,3,3], view)
+    assert_equal(Vector[1,3], Vector[0,1,2,3].view(1,nil,2))
+    assert_equal(Vector[0,2], Vector[0,1,2,3].view(0,nil,2))
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-gsl-ng
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - v01d
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-09 00:00:00 -03:00
+date: 2010-01-05 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,9 +30,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.3.3
+        version: 2.4.0
     version: 
-description: "* New-generation Ruby/GSL wrapper."
+description: New-generation Ruby/GSL wrapper.
 email: 
 - phreakuencies@gmail.com
 executables: []
@@ -51,10 +51,18 @@ files:
 - 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
 has_rdoc: true
@@ -86,6 +94,6 @@ rubyforge_project: ruby-gsl-ng
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: "* New-generation Ruby/GSL wrapper."
+summary: New-generation Ruby/GSL wrapper.
 test_files: 
 - test/test_gsl.rb

data/lib/gsl/finalizer.rb

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

@@ -1,236 +0,0 @@
-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/lib/gsl.rb

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