nmatrix 0.0.6 → 0.0.7

data/spec/nvector_spec.rb

@@ -49,13 +49,6 @@ describe NVector do
     v[0].should == 1.555
   end
 
-  it "transpose!() changes destructively its raw and column stored structure" do
-    v = NVector.new 5, :float64
-    v.transpose!
-    v.shape[0].should == 5
-    v.shape[1].should == 1
-  end
-
   it "dot() multiples itself by another NVector" do
     v1 = NVector.new(2, :float64)
     v2 = NVector.new(2, :float64).transpose
@@ -63,10 +56,11 @@ describe NVector do
     v1[1] = 2.3
     v2[0] = 1.3
     v2[1] = 2.5
-    v1.dot(v2).should == 12.0
+    v1.dot(v2).should be_within(0.000000001).of(7.7)
   end
 
   it "dot!() multiples itself destructively by another NVector" do
+    pending "dot! not yet implemented"
     v1 = NVector.new 2, :float64
     v2 = NVector.new(2, :float64).transpose
     v1[0] = 1.5
@@ -74,7 +68,7 @@ describe NVector do
     v2[0] = 1.3
     v2[1] = 2.5
     v1.dot!(v2)
-    v1.should == 12.0
+    v1.should be_within(0.000000001).of(7.7)
   end
 
   it "pretty_print() prints values to standard output with a pretty format" do

data/spec/rspec_monkeys.rb

@@ -0,0 +1,29 @@
+module RSpec::Matchers::BuiltIn
+  class BeWithin
+
+    def of(expected)
+      @expected = expected
+      @unit     = ''
+      if expected.is_a?(NMatrix)
+        @tolerance = if @delta.is_a?(NMatrix)
+                       @delta.clone
+                     elsif @delta.is_a?(Array)
+                       NMatrix.new(:dense, expected.shape, @delta, expected.dtype)
+                     else
+                       NMatrix.ones_like(expected) * @delta
+                     end
+      else
+        @tolerance = @delta
+      end
+
+      self
+    end
+
+    def percent_of(expected)
+      @expected  = expected
+      @unit      = '%'
+      @tolerance = @expected.abs * @delta / 100.0 # <- only change is to reverse abs and @delta
+      self
+    end
+  end
+end

data/spec/rspec_spec.rb

@@ -0,0 +1,34 @@
+# = 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
+#
+# == rspec_spec.rb
+#
+# A spec for testing monkey patches to RSpec for NMatrix.
+#
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe "RSpec" do
+  it "should permit #be_within to be used on a dense NMatrix" do
+    (NMatrix.new(:dense, [4,1], 1.0, :complex128) / 10000.0).should be_within(0.00000001).of(NMatrix.new(:dense, [4,1], 0.0001, :float64))
+    (NMatrix.new(:dense, [4,1], 1.0, :complex128) / 10000.0).should_not be_within(0.00000001).of(NMatrix.new(:dense, [4,1], 1.0, :float64))
+  end
+end

data/spec/shortcuts_spec.rb

@@ -165,29 +165,27 @@ describe NMatrix do
     m.column(2).is_a?(NMatrix).should be_true
   end
 
-  it "column() accepts a second parameter (only :copy or :reference)" do
-    m = NMatrix.random(3)
-
-    expect { m.column(1, :copy) }.to_not raise_error
-    expect { m.column(1, :reference) }.to_not raise_error
-
-    expect { m.column(1, :derp) }.to raise_error
-  end
-
   it "row() returns a NMatrix" do
     m = NMatrix.random(3)
 
     m.row(2).is_a?(NMatrix).should be_true
   end
 
-  it "row() accepts a second parameter (only :copy or :reference)" do
-    m = NMatrix.random(3)
-
-    expect { m.row(1, :copy) }.to_not raise_error
-    expect { m.row(1, :reference) }.to_not raise_error
+  it "diagonals() creates an NMatrix" do
+    arr = [1,2,3,4]
+    m = NMatrix.diagonals(arr)
+    m.is_a?(NMatrix).should be_true
+  end
 
-    expect { m.row(1, :derp) }.to raise_error
+  it "diagonals() contains the seeded values on the diagonal" do
+    arr = [1,2,3,4]
+    m = NMatrix.diagonals(arr)
+    m[0,0].should eq(arr[0])
+    m[1,1].should eq(arr[1])
+    m[2,2].should eq(arr[2])
+    m[3,3].should eq(arr[3])
   end
+
 end
 
 describe "NVector" do
@@ -261,7 +259,7 @@ describe "Inline constructor" do
 
   it "creates a NMatrix with the given values" do
     m = NMatrix.new([2, 2], [1, 4, 6, 7])
-    n = N[[1, 4], [6, 7]]
+    n = NMatrix[[1, 4], [6, 7]]
 
     m.should.eql? n
   end

data/spec/slice_spec.rb

@@ -27,29 +27,118 @@
 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)
+      if stype == :yale
+        it "should binary search for the left boundary of a partial row of stored indices correctly" do
+          n = NMatrix.new(:yale, 10, :int32)
+          n[3,0] = 1
+          #n[3,2] = 2
+          n[3,3] = 3
+          n[3,4] = 4
+          n[3,6] = 5
+          n[3,8] = 6
+          n[3,9] = 7
+          vs = []
+          is = []
+          js = []
+          n[3,1..9].each_stored_with_indices do |v,i,j|
+            vs << v
+            is << i
+            js << j
+          end
 
+          vs.should == [3,4,5,6,7]
+          js.should == [2,3,5,7,8]
+          is.should == [0,0,0,0,0]
+        end
+      elsif stype == :list
+        it "should iterate across a partial row of stored indices" do
+          vs = []
+          is = []
+          js = []
+
+          STDERR.puts("now") if stype == :yale
+          @m[2,1..2].each_stored_with_indices do |v,i,j|
+            vs << v
+            is << i
+            js << j
+          end
 
-          @m.is_ref?.should be_false
-          a.is_ref?.should be_true
-          b.is_ref?.should be_false
+          vs.should == [7,8]
+          is.should == [0,0]
+          js.should == [0,1]
         end
+      end
+
+      unless stype == :dense
+        it "should iterate across a row of stored indices" do
+
+          vs = []
+          is = []
+          js = []
+          @m[2,0..2].each_stored_with_indices do |v,i,j|
+            vs << v
+            is << i
+            js << j
+          end
+          vs.should == (stype == :yale ? [8,6,7] : [6,7,8])
+          is.should == [0,0,0]
+          js.should == (stype == :yale ? [2,0,1] : [0,1,2])
+        end
+
+        it "should iterate across a submatrix of stored indices" do
+          vs = []
+          is = []
+          js = []
+          @m[0..1,1..2].each_stored_with_indices do |v,i,j|
+            vs << v
+            is << i
+            js << j
+          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]
+          vs.should == (stype == :yale ? [4,1,2,5] : [1,2,4,5])
+          is.should == (stype == :yale ? [1,0,0,1] : [0,0,1,1])
+          js.should == (stype == :yale ? [0,0,1,1] : [0,1,0,1])
         end
-      end # unless stype == :yale
+      end
+
+      it "should return correct shape and 1st-order supershape" do
+        x = NMatrix.random([10,12])
+        y = x[0...8,5...12]
+        y.shape.should == [8,7]
+        y.supershape.should == [10,12]
+      end
+
+      it "should return correct 1st- and 2nd-order supershape" do
+        pending "Not yet sure if we ever want to enable reference slices of reference slices"
+        x = NMatrix.random([10,12])
+        y = x[0...8,5...12]
+        z = y[0...3,0...4]
+        z.supershape(2).should == y.supershape(1)
+        z.supershape(1).should == [8,7]
+      end
+
+      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
 
       context "with copying" do
         it 'should return an NMatrix' do
@@ -66,7 +155,7 @@ describe "Slice operation" do
           @m[2,1].should eql(7)
         end
 
-        it 'should return a 1x2 vector with refs to self elements' do
+        it 'should return a 1x2 matrix with refs to self elements' do
           n = @m.slice(0,1..2)
           n.shape.should eql([1,2])
 
@@ -105,211 +194,178 @@ describe "Slice operation" do
         end
       end
 
-
-
-      if stype == :yale
-        context "by reference" do
-          it "should raise an error" do
-            expect{ @m[1..2,1..2] }.to raise_error(NotImplementedError)
-          end
+      # Yale:
+      #context "by copy" do
+        #it "should correctly preserve zeros" do
+        #  @m = NMatrix.new(:yale, 3, :int64)
+        #  column_slice = @m.column(2, :copy)
+        #  column_slice[0].should == 0
+        #  column_slice[1].should == 0
+        #  column_slice[2].should == 0
+        #end
+      #end
+
+      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
 
-        context "by copy" do
-          it "should correctly preserve zeros" do
-            @m = NMatrix.new(:yale, 3, :int64)
-            column_slice = @m.column(2, :copy)
-            column_slice[0].should == 0
-            column_slice[1].should == 0
-            column_slice[2].should == 0
-          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])
 
-          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
 
-            n[0,0].should == @m[1,0]
-            n[0,0] = -9
-            @m[1,0].should eql(-9)
-          end
+        it 'should return a 1x2 vector with refs to self elements' do
+          n = @m[0,1..2]
+          n.shape.should eql([1,2])
 
-          it 'should return a 1x2 vector with refs to self elements' do
-            n = @m[0,1..2]
-            n.shape.should eql([1,2])
+          n[0].should == @m[0,1]
+          n[0] = -9
+          @m[0,1].should eql(-9)
+        end
 
-            n[0].should == @m[0,1]
-            n[0] = -9
-            @m[0,1].should eql(-9)
-          end
+        it 'should return a 2x1 vector with refs to self elements' do
+          n = @m[0..1,1]
+          n.shape.should eql([2,1])
 
-          it 'should return a 2x1 vector with refs to self elements' do
-            n = @m[0..1,1]
-            n.shape.should eql([2,1])
+          n[0].should == @m[0,1]
+          n[0] = -9
+          @m[0,1].should eql(-9)
+        end
 
-            n[0].should == @m[0,1]
-            n[0] = -9
-            @m[0,1].should eql(-9)
-          end
+        it 'should slice again' do
+          n = @m[1..2, 1..2]
+          nm_eql(n[1,0..1], NVector.new(2, [7,8], :int32).transpose).should be_true
+        end
 
-          it 'should slice again' do
-            n = @m[1..2, 1..2]
-            nm_eql(n[1,0..1], NVector.new(2, [7,8], :int32).transpose).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
 
-          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
 
-          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
 
-            context "operations" do 
-
-              it "correctly transposes slices" do
-                @m[0...3,0].transpose.should eq N[[0, 3, 6]]
-              end
+          context "operations" do
 
-              it "adds slices" do 
-                (N[[0,0,0]] + @m[1,0..2]).should eq N[[3, 4, 5]]
-              end
+            it "correctly transposes slices" do
+              @m[0...3,0].transpose.should eq NMatrix[[0, 3, 6]]
+            end
 
-              it "scalar adds to slices" do
-                (@m[1,0..2]+1).should eq N[[4, 5, 6]]
-              end
+            it "adds slices" do
+              (NMatrix[[0,0,0]] + @m[1,0..2]).should eq NMatrix[[3, 4, 5]]
+            end
 
-              it "compares slices to scalars" do
-                (@m[1, 0..2] > 2).each { |e| (e != 0).should be_true }
-              end
+            it "scalar adds to slices" do
+              (@m[1,0..2]+1).should eq NMatrix[[4, 5, 6]]
+            end
 
-              it "iterates only over elements in the slice" do 
-                els = []
-                @m[1, 0..2].each { |e| els << e }
-                els.size.should eq 3
-                els[0].should eq 3
-                els[1].should eq 4
-                els[2].should eq 5
-              end
+            it "compares slices to scalars" do
+              (@m[1, 0..2] > 2).each { |e| (e != 0).should be_true }
+            end
 
-              it "iterates with index only over elements in the slice" do 
-                els = []
-                @m[1, 0..2].each_stored_with_indices { |a| els << a }
-                els.size.should eq 3
-                els[0].should eq [3, 0, 0]
-                els[1].should eq [4, 0, 1]
-                els[2].should eq [5, 0, 2]
-              end
+            it "iterates only over elements in the slice" do
+              els = []
+              @m[1, 0..2].each { |e| els << e }
+              els.size.should eq 3
+              els[0].should eq 3
+              els[1].should eq 4
+              els[2].should eq 5
+            end
 
+            it "iterates with index only over elements in the slice" do
+              els = []
+              @m[1, 0..2].each_stored_with_indices { |a| els << a }
+              els.size.should eq 3
+              els[0].should eq [3, 0, 0]
+              els[1].should eq [4, 0, 1]
+              els[2].should eq [5, 0, 2]
             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
+
+        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
+        [:dense, :list, :yale].each do |cast_type|
+          it "should cast from #{stype.upcase} to #{cast_type.upcase}" do
 
-              # 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
+            nm_eql(@m[1..2, 1..2].cast(cast_type), @m[1..2,1..2]).should be_true
+            nm_eql(@m[0..1, 1..2].cast(cast_type), @m[0..1,1..2]).should be_true
+            nm_eql(@m[1..2, 0..1].cast(cast_type), @m[1..2,0..1]).should be_true
+            nm_eql(@m[0..1, 0..1].cast(cast_type), @m[0..1,0..1]).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
+            # Non square
+            nm_eql(@m[0..2, 1..2].cast(cast_type), @m[0..2,1..2]).should be_true
+            nm_eql(@m[1..2, 0..2].cast(cast_type), @m[1..2,0..2]).should be_true
 
-  # Stupid but independent comparison
-  def nm_eql(n, m) #:nodoc:
-    if n.shape != m.shape
-      false
-    elsif n.is_a?(NVector)
-      return false unless m.is_a?(NVector) # don't compare NV to NM
-      long_shape = n.shape[0] == 1 ? n.shape[1] : n.shape[0]
-      long_shape.times do |j|
-        if n[j] != m[j]
-          puts "n[#{j}] != m[#{j}] (#{n[j]} != #{m[j]})"
-          return false
-        end
-      end
-    else # NMatrix
-      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
+            # Full
+            nm_eql(@m[0..2, 0..2].cast(cast_type), @m).should be_true
           end
         end
       end
+
     end
-    true
   end
 end