ruby-gsl-ngx 0.2.6.1

data/lib/gslng/vector_view.rb

@@ -0,0 +1,44 @@
+module GSLng
+  class Vector
+    # A View of a Vector.
+    #
+    # Views reference an existing Vector (or a row/column from a Matrix) and can be used to access parts of it without
+    # having to copy it entirely. You can treat a View just like a Vector.
+    # But note that modifying elements of a View will modify the elements of the original Vector/Matrix.
+    #
+    class View < Vector
+      # @return [Vector,Matrix] The owner of the data this view accesses
+      attr_reader :owner 
+
+      def initialize(ptr, owner, size, stride = 1) # @private
+        @backend = GSLng.backend
+        @owner,@size,@stride = owner,size,stride
+        @ptr = FFI::AutoPointer.new(ptr, View.method(:release))
+        @ptr_value = @ptr.to_i
+      end
+
+      def View.release(ptr)
+        GSLng.backend.gsl_vector_free(ptr)
+      end
+      
+      # Returns a Vector (*NOT* a View) copied from this view. In other words,
+      # you'll get a Vector which you can modify without modifying {#owner}'s elements
+      # @return [Vector]
+      def dup
+        v = Vector.new(@size)
+        @backend.gsl_vector_memcpy(v.ptr, @ptr)
+        return v
+      end
+      alias_method :clone, :dup
+      alias_method :to_vector, :dup
+
+      def view # @private
+        raise "Can't create a View from a View"
+      end
+
+      def inspect # @private
+        "#{self}:VectorView"
+      end
+    end
+  end
+end

data/ruby-gsl-ngx.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors = ["ronen barzel", "v01d"]
+  gem.email = ["ronen@barzel.org"]
+  gem.description = "Ruby/GSL new-generation wrapper (memory leak fix)"
+  gem.summary = "Ruby/GSL new-generation wrapper (memory leak fix)"
+  gem.homepage = "http://github.com/ronen/gsl-ng"
+
+  gem.extra_rdoc_files = ["README.rdoc", "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", "lib/gslng/backend_components/matrix.rb", "lib/gslng/backend_components/rng.rb", "lib/gslng/backend_components/special.rb", "lib/gslng/backend_components/stats.rb", "lib/gslng/backend_components/vector.rb", "lib/gslng/matrix.rb", "lib/gslng/matrix_view.rb", "lib/gslng/plotter.rb", "lib/gslng/rng/gaussian.rb", "lib/gslng/rng/rng.rb", "lib/gslng/rng/uniform.rb", "lib/gslng/special.rb", "lib/gslng/vector.rb", "lib/gslng/vector_view.rb"]
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  gem.name = "ruby-gsl-ngx"
+  gem.require_paths = ["lib", "ext"]
+  gem.version = "0.2.6.1"
+  gem.extensions = ["ext/extconf.rb"]
+
+  gem.add_dependency "ffi"
+  gem.add_development_dependency "yard"
+end

data/test/benchmark.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/ruby 
+$:.unshift('../lib')
+$:.unshift('../ext')
+require 'benchmark'
+require 'gslng'
+require 'rbgsl'
+require 'narray'
+include Benchmark
+
+puts '#################################### Vector ####################################'
+
+n=500000
+size = 50000
+puts "Vector#[]"
+bmbm do |x|
+  v = GSLng::Vector.random(size)
+  gv = GSL::Vector.alloc(v.to_a)
+  x.report("rb-gsl :") {n.times {i=rand(size); gv[i]}}
+  x.report("GSLng  :") {n.times {i=rand(size); v[i]}}
+end
+puts
+
+n = 100
+size = 5000
+puts "Vector#each - vector of #{size} elements"
+bmbm do |x|
+  v = GSLng::Vector.zero(size)
+  gv = GSL::Vector.alloc(v.to_a)
+  x.report("rb-gsl :") {n.times {s = 0; gv.each do |e| s += e end}}
+  x.report("GSLng  :") {n.times {s = 0; v.each do |e| s += e end}}
+end
+puts
+
+n = 500
+size = 50000
+puts "Norm (BLAS) - vector of #{size} elements"
+bmbm do |x|
+  v = GSLng::Vector.random(size)
+  gv = GSL::Vector.alloc(v.to_a)
+  x.report("rb-gsl :") {n.times {gv.dnrm2}}
+  x.report("GSLng  :") {n.times {v.norm}}
+end
+puts
+
+n=10
+size = 50000
+puts "Vector#map!"
+bmbm do |x|
+  v = GSLng::Vector.random(size)
+  gv = GSL::Vector.alloc(v.to_a)
+  i = rand(size)
+  l = lambda{|e| rand}
+  x.report("rb-gsl :") {n.times {gv.collect!{|e| rand}}}
+  x.report("GSLng  :") {n.times {v.map!{|e| rand}}}
+end
+puts
+
+
+n=5000
+size = 5000
+puts "Vector product - two vectors of #{size} elements"
+bmbm do |x|
+  v,v2 = GSLng::Vector.random(size),GSLng::Vector.random(size)
+  gv,gv2 = GSL::Vector.alloc(v.to_a),GSL::Vector.alloc(v2.to_a)
+  x.report("rb-gsl :") {n.times {gv.mul!(gv2)}}
+  x.report("GSLng  :") {n.times {v.mul!(v2)}}
+end
+puts
+
+n=500
+size = 5000
+puts "Sort - vector of #{size} elements"
+bmbm do |x|
+  v = GSLng::Vector.random(size)
+  gv = GSL::Vector.alloc(v.to_a)
+  x.report("rb-gsl :") {n.times {gv.sort!}}
+  x.report("GSLng  :") {n.times {v.sort!}}
+end
+puts
+
+n=500
+size = 5000
+puts "Vector#to_a"
+bmbm do |x|
+  v = GSLng::Vector.random(size)
+  gv = GSL::Vector.alloc(v.to_a)
+  x.report("rb-gsl :") {n.times {gv.to_a}}
+  x.report("GSLng  :") {n.times {v.to_a}}
+end
+puts
+
+n=500
+size = 50000
+puts "Vector::from_array"
+bmbm do |x|
+  a = Array.new(size) { rand }
+  x.report("rb-gsl :") {n.times {GSL::Vector.alloc(a)}}
+  x.report("GSLng  :") {n.times {GSLng::Vector.from_array(a)}}
+end
+puts
+
+puts '#################################### Matrix ####################################'
+
+n=500000
+size = 50
+puts "Matrix#[] - 50 x 50"
+bmbm do |x|
+  v = GSLng::Matrix.random(size, size)
+  gv = GSL::Matrix.alloc(size, size)
+  x.report("rb-gsl :") {n.times {i,j=rand(size),rand(size); gv[i,j]}}
+  x.report("GSLng  :") {n.times {i,j=rand(size),rand(size); v[i,j]}}
+end
+puts

data/test/benchmark_results

@@ -0,0 +1,92 @@
+#################################### Vector ####################################
+Vector#[]
+Rehearsal --------------------------------------------
+rb-gsl :   0.300000   0.000000   0.300000 (  0.301650)
+GSLng  :   0.360000   0.000000   0.360000 (  0.369323)
+----------------------------------- total: 0.660000sec
+
+               user     system      total        real
+rb-gsl :   0.310000   0.000000   0.310000 (  0.387314)
+GSLng  :   0.340000   0.000000   0.340000 (  0.348130)
+
+Vector#each - vector of 5000 elements
+Rehearsal --------------------------------------------
+rb-gsl :   0.220000   0.000000   0.220000 (  0.218779)
+GSLng  :   0.200000   0.000000   0.200000 (  0.205919)
+----------------------------------- total: 0.420000sec
+
+               user     system      total        real
+rb-gsl :   0.220000   0.000000   0.220000 (  0.231055)
+GSLng  :   0.200000   0.000000   0.200000 (  0.203754)
+
+Norm (BLAS) - vector of 50000 elements
+Rehearsal --------------------------------------------
+rb-gsl :   0.520000   0.000000   0.520000 (  0.521935)
+GSLng  :   0.520000   0.000000   0.520000 (  0.521729)
+----------------------------------- total: 1.040000sec
+
+               user     system      total        real
+rb-gsl :   0.520000   0.000000   0.520000 (  0.521828)
+GSLng  :   0.520000   0.000000   0.520000 (  0.521704)
+
+Vector#map!
+Rehearsal --------------------------------------------
+rb-gsl :   0.240000   0.000000   0.240000 (  0.239012)
+GSLng  :   0.260000   0.000000   0.260000 (  0.259632)
+----------------------------------- total: 0.500000sec
+
+               user     system      total        real
+rb-gsl :   0.250000   0.000000   0.250000 (  0.245187)
+GSLng  :   0.240000   0.000000   0.240000 (  0.235865)
+
+Vector product - two vectors of 5000 elements
+Rehearsal --------------------------------------------
+rb-gsl :   0.620000   0.000000   0.620000 (  0.655681)
+GSLng  :   0.620000   0.010000   0.630000 (  0.652757)
+----------------------------------- total: 1.250000sec
+
+               user     system      total        real
+rb-gsl :   1.170000   0.000000   1.170000 (  1.178990)
+GSLng  :   1.170000   0.000000   1.170000 (  1.172545)
+
+Sort - vector of 5000 elements
+Rehearsal --------------------------------------------
+rb-gsl :   0.440000   0.000000   0.440000 (  0.441440)
+GSLng  :   0.440000   0.000000   0.440000 (  0.444755)
+----------------------------------- total: 0.880000sec
+
+               user     system      total        real
+rb-gsl :   0.430000   0.000000   0.430000 (  0.440950)
+GSLng  :   0.450000   0.010000   0.460000 (  0.447733)
+
+Vector#to_a
+Rehearsal --------------------------------------------
+rb-gsl :   0.470000   0.000000   0.470000 (  0.490407)
+GSLng  :   0.470000   0.000000   0.470000 (  0.472971)
+----------------------------------- total: 0.940000sec
+
+               user     system      total        real
+rb-gsl :   0.450000   0.000000   0.450000 (  0.452365)
+GSLng  :   0.460000   0.000000   0.460000 (  0.450768)
+
+Vector::from_array
+Rehearsal --------------------------------------------
+rb-gsl :   0.730000   0.140000   0.870000 (  0.868696)
+GSLng  :   0.650000   0.160000   0.810000 (  0.811343)
+----------------------------------- total: 1.680000sec
+
+               user     system      total        real
+rb-gsl :   0.730000   0.000000   0.730000 (  0.727155)
+GSLng  :   0.650000   0.000000   0.650000 (  0.644819)
+
+#################################### Matrix ####################################
+Matrix#[] - 50 x 50
+Rehearsal --------------------------------------------
+rb-gsl :   0.380000   0.080000   0.460000 (  0.455793)
+GSLng  :   0.530000   0.000000   0.530000 (  0.542278)
+----------------------------------- total: 0.990000sec
+
+               user     system      total        real
+rb-gsl :   0.360000   0.000000   0.360000 (  0.367216)
+GSLng  :   0.510000   0.000000   0.510000 (  0.510689)
+

data/test/matrix_test.rb

@@ -0,0 +1,145 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'..','ext')
+
+require 'test/unit'
+require 'gslng'
+
+include GSLng
+
+class TestMatrix < Test::Unit::TestCase
+  def test_initialize
+		assert_equal([5,5], Matrix.new(5,5).size)
+		assert_equal([5,5], Matrix.zero(5,5).size)
+		assert(Matrix.zero(5,5).zero?)
+		assert_nothing_raised { Matrix.random(5,5) }
+	end
+
+  def test_to_s
+    assert_equal("[0.0 0.0 0.0]", Matrix[0, 0, 0].to_s)
+    assert_equal("[0.0 1.0 2.0]", Matrix[0,1,2].to_s)
+    assert_equal("[1.0 2.0 3.0;\n 2.0 3.0 4.0]", Matrix[[1,2,3],[2,3,4]].to_s)
+    assert_equal("0.0 0.0 0.0", Matrix[0, 0, 0].join(' '))
+    assert_equal("1.0 2.0 3.0 2.0 3.0 4.0", Matrix[[1,2,3],[2,3,4]].join(' '))
+  end
+  
+  def test_to_a
+    assert_equal([[0.0, 0.0, 0.0]], Matrix[0, 0, 0].to_a)
+    assert_equal([[0.0, 1.0, 2.0]], Matrix[0,1,2].to_a)
+    assert_equal([[1.0, 2.0, 3.0],[2.0, 3.0, 4.0]], Matrix[[1,2,3],[2,3,4]].to_a)
+  end
+
+  def test_equal
+    assert_equal(Matrix[0, 0, 0], Matrix[0, 0, 0])
+    assert_equal(Matrix[[1,2,3],[2,3,4]], Matrix[[1,2,3],[2,3,4]])
+    m = Matrix[[1,2,3],[2,3,4]]
+    assert_equal(m, m.dup)
+    assert_equal(Matrix[0,1,2], Matrix[0...3])
+    assert_equal(Matrix[[0,1,2],[1,2,3]], Matrix[0...3,1...4])
+  end
+
+	def test_set_get
+    m = Matrix[[1,2,3],[2,3,4]]
+    m[0,0] = 3
+    assert_equal(Matrix[[3,2,3],[2,3,4]], m)
+    assert_equal(2, m[1,0])
+	end
+
+  def test_each
+    m = Matrix[[1,2,3],[3,4,5]]
+    a = []
+    m.each {|e| a << e}
+    assert_equal([1,2,3,3,4,5], a)
+    a = []
+    m.each {|e| a << e}
+    assert_equal([1,2,3,3,4,5], a)
+    a = []
+    m.each_row {|r| r.each {|e| a << e}}
+    assert_equal([1,2,3,3,4,5], a)
+    a = []
+    m.each_column {|c| c.each {|e| a << e}}
+    assert_equal([1,3,2,4,3,5], a)
+    a = []
+    m.each_vec_row {|r| r.each {|e| a << e}}
+    assert_equal([1,2,3,3,4,5], a)
+    a = []
+    m.each_vec_column {|c| c.each {|e| a << e}}
+    assert_equal([1,3,2,4,3,5], a)
+  end
+
+  def test_complex_get
+    m = Matrix[[1,2,3],[2,3,4]]
+    assert_equal(m, m[:*,:*])
+    assert_equal(Matrix[1, 2, 3], m[0,:*])
+    assert_equal(Matrix[2, 3, 4], m[1,:*])
+    assert_equal(Matrix[1, 2], m[:*,0])
+    assert_equal(Matrix[2, 3], m[:*,1])
+    assert_equal(Matrix[3, 4], m[:*,2])
+  end
+
+  def test_complex_set
+    m = Matrix[[1,2,3],[2,3,4]]
+    m[0,:*] = 1
+    assert_equal(Matrix[[1,1,1],[2,3,4]], m)
+    m[0,:*] = Vector[1,2,4]
+    assert_equal(Matrix[[1,2,4],[2,3,4]], m)
+
+    m[:*,0] = 1
+    assert_equal(Matrix[[1,2,4],[1,3,4]], m)
+    m[:*,0] = Vector[1,2]
+    assert_equal(Matrix[[1,2,4],[2,3,4]], m)
+
+    m[:*,:*] = 1
+    assert_equal(Matrix[[1,1,1],[1,1,1]], m)
+  end
+
+	def test_operators
+		assert_equal(Matrix[[1,4,3],[2,4,4]],Matrix[[1,2,3],[2,3,4]] + Matrix[[0,2,0],[0,1,0]])
+    assert_equal(Matrix[[1.5,2.5,3.5],[2.5,3.5,4.5]],Matrix[[1,2,3],[2,3,4]] + 0.5)
+    assert_equal(Matrix[[1.5,2.5,3.5],[2.5,3.5,4.5]],0.5 + Matrix[[1,2,3],[2,3,4]])
+
+    assert_equal(Matrix[[0,2,0],[0,4,0],[0,6,0]],Matrix[1,2,3].transpose * Vector[0,2,0])
+    assert_equal(Matrix[[4],[6]],Matrix[[1,2,3],[2,3,4]] * Vector[0,2,0].transpose)
+    assert_equal(Matrix[4, 6],Vector[0,2,0] * Matrix[[1,2],[2,3],[4,5]])
+    assert_equal(Matrix[[3,6],[9,12]],Matrix[[1,2],[3,4]] * 3)
+
+    assert_equal(Matrix[[4,6],[2,3]],Matrix[[0,2,0],[0,1,0]] * Matrix[[1,2],[2,3],[4,5]])
+    assert_equal(Matrix[[0,4,0],[0,1,0]],Matrix[[0,2,0],[0,1,0]] ^ Matrix[[0,2,0],[0,1,0]])
+	end
+
+  def test_swaps
+    m = Matrix[[1,2,3],[2,3,4],[3,4,5]]
+    assert_equal(Matrix[[2,3,4],[1,2,3],[3,4,5]], m.swap_rows(0,1))
+    assert_equal(Matrix[[3,2,4],[2,1,3],[4,3,5]], m.swap_columns(0,1))
+    assert_equal(Matrix[[3,2,4],[2,1,3],[4,3,5]], m.swap_rowcol(0,0))
+
+    m = Matrix[[1,2,3],[4,5,6],[7,8,9]]
+    assert_equal(Matrix[[0, 0, 0],[0, 1, 2],[0, 4, 5]], m.slide(1, 1))
+
+    m = Matrix[[1,2,3],[4,5,6],[7,8,9]]
+    assert_equal(Matrix[[5, 6, 0],[8, 9, 0],[0, 0, 0]], m.slide(-1, -1))
+
+    m = Matrix[[1,2,3],[4,5,6],[7,8,9]]
+    assert_equal(Matrix[[4, 5, 6],[7, 8, 9],[0, 0, 0]], m.slide(-1, 0))
+  end
+
+  def test_view
+    m,view = nil,nil
+    assert_nothing_raised {
+      m = Matrix[[1,2,3],[2,3,4]]
+      view = m.view
+      view[0,0] = 3
+    }
+    assert_equal(Matrix[[3,2,3],[2,3,4]], m)
+    assert_equal(Matrix[[3,2,3],[2,3,4]], view)
+    assert_equal(Matrix[3,4], m.view(1, 1))
+    assert_equal(Matrix[3,2], m.view(0, 0, nil, 1).transpose)
+    assert_equal(Matrix[[3],[2]], m.column_view(0))
+    assert_equal(Matrix[3,2,3], m.row_view(0))
+  end
+
+  def test_map
+    m = Matrix[[1,2,3],[2,3,4]]
+    assert_equal([['1.0','2.0','3.0'],['2.0','3.0','4.0']], m.map_array {|e| e.to_s})
+    assert_equal(Matrix[[2,3,4],[3,4,5]], m.map {|e| e+1})
+  end
+end

data/test/rng_test.rb

@@ -0,0 +1,27 @@
+# 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 'gslng'
+include GSLng
+
+class RNGTest < Test::Unit::TestCase
+  def test_rng
+    RNG.new
+  end
+
+  def test_uniform
+    three_epsilon = Vector.new(3).fill!(Float::EPSILON)
+    uniform = RNG::Uniform.new(0, 2)
+    assert(Vector[1.99948349781334, 0.325819750782102, 0.56523561058566] - Vector.new(3) { uniform.sample } <= three_epsilon)
+  end
+
+  def test_gaussian
+    three_epsilon = Vector.new(3).fill!(Float::EPSILON)
+    gaussian = RNG::Gaussian.new
+    assert(Vector[0.133918608118676, -0.0881009918314384, 1.67440840625377] - Vector.new(3) { gaussian.sample } <= three_epsilon)
+  end
+end