vector_sse 0.0.1.pre

data/spec/vector_mat_spec.rb

@@ -0,0 +1,374 @@
+begin
+   require 'vector_sse'
+rescue StandardError => e
+   # vector_sse is not installed as a gem
+   require File.join( '..', 'lib', 'vector_sse' )
+end
+
+RSpec.describe VectorSSE::Mat do
+
+   describe "constructor" do
+
+      it "raises exception on invalid type" do
+         expect {
+            VectorSSE::Mat.new( VectorSSE::Type::INVALID, 2, 1 )
+         }.to raise_error ArgumentError, "invalid SSE matrix type for argument 0"
+      end
+
+      it "raises exception on invalid row dimension" do
+         expect {
+            VectorSSE::Mat.new( VectorSSE::Type::S32, 0, 1 )
+         }.to raise_error ArgumentError, "row count must be greater than zero for argument 1"
+      end
+
+      it "raises exception on invalid column dimension" do
+         expect {
+            VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 0 )
+         }.to raise_error ArgumentError, "column count must be greater than zero for argument 2"
+      end
+
+      it "initializes with correct type and dimensions" do
+         mat = VectorSSE::Mat.new( VectorSSE::Type::S32, 10, 8 )
+         expect( mat.type ).to eq( VectorSSE::Type::S32 )
+         expect( mat.rows ).to eq( 10 )
+         expect( mat.cols ).to eq( 8 )
+      end
+
+      it "initializes all elements to zero" do
+         mat = VectorSSE::Mat.new( VectorSSE::Type::S32, 4, 2 )
+         8.times do |index|
+            expect( mat[ index ] ).to eq( 0 )
+         end
+      end
+
+   end
+
+   describe "attributes" do
+      it "raises exception on attempt to access protected field" do
+         expect {
+            mat = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 4 )
+            protected_data = mat.data
+         }.to raise_error NoMethodError
+         expect {
+            mat = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 4 )
+            mat.data = []
+         }.to raise_error NoMethodError
+      end
+   end
+
+   describe "read element" do
+
+      mat = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 4 )
+      mat.fill([
+         1, 2, 3, 4,
+         5, 6, 7, 8
+      ])
+
+      it "raises exception on invalid row with 'at' reader" do
+         expect {
+            mat.at( -1, 0 )
+         }.to raise_error "row index out of bounds"
+         expect {
+            mat.at( 2, 0 )
+         }.to raise_error "row index out of bounds"
+      end
+
+      it "raises exception on invalid column with 'at' reader" do
+         expect {
+            mat.at( 0, -1 )
+         }.to raise_error "column index out of bounds"
+         expect {
+            mat.at( 0, 4 )
+         }.to raise_error "column index out of bounds"
+      end
+
+      it "raises exception on invalid index with '[]' reader" do
+         expect {
+            mat[ -1 ]
+         }.to raise_error "index out of bounds"
+         expect {
+            mat[ 8 ]
+         }.to raise_error "index out of bounds"
+      end
+
+      it "returns value from correct row/col location with 'at' reader" do
+         expect( mat.at( 1, 2) ).to eq( 7 )
+      end
+
+      it "returns value from correct index with '[]' reader" do
+         expect( mat[ 6 ] ).to eq( 7 )
+      end
+   end
+
+   describe "write element" do
+      mat = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 4 )
+
+      it "raises exception on invalid row with 'set' writer" do
+         expect {
+            mat.set( -1, 0, 0 )
+         }.to raise_error "row index out of bounds"
+         expect {
+            mat.set( 2, 0, 0 )
+         }.to raise_error "row index out of bounds"
+      end
+
+      it "raises exception on invalid column with 'set' writer" do
+         expect {
+            mat.set( 0, -1, 0 )
+         }.to raise_error "column index out of bounds"
+         expect {
+            mat.set( 0, 4, 0 )
+         }.to raise_error "column index out of bounds"
+      end
+
+      it "raises exception on invalid index with '[]=' write" do
+         expect {
+            mat[ -1 ] = 0
+         }.to raise_error "index out of bounds"
+         expect {
+            mat[ 8 ] = 0
+         }.to raise_error "index out of bounds"
+      end
+
+      it "sets value at correct row/col location with 'set' writer" do
+         mat.set( 1, 2, 7 )
+         expect( mat.at( 1, 2) ).to eq( 7 )
+      end
+
+      it "sets value at correct index with '[]=' writer" do
+         mat[ 3 ] = 4
+         expect( mat[ 3 ] ).to eq( 4 )
+      end
+   end
+
+   describe "to string" do
+      it "renders matrix as string" do
+         mat = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 4 )
+         mat.fill([
+            1, 2, 3, 4,
+            5, 6, 7, 8
+         ])
+
+         expect( mat.to_s ).to eq( "|1 2 3 4|\n|5 6 7 8|\n" )
+      end
+   end
+
+   describe "matrix addition and subtraction" do
+      it "raises exception if the addends are not of equal size" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         left.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+         right = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 1 )
+         right.fill([
+            1,
+            2
+         ])
+
+         expect {
+            left + right
+         }.to raise_error ArgumentError, "matrix addition requires operands of equal size"
+
+         expect {
+            left - right
+         }.to raise_error ArgumentError, "matrix subtraction requires operands of equal size"
+      end
+
+      it "returns correct sum" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         left.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+         right = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         right.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+
+         result = left + right
+         expect( result.type ).to eq( left.type )
+         expect( result.rows ).to eq( left.rows )
+         expect( result.cols ).to eq( left.cols )
+
+         [  2,  4,
+            6,  8,
+           10, 12 ].each_with_index do |value,index|
+            expect( result[ index ] ).to eq( value )
+         end
+
+         result = left - right
+         expect( result.type ).to eq( left.type )
+         expect( result.rows ).to eq( left.rows )
+         expect( result.cols ).to eq( left.cols )
+
+         [  0, 0,
+            0, 0,
+            0, 0 ].each_with_index do |value,index|
+            expect( result[ index ] ).to eq( value )
+         end
+      end
+
+      it "returns correct sum when added to self" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         left.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+
+         result = left + left
+         expect( result.type ).to eq( left.type )
+         expect( result.rows ).to eq( left.rows )
+         expect( result.cols ).to eq( left.cols )
+
+         [  2,  4,
+            6,  8,
+           10, 12 ].each_with_index do |value,index|
+            expect( result[ index ] ).to eq( value )
+         end
+      end
+
+      it "returns correct sum when added and assigned to self" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         left.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+         right = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         right.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+
+         left += right
+         expect( left.type ).to eq( VectorSSE::Type::S32 )
+         expect( left.rows ).to eq( 3 )
+         expect( left.cols ).to eq( 2 )
+
+         [  2,  4,
+            6,  8,
+           10, 12 ].each_with_index do |value,index|
+            expect( left[ index ] ).to eq( value )
+         end
+      end
+   end
+
+   describe "matrix multiplication" do
+      it "raises exception for invalid argument" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 2 )
+         right = "this is not a matrix"
+
+         expect {
+            left * right
+         }.to raise_error ArgumentError, "expected argument of type VectorSSE::Mat for argument 0"
+      end
+
+      it "raises exception on invalid factor dimensions" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 2 )
+         right = VectorSSE::Mat.new( VectorSSE::Type::S32, 1, 2 )
+
+         expect {
+            left * right
+         }.to raise_error "invalid matrix dimensions"
+      end
+
+      it "returns correct signed 32-bit result" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         left.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+         right = VectorSSE::Mat.new( VectorSSE::Type::S32, 2, 1 )
+         right.fill([
+            1,
+            2
+         ])
+
+         result = left * right
+         expect( result.type ).to eq( left.type )
+         expect( result.rows ).to eq( left.rows )
+         expect( result.cols ).to eq( right.cols )
+
+         [ 5, 11, 17 ].each_with_index do |value,index|
+            expect( result[ index ] ).to eq( value )
+         end
+      end
+
+      it "returns result with same type as left factor" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::S32, 3, 2 )
+         left.fill([
+            1, 2,
+            3, 4,
+            5, 6
+         ])
+         right = VectorSSE::Mat.new( VectorSSE::Type::F32, 2, 1 )
+         right.fill([
+            1.9,
+            2.3
+         ])
+
+         result = left * right
+         expect( result.type ).to eq( left.type )
+         expect( result.rows ).to eq( left.rows )
+         expect( result.cols ).to eq( right.cols )
+
+         [ 5, 11, 17 ].each_with_index do |value,index|
+            expect( result[ index ] ).to eq( value )
+         end
+      end
+
+      it "returns correct float 32-bit product" do
+         left = VectorSSE::Mat.new( VectorSSE::Type::F32, 3, 2 )
+         left.fill([
+            1.2, 2.3,
+            3.4, 4.5,
+            5.6, 6.7
+         ])
+         right = VectorSSE::Mat.new( VectorSSE::Type::F32, 2, 1 )
+         right.fill([
+            1.9,
+            2.3
+         ])
+
+         result = left * right
+         expect( result.type ).to eq( VectorSSE::Type::F32 )
+         expect( result.rows ).to eq( left.rows )
+         expect( result.cols ).to eq( right.cols )
+
+         [  1.2 * 1.9 + 2.3 * 2.3,
+            3.4 * 1.9 + 4.5 * 2.3,
+            5.6 * 1.9 + 6.7 * 2.3 ].each_with_index do |value,index|
+            expect( result[ index ] ).to be_within( 1e-6 ).of( value )
+         end
+      end
+
+      it "returns sum of matrix and scalar" do
+         original_values = [
+            1.2, 2.3,
+            3.4, 4.5,
+            5.6, 6.7
+         ]
+
+         scalar_value = 1.1
+
+         left = VectorSSE::Mat.new( VectorSSE::Type::F32, 3, 2 )
+         left.fill( original_values )
+
+         left -= scalar_value
+
+         original_values.each_with_index do |value,index|
+            expected_value = value - scalar_value
+            expect( left[ index ] ).to be_within( 1e-6 ).of( expected_value )
+         end
+      end
+   end
+
+end

data/spec/vector_vec_spec.rb

@@ -0,0 +1,150 @@
+begin
+   require 'vector_sse'
+rescue StandardError => e
+   # vector_sse is not installed as a gem
+   require File.join( '..', 'lib', 'vector_sse' )
+end
+
+RSpec.describe VectorSSE::Array do
+
+   describe "constructor" do
+   end
+
+   describe "element insertion" do
+
+      it "rejects insertion of invalid data types" do
+         arr = VectorSSE::Array.new( VectorSSE::Type::S32 )
+
+         expect {
+            arr << "not a valid data type"
+         }.to raise_error ArgumentError
+
+         expect {
+            arr.insert( 0, [ 1, "not a valid data type" ] )
+         }.to raise_error ArgumentError
+
+         expect {
+            arr[ 0 ] = "not a valid data type"
+         }.to raise_error ArgumentError        
+      end
+   end
+
+   describe "vector addition" do
+      it "returns difference between vectors" do
+         left = VectorSSE::Array.new( VectorSSE::Type::S32 )
+         left.replace [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
+         right = VectorSSE::Array.new( VectorSSE::Type::S32 )
+         right.replace [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
+
+         result = left - right
+         expect( result.type ).to eq( left.type )
+         expect( result.length ).to eq( left.length )
+
+         [ 9, 7, 5, 3, 1, -1, -3, -5, -7, -9 ].each_with_index do |value,index|
+            expect( result[ index ] ).to eq( value )
+         end
+      end
+
+      it "returns difference after subtracting scalar Fixnum" do
+         left = VectorSSE::Array.new( VectorSSE::Type::S32 )
+         left.replace [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
+
+         left -= 2
+
+         expect( left.type ).to eq( VectorSSE::Type::S32 )
+         expect( left.length ).to eq( 10 )
+
+         [ 8, 7, 6, 5, 4, 3, 2, 1, 0, -1 ].each_with_index do |value,index|
+            expect( left[ index ] ).to eq( value )
+         end
+      end
+
+      it "returns difference after subtracting scalar Float" do
+
+         values = [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
+         scalar_value = 2.8
+
+         left = VectorSSE::Array.new( VectorSSE::Type::F32 )
+         left.replace values
+
+         left -= scalar_value
+
+         expect( left.type ).to eq( VectorSSE::Type::F32 )
+         expect( left.length ).to eq( 10 )
+
+         values.each_with_index do |value,index|
+            expected_value = value - scalar_value
+            expect( left[ index ] ).to be_within( 1e-6 ).of( expected_value )
+         end
+      end
+   end
+
+   describe "scalar vector multiplication" do
+
+      it "performs scalar multiplication when right factor is scalar integer" do
+         data = [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
+         scalar_value = -2
+
+         left = VectorSSE::Array.new( VectorSSE::Type::S32 )
+         left.replace data
+
+         left *= scalar_value
+
+         expect( left.length ).to eq( data.length )
+         data.each_with_index do |value,index|
+            expect( left[ index ] ).to eq( value * scalar_value )
+         end
+
+      end
+
+      it "performs scalar multiplication when right factor is 64-bit scalar integer" do
+         data = [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
+         scalar_value = -2
+
+         left = VectorSSE::Array.new( VectorSSE::Type::S64 )
+         left.replace data
+
+         left *= scalar_value
+
+         expect( left.length ).to eq( data.length )
+         data.each_with_index do |value,index|
+            expect( left[ index ] ).to eq( value * scalar_value )
+         end
+
+      end
+
+      it "performs scalar multiplication when right factor is scalar float" do
+         data = [ 10.1, 9.2, 8.3, 7.4, 6.5, 5.6, 4.7, 3.8, 2.9, 1.93 ]
+         scalar_value = -2.2
+
+         left = VectorSSE::Array.new( VectorSSE::Type::F32 )
+         left.replace data
+
+         left *= scalar_value
+
+         expect( left.length ).to eq( data.length )
+         data.each_with_index do |value,index|
+            expect( left[ index ] ).to be_within( 2e-6 ).of( value * scalar_value )
+         end
+
+      end
+
+      it "performs scalar multiplication when right factor is scalar double" do
+         data = [ 10.1, 9.2, 8.3, 7.4, 6.5, 5.6, 4.7, 3.8, 2.9, 1.93 ]
+         scalar_value = -2.2
+
+         left = VectorSSE::Array.new( VectorSSE::Type::F64 )
+         left.replace data
+
+         left *= scalar_value
+
+         expect( left.length ).to eq( data.length )
+         data.each_with_index do |value,index|
+            expect( left[ index ] ).to be_within( 1e-6 ).of( value * scalar_value )
+         end
+
+      end
+
+   end
+
+end

data/vector_sse.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require_relative 'lib/vector_sse'
+
+Gem::Specification.new do |s|
+   s.name        = 'vector_sse'
+   s.version     = VectorSSE::VERSION
+   s.date        = '2015-12-28'
+   s.summary     = "SIMD accelerated vector and matrix operations"
+   s.description = "VectorSse employs x86 Streaming SIMD Extensions (SSE), v3 or greater, to accelerate basic vector and matrix computations in Ruby."
+   s.authors     = [ "Robert Glissmann" ]
+   s.email       = 'Robert.Glissmann@gmail.com'
+   s.files       = `git ls-files`.split("\n")
+   s.extensions  = %w[ext/vector_sse/extconf.rb]
+   s.licenses    = ['BSD']
+   s.homepage    = 'https://github.com/rgmann/vector_sse'
+
+   s.add_development_dependency 'rake-compiler', '~> 0.9.5'
+   s.add_development_dependency 'rspec', '~> 3.1.0'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: vector_sse
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- Robert Glissmann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: VectorSse employs x86 Streaming SIMD Extensions (SSE), v3 or greater,
+  to accelerate basic vector and matrix computations in Ruby.
+email: Robert.Glissmann@gmail.com
+executables: []
+extensions:
+- ext/vector_sse/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/vector_sse/.gitignore
+- ext/vector_sse/extconf.rb
+- ext/vector_sse/vector_sse.c
+- ext/vector_sse/vector_sse_add.c
+- ext/vector_sse/vector_sse_add.h
+- ext/vector_sse/vector_sse_mul.c
+- ext/vector_sse/vector_sse_mul.h
+- ext/vector_sse/vector_sse_sum.c
+- ext/vector_sse/vector_sse_sum.h
+- ext/vector_sse/vector_sse_vec_mul.c
+- ext/vector_sse/vector_sse_vec_mul.h
+- lib/.gitignore
+- lib/vector_sse.rb
+- spec/vector_mat_spec.rb
+- spec/vector_vec_spec.rb
+- vector_sse.gemspec
+homepage: https://github.com/rgmann/vector_sse
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: SIMD accelerated vector and matrix operations
+test_files: []