nmatrix 0.0.1 → 0.0.2

data/spec/slice_spec.rb

@@ -0,0 +1,257 @@
+# = NMatrix
+#
+# A linear algebra library for scientific computation in Ruby.
+# NMatrix is part of SciRuby.
+#
+# NMatrix was originally inspired by and derived from NArray, by
+# Masahiro Tanaka: http://narray.rubyforge.org
+#
+# == Copyright Information
+#
+# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+#
+# Please see LICENSE.txt for additional copyright notices.
+#
+# == Contributing
+#
+# By contributing source code to SciRuby, you agree to be bound by
+# our Contributor Agreement:
+#
+# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+#
+# == slec_spec.rb
+#
+# Test of slice operations. 
+#
+require File.dirname(__FILE__) + "/spec_helper.rb"
+
+describe "Slice operation" do
+  [:dense, :list, :yale].each do |stype|
+  context "for #{stype}" do
+    before :each do
+      @m = create_matrix(stype)
+    end
+
+    unless stype == :yale
+    it "should have #is_ref? method" do
+      a = @m[0..1, 0..1]
+      b = @m.slice(0..1, 0..1)
+
+
+      @m.is_ref?.should be_false
+      a.is_ref?.should be_true
+      b.is_ref?.should be_false
+    end
+
+    it "reference should compare with non-reference" do
+      @m.slice(1..2,0..1).should == @m[1..2, 0..1]
+      @m[1..2,0..1].should == @m.slice(1..2, 0..1)
+      @m[1..2,0..1].should == @m[1..2, 0..1]
+    end
+    end # unless stype == :yale
+
+    context "with copying" do
+      it 'should return an NMatrix' do
+        n = @m.slice(0..1,0..1)
+        nm_eql(n, NMatrix.new([2,2], [0,1,3,4], :int32)).should be_true
+      end
+
+      it 'should return a copy of 2x2 matrix to self elements' do
+        n = @m.slice(1..2,0..1)
+        n.shape.should eql([2,2])
+
+        n[1,1].should == @m[2,1]
+        n[1,1] = -9
+        @m[2,1].should eql(7)
+      end
+
+      it 'should return a 1x2 matrix with refs to self elements' do
+        n = @m.slice(0,1..2)
+        n.shape.should eql([1,2])
+
+        n[0,0].should == @m[0,1]
+        n[0,0] = -9
+        @m[0,1].should eql(1)
+      end
+
+      it 'should return a 2x1 matrix with refs to self elements' do
+        n = @m.slice(0..1,1)
+        n.shape.should eql([2,1])
+
+        n[0,0].should == @m[0,1]
+        n[0,0] = -9
+        @m[0,1].should eql(1)
+      end
+
+      it 'should be correct slice for range 0..2 and 0...3' do
+        @m.slice(0..2,0..2).should == @m.slice(0...3,0...3)
+      end
+    
+      [:dense, :list, :yale].each do |cast_type|
+        it "should cast from #{stype.upcase} to #{cast_type.upcase}" do
+          nm_eql(@m.slice(1..2, 1..2).cast(cast_type, :int32), @m.slice(1..2,1..2)).should be_true
+          nm_eql(@m.slice(0..1, 1..2).cast(cast_type, :int32), @m.slice(0..1,1..2)).should be_true
+          nm_eql(@m.slice(1..2, 0..1).cast(cast_type, :int32), @m.slice(1..2,0..1)).should be_true
+          nm_eql(@m.slice(0..1, 0..1).cast(cast_type, :int32), @m.slice(0..1,0..1)).should be_true
+
+          # Non square
+          nm_eql(@m.slice(0..2, 1..2).cast(cast_type, :int32), @m.slice(0..2,1..2)).should be_true
+          nm_eql(@m.slice(1..2, 0..2).cast(cast_type, :int32), @m.slice(1..2,0..2)).should be_true
+
+          # Full
+          nm_eql(@m.slice(0..2, 0..2).cast(cast_type, :int32), @m).should be_true
+        end
+      end
+    end
+
+    if stype == :yale
+    context "by reference" do
+      it "should be raise error" do
+        expect{ @m[1..2,1..2] }.to raise_error(NotImplementedError)
+      end
+    end
+    else
+    context "by reference" do
+      it 'should return an NMatrix' do
+        n = @m[0..1,0..1]
+        nm_eql(n, NMatrix.new([2,2], [0,1,3,4], :int32)).should be_true
+      end
+
+      it 'should return a 2x2 matrix with refs to self elements' do
+        n = @m[1..2,0..1]
+        n.shape.should eql([2,2])
+
+        n[0,0].should == @m[1,0]
+        n[0,0] = -9
+        @m[1,0].should eql(-9)
+      end
+
+      it 'should return a 1x2 matrix with refs to self elements' do
+        n = @m[0,1..2]
+        n.shape.should eql([1,2])
+
+        n[0,0].should == @m[0,1]
+        n[0,0] = -9
+        @m[0,1].should eql(-9)
+      end
+
+      it 'should return a 2x1 matrix with refs to self elements' do
+        n = @m[0..1,1]
+        n.shape.should eql([2,1])
+
+        n[0,0].should == @m[0,1]
+        n[0,0] = -9
+        @m[0,1].should eql(-9)
+      end
+
+      it 'should set value from NMatrix'
+
+      it 'should slice again' do
+        n = @m[1..2, 1..2]
+        nm_eql(n[1,0..1], NMatrix.new([1,2], [7,8])).should be_true
+      end
+
+      it 'should be correct slice for range 0..2 and 0...3' do
+        @m[0..2,0..2].should == @m[0...3,0...3]
+      end
+
+      if stype == :dense
+        [:byte,:int8,:int16,:int32,:int64,:float32,:float64,:rational64,:rational128].each do |left_dtype|
+          [:byte,:int8,:int16,:int32,:int64,:float32,:float64,:rational64,:rational128].each do |right_dtype|
+
+            # Won't work if they're both 1-byte, due to overflow.
+            next if [:byte,:int8].include?(left_dtype) && [:byte,:int8].include?(right_dtype)
+
+            # For now, don't bother testing int-int mult.
+            #next if [:int8,:int16,:int32,:int64].include?(left_dtype) && [:int8,:int16,:int32,:int64].include?(right_dtype)
+            it "handles #{left_dtype.to_s} dot #{right_dtype.to_s} matrix multiplication" do
+              #STDERR.puts "dtype=#{dtype.to_s}"
+              #STDERR.puts "2"
+
+              nary = if left_dtype.to_s =~ /complex/
+                       COMPLEX_MATRIX43A_ARRAY
+                     elsif left_dtype.to_s =~ /rational/
+                       RATIONAL_MATRIX43A_ARRAY
+                     else
+                       MATRIX43A_ARRAY
+                     end
+
+              mary = if right_dtype.to_s =~ /complex/
+                       COMPLEX_MATRIX32A_ARRAY
+                     elsif right_dtype.to_s =~ /rational/
+                       RATIONAL_MATRIX32A_ARRAY
+                     else
+                       MATRIX32A_ARRAY
+                     end
+
+              n = NMatrix.new([4,3], nary, left_dtype)[1..3,1..2]
+              m = NMatrix.new([3,2], mary, right_dtype)[1..2,0..1]
+
+              r = n.dot m
+              r.shape.should eql([3,2])
+
+              r[0,0].should == 219.0
+              r[0,1].should == 185.0
+              r[1,0].should == 244.0
+              r[1,1].should == 205.0
+              r[2,0].should == 42.0
+              r[2,1].should == 35.0
+
+            end
+          end
+        end
+      end
+
+      it 'should be cleaned up by garbage collector without errors'  do
+        1.times do
+          n = @m[1..2,0..1]
+        end
+        GC.start
+        @m.should == NMatrix.new(:dense, [3,3], (0..9).to_a, :int32).cast(stype, :int32)
+        n = nil
+        1.times do
+          m = NMatrix.new(:dense, [2,2], [1,2,3,4]).cast(stype, :int32)
+          n = m[0..1,0..1]
+        end
+        GC.start
+        n.should == NMatrix.new(:dense, [2,2], [1,2,3,4]).cast(stype, :int32)
+      end
+
+      [:dense, :list, :yale].each do |cast_type|
+        it "should cast from #{stype.upcase} to #{cast_type.upcase}" do
+          nm_eql(@m[1..2, 1..2].cast(cast_type, :int32), @m[1..2,1..2]).should be_true
+          nm_eql(@m[0..1, 1..2].cast(cast_type, :int32), @m[0..1,1..2]).should be_true
+          nm_eql(@m[1..2, 0..1].cast(cast_type, :int32), @m[1..2,0..1]).should be_true
+          nm_eql(@m[0..1, 0..1].cast(cast_type, :int32), @m[0..1,0..1]).should be_true
+
+          # Non square
+          nm_eql(@m[0..2, 1..2].cast(cast_type, :int32), @m[0..2,1..2]).should be_true
+          nm_eql(@m[1..2, 0..2].cast(cast_type, :int32), @m[1..2,0..2]).should be_true
+
+          # Full
+          nm_eql(@m[0..2, 0..2].cast(cast_type, :int32), @m).should be_true
+        end
+      end
+      end
+    end
+    end # unless stype == :yale
+  end
+
+  # Stupid but independent comparison
+  def nm_eql(n, m)
+    if n.shape != m.shape
+      false
+    else
+      n.shape[0].times do |i|
+        n.shape[1].times do |j|
+          if n[i,j] != m[i,j]
+            puts "n[#{i},#{j}] != m[#{i},#{j}] (#{n[i,j]} != #{m[i,j]})"
+            return false 
+          end
+        end
+      end
+      true
+    end 
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# = NMatrix
+#
+# A linear algebra library for scientific computation in Ruby.
+# NMatrix is part of SciRuby.
+#
+# NMatrix was originally inspired by and derived from NArray, by
+# Masahiro Tanaka: http://narray.rubyforge.org
+#
+# == Copyright Information
+#
+# SciRuby is Copyright (c) 2010 - 2012, Ruby Science Foundation
+# NMatrix is Copyright (c) 2012, Ruby Science Foundation
+#
+# Please see LICENSE.txt for additional copyright notices.
+#
+# == Contributing
+#
+# By contributing source code to SciRuby, you agree to be bound by
+# our Contributor Agreement:
+#
+# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+#
+# == spec_helper.rb
+#
+# Common data for testing. 
+require "./lib/nmatrix"
+
+MATRIX43A_ARRAY = [14.0, 9.0, 3.0, 2.0, 11.0, 15.0, 0.0, 12.0, 17.0, 5.0, 2.0, 3.0]
+MATRIX32A_ARRAY = [12.0, 25.0, 9.0, 10.0, 8.0, 5.0]
+
+COMPLEX_MATRIX43A_ARRAY = MATRIX43A_ARRAY.zip(MATRIX43A_ARRAY.reverse).collect { |ary| Complex(ary[0], ary[1]) }
+COMPLEX_MATRIX32A_ARRAY = MATRIX32A_ARRAY.zip(MATRIX32A_ARRAY.reverse).collect { |ary| Complex(ary[0], -ary[1]) }
+
+RATIONAL_MATRIX43A_ARRAY = MATRIX43A_ARRAY.collect { |x| x.to_r }
+RATIONAL_MATRIX32A_ARRAY = MATRIX32A_ARRAY.collect { |x| x.to_r }
+
+def create_matrix(stype)
+  m = NMatrix.new(stype, [3,3], 0, :int32)
+
+  m[0,0] = 0
+  m[0,1] = 1
+  m[0,2] = 2
+  m[1,0] = 3
+  m[1,1] = 4
+  m[1,2] = 5
+  m[2,0] = 6
+  m[2,1] = 7
+  m[2,2] = 8
+
+  m
+end