nmatrix 0.0.3 → 0.0.4

data/spec/shortcuts_spec.rb

@@ -29,39 +29,49 @@
 require File.join(File.dirname(__FILE__), "spec_helper.rb")
 
 describe NMatrix do
-    
+
   it "zeros() creates a matrix of zeros" do
     m = NMatrix.zeros(3)
     n = NMatrix.new([3, 3], 0)
-    
+
     m.should.eql? n
   end
-  
+
   it "ones() creates a matrix of ones" do
     m = NMatrix.ones(3)
     n = NMatrix.new([3, 3], 1)
-    
-    m.should.eql? n    
+
+    m.should.eql? n
   end
-  
+
   it "eye() creates an identity matrix" do
     m = NMatrix.eye(3)
     identity3 = NMatrix.new([3, 3], [1, 0, 0, 0, 1, 0, 0, 0, 1])
-    
+
     m.should.eql? identity3
   end
-  
+
   it "random() creates a matrix of random numbers" do
     m = NMatrix.random(2)
-    
+
+    m.stype.should == :dense
+    m.dtype.should == :float64
+  end
+
+  it "random() only accepts an integer or an array as dimension" do
+    m = NMatrix.random([2, 2])
+
     m.stype.should == :dense
     m.dtype.should == :float64
+
+    expect { NMatrix.random(2.0) }.to raise_error
+    expect { NMatrix.random("not an array or integer") }.to raise_error
   end
-  
+
   it "seq() creates a matrix of integers, sequentially" do
     m = NMatrix.seq(2) # 2x2 matrix.
     value = 0
-    
+
     2.times do |i|
       2.times do |j|
         m[i, j].should == value
@@ -69,86 +79,200 @@ describe NMatrix do
       end
     end
   end
-  
+
   it "seq() only accepts an integer or a 2-element array as dimension" do
+    m = NMatrix.seq([2, 2])
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        m[i, j].should == value
+        value += 1
+      end
+    end
+
     expect { NMatrix.seq([1, 2, 3]) }.to raise_error
     expect { NMatrix.seq("not an array or integer") }.to raise_error
   end
-  
+
+  it "indgen() creates a matrix of integers as well as seq()" do
+    m = NMatrix.indgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        m[i, j].should == value
+        value += 1
+      end
+    end
+  end
+
+  it "findgen creates a matrix of floats, sequentially" do
+    m = NMatrix.findgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        (m[i, j]/10).should be_within(Float::EPSILON).of(value.to_f/10)
+        value += 1
+      end
+    end
+  end
+
+  it "bindgen() creates a matrix of bytes" do
+    m = NMatrix.bindgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        m[i, j].should == value
+        value += 1
+      end
+    end
+  end
+
+  it "cindgen() creates a matrix of complexes" do
+    m = NMatrix.cindgen(2) # 2x2 matrix.
+    value = 0
+
+    2.times do |i|
+      2.times do |j|
+        m[i, j].real.should be_within(Float::EPSILON).of(value)
+        m[i, j].imag.should be_within(Float::EPSILON).of(0.0)
+        value += 1
+      end
+    end
+  end
+
   it "column() returns a NMatrix" do
     m = NMatrix.random(3)
-    
+
     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
+
+    expect { m.row(1, :derp) }.to raise_error
+  end
 end
 
 describe "NVector" do
-      
+
   it "zeros() creates a vector of zeros" do
     v = NVector.zeros(4)
-    
+
     4.times do |i|
       v[i].should == 0
     end
   end
-  
+
   it "ones() creates a vector of ones" do
     v = NVector.ones(3)
-    
+
     3.times do |i|
       v[i].should == 1
     end
   end
-  
+
   it "random() creates a vector of random numbers" do
-    v = NVector.zeros(4)
+    v = NVector.random(4)
     v.dtype.should == :float64
     v.stype.should == :dense
   end
-  
+
   it "seq() creates a vector of integers, sequentially" do
     v = NVector.seq(7)
     i = 0
-    
+
     v.each do |elem|
       elem.should == i
       i += 1
     end
   end
-  
+
   it "seq() only accepts integers as dimension" do
     expect { NVector.seq(3) }.to_not raise_error
 
     expect { NVector.seq([1, 3]) }.to raise_error
     expect { NVector.seq(:wtf) }.to raise_error
   end
-  
+
+  it "indgen() creates a vector of integers as well as seq()" do
+    v = NVector.indgen(7)
+    i = 0
+
+    v.each do |elem|
+      elem.should == i
+      i += 1
+    end
+  end
+
+  it "findgen creates a vector of floats, sequentially" do
+    v = NVector.findgen(2)
+
+    2.times do |i|
+      (v[i]/10).should be_within(Float::EPSILON).of(i.to_f/10)
+    end
+  end
+
+  it "bindgen() creates a vector of bytes, sequentially" do
+    v = NVector.bindgen(7)
+    i = 0
+
+    v.each do |elem|
+      elem.should == i
+      i += 1
+    end
+  end
+
+  it "cindgen() creates a vector of complexes, sequentially" do
+    v = NVector.cindgen(2)
+    value = 0
+
+    2.times do |i|
+      v[i].real.should be_within(Float::EPSILON).of(value)
+      v[i].imag.should be_within(Float::EPSILON).of(0.0)
+      value += 1
+    end
+  end
+
+
   it "linspace() creates a vector with n values equally spaced between a and b" do
     v = NVector.linspace(0, 2, 5)
     i = 0
-    
+
     v.each do |elem|
       elem.should == i * 0.5
       i += 1
     end
-  end  
+  end
 end
 
 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]]
-    
-    m.should.eql? n 
+
+    m.should.eql? n
   end
 end

data/spec/slice_spec.rb

@@ -20,226 +20,277 @@
 #
 # * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
 #
-# == slec_spec.rb
+# == slice_spec.rb
 #
-# Test of slice operations. 
+# 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
+    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)
+      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
+          @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
+        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
+      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])
+        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
+          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])
+        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
+          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])
+        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
+          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
+        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
-      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
+        [: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
 
-      it 'should return a 2x2 matrix with refs to self elements' do
-        n = @m[1..2,0..1]
-        n.shape.should eql([2,2])
+            # 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
 
-        n[0,0].should == @m[1,0]
-        n[0,0] = -9
-        @m[1,0].should eql(-9)
+            # Full
+            nm_eql(@m.slice(0..2, 0..2).cast(cast_type, :int32), @m).should be_true
+          end
+        end
       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])
+      if stype == :yale
+        context "by reference" do
+          it "should raise an error" do
+            expect{ @m[1..2,1..2] }.to raise_error(NotImplementedError)
+          end
+        end
 
-        n[0,0].should == @m[0,1]
-        n[0,0] = -9
-        @m[0,1].should eql(-9)
-      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,0].should == 0
+            column_slice[1,0].should == 0
+            column_slice[2,0].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 set value from NMatrix'
+          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 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
+            n[0,0].should == @m[1,0]
+            n[0,0] = -9
+            @m[1,0].should eql(-9)
+          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 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
 
-      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
+            context "operations" do 
+
+              it "correctly transposes slices" do
+                @m[0...3,0].transpose.should eq N[[0, 3, 6]]
+              end
+
+              it "adds slices" do 
+                (N[[0,0,0]] + @m[1,0..2]).should eq N[[3, 4, 5]]
+              end
+
+              it "scalar adds to slices" do 
+                (@m[1,0..2]+1).should eq N[[4, 5, 6]]
+              end
+
+              it "compares slices to scalars" do 
+                (@m[1, 0..2] > 2).each { |e| (e != 0).should be_true }
+              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
+
           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
+          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
+              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
+              # 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
+              # Full
+              nm_eql(@m[0..2, 0..2].cast(cast_type, :int32), @m).should be_true
+            end
+          end
         end
       end
-      end
-    end
     end # unless stype == :yale
   end
 
   # Stupid but independent comparison
-  def nm_eql(n, m)
+  def nm_eql(n, m) #:nodoc:
     if n.shape != m.shape
       false
     else
@@ -247,11 +298,11 @@ describe "Slice operation" do
         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 
+            return false
           end
         end
       end
       true
-    end 
+    end
   end
 end