nmatrix 0.1.0.rc1 → 0.1.0.rc2

data/spec/lapack_spec.rb

@@ -40,7 +40,7 @@ describe NMatrix::LAPACK do
         a = NMatrix.new(:dense, [3,4], [1,2,3,4,5,6,7,8,9,10,11,12], dtype)
         NMatrix::LAPACK::clapack_laswp(3, a, 4, 0, 3, [2,1,3,0], 1)
         b = NMatrix.new(:dense, [3,4], [3,2,4,1,7,6,8,5,11,10,12,9], dtype)
-        a.should == b
+        expect(a).to eq(b)
       end
 
       it "exposes NMatrix#permute_columns and #permute_columns! (user-friendly laswp)" do
@@ -48,10 +48,10 @@ describe NMatrix::LAPACK do
         b = NMatrix.new(:dense, [3,4], [3,2,4,1,7,6,8,5,11,10,12,9], dtype)
         piv = [2,1,3,0]
         r = a.permute_columns(piv)
-        r.should_not == a
-        r.should == b
+        expect(r).not_to eq(a)
+        expect(r).to eq(b)
         a.permute_columns!(piv)
-        a.should == b
+        expect(a).to eq(b)
       end
     end
   end
@@ -71,7 +71,7 @@ describe NMatrix::LAPACK do
                 else
                   1e-64
               end
-        NMatrix::LAPACK::clapack_gesv(:row,a.shape[0],b.shape[1],a,a.shape[0],b,b.shape[0]).should be_within(err).of(NMatrix[[-1.quo(2)], [0], [1.quo(2)]].cast(dtype: dtype))
+        expect(NMatrix::LAPACK::clapack_gesv(:row,a.shape[0],b.shape[1],a,a.shape[0],b,b.shape[0])).to be_within(err).of(NMatrix[[-1.quo(2)], [0], [1.quo(2)]].cast(dtype: dtype))
       end
 
 
@@ -89,15 +89,15 @@ describe NMatrix::LAPACK do
                   1e-64 # FIXME: should be 0, but be_within(0) does not work.
               end
 
-        a[0,0].should == 9 # 8
-        a[0,1].should be_within(err).of(2.quo(9)) # 1
-        a[0,2].should be_within(err).of(4.quo(9)) # 6
-        a[1,0].should == 5 # 1.quo(2)
-        a[1,1].should be_within(err).of(53.quo(9)) # 17.quo(2)
-        a[1,2].should be_within(err).of(7.quo(53)) # -1
-        a[2,0].should == 1 # 3.quo(8)
-        a[2,1].should be_within(err).of(52.quo(9))
-        a[2,2].should be_within(err).of(360.quo(53))
+        expect(a[0,0]).to eq(9) # 8
+        expect(a[0,1]).to be_within(err).of(2.quo(9)) # 1
+        expect(a[0,2]).to be_within(err).of(4.quo(9)) # 6
+        expect(a[1,0]).to eq(5) # 1.quo(2)
+        expect(a[1,1]).to be_within(err).of(53.quo(9)) # 17.quo(2)
+        expect(a[1,2]).to be_within(err).of(7.quo(53)) # -1
+        expect(a[2,0]).to eq(1) # 3.quo(8)
+        expect(a[2,1]).to be_within(err).of(52.quo(9))
+        expect(a[2,2]).to be_within(err).of(360.quo(53))
       end
 
       it "exposes clapack_potrf" do
@@ -106,7 +106,7 @@ describe NMatrix::LAPACK do
           a = NMatrix.new(:dense, 3, [25,15,-5, 0,18,0, 0,0,11], dtype)
           NMatrix::LAPACK::clapack_potrf(:row, :upper, 3, a, 3)
           b = NMatrix.new(:dense, 3, [5,3,-1, 0,3,1, 0,0,3], dtype)
-          a.should == b
+          expect(a).to eq(b)
         rescue NotImplementedError => e
           pending e.to_s
         end
@@ -115,7 +115,7 @@ describe NMatrix::LAPACK do
         a = NMatrix.new(:dense, 3, [25,0,0, 15,18,0,-5,0,11], dtype)
         NMatrix::LAPACK::clapack_potrf(:row, :lower, 3, a, 3)
         b = NMatrix.new(:dense, 3, [5,0,0, 3,3,0, -1,1,3], dtype)
-        a.should == b
+        expect(a).to eq(b)
       end
 
       # Together, these calls are basically xGESV from LAPACK: http://www.netlib.org/lapack/double/dgesv.f
@@ -126,9 +126,9 @@ describe NMatrix::LAPACK do
 
         NMatrix::LAPACK::clapack_getrs(:row, false, 3, 1, a, 3, ipiv, b, 3)
 
-        b[0].should == 5
-        b[1].should == -15.quo(2)
-        b[2].should == -13
+        expect(b[0]).to eq(5)
+        expect(b[1]).to eq(-15.quo(2))
+        expect(b[2]).to eq(-13)
       end
 
       it "exposes clapack_getri" do
@@ -139,7 +139,7 @@ describe NMatrix::LAPACK do
           NMatrix::LAPACK::clapack_getri(:row, 3, a, 3, ipiv)
 
           b = NMatrix.new(:dense, 3, [-5,0,-2,-4,1,-1,1.5,0,0.5], dtype)
-          a.should == b
+          expect(a).to eq(b)
         rescue NotImplementedError => e
           pending e.to_s
         end
@@ -200,10 +200,10 @@ describe NMatrix::LAPACK do
           pending e.to_s
         end
 
-        u.should be_within(err).of(left_true)
+        expect(u).to be_within(err).of(left_true)
         #FIXME: Is the next line correct?
-        vt[0...right_true.shape[0], 0...right_true.shape[1]-1].should be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
-        s.transpose.should be_within(err).of(s_true.row(0))
+        expect(vt[0...right_true.shape[0], 0...right_true.shape[1]-1]).to be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
+        expect(s.transpose).to be_within(err).of(s_true.row(0))
       end
 
 
@@ -272,10 +272,10 @@ describe NMatrix::LAPACK do
           pending e.to_s
         end
 
-        u.should be_within(err).of(left_true)
+        expect(u).to be_within(err).of(left_true)
         #FIXME: Is the next line correct?
-        vt[0...right_true.shape[0], 0...right_true.shape[1]-1].should be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
-        s.transpose.should be_within(err).of(s_true.row(0))
+        expect(vt[0...right_true.shape[0], 0...right_true.shape[1]-1]).to be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
+        expect(s.transpose).to be_within(err).of(s_true.row(0))
 
       end
  
@@ -341,10 +341,10 @@ describe NMatrix::LAPACK do
         rescue NotImplementedError => e
           pending e.to_s
         end
-        u.should be_within(err).of(left_true)
+        expect(u).to be_within(err).of(left_true)
         #FIXME: Is the next line correct?
-        vt[0...right_true.shape[0], 0...right_true.shape[1]-1].should be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
-        s.transpose.should be_within(err).of(s_true.row(0))
+        expect(vt[0...right_true.shape[0], 0...right_true.shape[1]-1]).to be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
+        expect(s.transpose).to be_within(err).of(s_true.row(0))
 
       end
       it "exposes the convenience gesdd method" do
@@ -400,10 +400,10 @@ describe NMatrix::LAPACK do
         rescue NotImplementedError => e
           pending e.to_s
         end
-        u.should be_within(err).of(left_true)
+        expect(u).to be_within(err).of(left_true)
         #FIXME: Is the next line correct?
-        vt[0...right_true.shape[0], 0...right_true.shape[1]-1].should be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
-        s.transpose.should be_within(err).of(s_true.row(0))
+        expect(vt[0...right_true.shape[0], 0...right_true.shape[1]-1]).to be_within(err).of(right_true[0...right_true.shape[0],0...right_true.shape[1]-1])
+        expect(s.transpose).to be_within(err).of(s_true.row(0))
       end
 
 
@@ -428,7 +428,7 @@ describe NMatrix::LAPACK do
         ldvl = n
 
         info = NMatrix::LAPACK::lapack_geev(:left, :right, n, a.clone, lda, wr.clone, wi.nil? ? nil : wi.clone, vl.clone, ldvl, vr.clone, ldvr, -1)
-        info.should == 0
+        expect(info).to eq(0)
 
         info = NMatrix::LAPACK::lapack_geev(:left, :right, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, 2*n)
 
@@ -443,7 +443,7 @@ describe NMatrix::LAPACK do
                                           0.28,  0.01,  0.02,  0.19,  0.80,
                                          -0.04,  0.34,  0.40, -0.22, -0.18 ], :float64)
 
-        vl.abs.should be_within(1e-2).of(vl_true.abs)
+        expect(vl.abs).to be_within(1e-2).of(vl_true.abs)
         # Not checking vr_true.
         # Example from:
         # http://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_lapack_examples/lapacke_dgeev_row.c.htm

data/spec/math_spec.rb

@@ -53,9 +53,16 @@ describe "math" do
                   meth.to_s[1...meth.to_s.length].to_sym)
               next if meth == :atanh
 
+              if meth == :-@
+                it "should correctly apply elementwise negation" do
+                  expect(@m.send(meth)).to eq N.new(@size, @a.map { |e| -e }, dtype: dtype, stype: stype)
+                end
+                next
+              end
+
               it "should correctly apply elementwise #{meth}" do
 
-                @m.send(meth).should eq N.new(@size, @a.map{ |e| Math.send(meth, e) },
+                expect(@m.send(meth)).to eq N.new(@size, @a.map{ |e| Math.send(meth, e) },
                                                  dtype: :float64, stype: stype)
               end
             end
@@ -63,28 +70,28 @@ describe "math" do
             NMatrix::NMMath::METHODS_ARITY_2.each do |meth|
               next if meth == :atan2
               it "should correctly apply elementwise #{meth}" do
-                @m.send(meth, @m).should eq N.new(@size, @a.map{ |e|
+                expect(@m.send(meth, @m)).to eq N.new(@size, @a.map{ |e|
                                                      Math.send(meth, e, e) },
-                                                     dtype: :float64, 
+                                                     dtype: :float64,
                                                      stype: stype)
               end
 
               it "should correctly apply elementwise #{meth} with a scalar first arg" do
-                Math.send(meth, 1, @m).should eq N.new(@size, @a.map { |e| Math.send(meth, 1, e) }, dtype: :float64, stype: stype)
+                expect(Math.send(meth, 1, @m)).to eq N.new(@size, @a.map { |e| Math.send(meth, 1, e) }, dtype: :float64, stype: stype)
               end
 
               it "should correctly apply elementwise #{meth} with a scalar second arg" do
-                @m.send(meth, 1).should eq N.new(@size, @a.map { |e| Math.send(meth, e, 1) }, dtype: :float64, stype: stype)
+                expect(@m.send(meth, 1)).to eq N.new(@size, @a.map { |e| Math.send(meth, e, 1) }, dtype: :float64, stype: stype)
               end
             end
 
             it "should correctly apply elementwise natural log" do
-              @m.log.should eq N.new(@size, [0, Math.log(2), Math.log(3), Math.log(4)],
+              expect(@m.log).to eq N.new(@size, [0, Math.log(2), Math.log(3), Math.log(4)],
                                         dtype: :float64, stype: stype)
             end
 
             it "should correctly apply elementwise log with arbitrary base" do
-              @m.log(3).should eq N.new(@size, [0, Math.log(2,3), 1, Math.log(4,3)],
+              expect(@m.log(3)).to eq N.new(@size, [0, Math.log(2,3), 1, Math.log(4,3)],
                                            dtype: :float64, stype: stype)
             end
 
@@ -96,23 +103,23 @@ describe "math" do
               [:asin, :acos, :atan, :atanh].each do |atf|
 
                 it "should correctly apply elementwise #{atf}" do
-                  @m.send(atf).should eq N.new(@size, 
+                  expect(@m.send(atf)).to eq N.new(@size, 
                                                @a.map{ |e| Math.send(atf, e) },
                                                dtype: :float64, stype: stype)
                 end
               end
 
               it "should correctly apply elementtwise atan2" do
-                @m.atan2(@m*0+1).should eq N.new(@size, 
+                expect(@m.atan2(@m*0+1)).to eq N.new(@size, 
                   @a.map { |e| Math.send(:atan2, e, 1) }, dtype: :float64, stype: stype)
               end
 
               it "should correctly apply elementwise atan2 with a scalar first arg" do
-                Math.atan2(1, @m).should eq N.new(@size, @a.map { |e| Math.send(:atan2, 1, e) }, dtype: :float64, stype: stype)
+                expect(Math.atan2(1, @m)).to eq N.new(@size, @a.map { |e| Math.send(:atan2, 1, e) }, dtype: :float64, stype: stype)
               end
 
               it "should correctly apply elementwise atan2 with a scalar second arg" do
-                  @m.atan2(1).should eq N.new(@size, @a.map { |e| Math.send(:atan2, e, 1) }, dtype: :float64, stype: stype)
+                  expect(@m.atan2(1)).to eq N.new(@size, @a.map { |e| Math.send(:atan2, e, 1) }, dtype: :float64, stype: stype)
               end
             end
           end
@@ -127,20 +134,20 @@ describe "math" do
       it "should correctly factorize a matrix" do
         m = NMatrix.new(:dense, 3, [4,9,2,3,5,7,8,1,6], dtype)
         a = m.factorize_lu
-        a[0,0].should == 8
-        a[0,1].should == 1
-        a[0,2].should == 6
-        a[1,0].should == 0.5
-        a[1,1].should == 8.5
-        a[1,2].should == -1
-        a[2,0].should == 0.375
+        expect(a[0,0]).to eq(8)
+        expect(a[0,1]).to eq(1)
+        expect(a[0,2]).to eq(6)
+        expect(a[1,0]).to eq(0.5)
+        expect(a[1,1]).to eq(8.5)
+        expect(a[1,2]).to eq(-1)
+        expect(a[2,0]).to eq(0.375)
       end
     end
 
     context dtype do
-      it "should correctly invert a matrix" do
+      it "should correctly invert a matrix in place" do
         a = NMatrix.new(:dense, 3, [1,0,4,1,1,6,-3,0,-10], dtype)
-        b = NMatrix.new(:dense, 3, [-5,0,-2,-4,1,-1,1.5,0,0.5], dtype)
+        b = NMatrix.new(:dense, 3, [-5,0,-2,-4,1,-1,3.quo(2),0,1.quo(2)], dtype)
         begin
           a.invert!
         rescue NotImplementedError => e
@@ -150,7 +157,15 @@ describe "math" do
             pending e.to_s
           end
         end
-        a.should == b
+        expect(a).to eq(b)
+      end
+
+      unless NMatrix.has_clapack?
+        it "should correctly exact-invert a matrix" do
+          a = NMatrix.new(:dense, 3, [1,0,4,1,1,6,-3,0,-10], dtype)
+          b = NMatrix.new(:dense, 3, [-5,0,-2,-4,1,-1,3.quo(2),0,1.quo(2)], dtype)
+          a.invert.should == b
+        end
       end
     end
   end
@@ -187,26 +202,26 @@ describe "math" do
         n = NMatrix.new([4,3], nary, dtype: left_dtype, stype: :dense)
         m = NMatrix.new([3,2], mary, dtype: right_dtype, stype: :dense)
 
-        m.shape[0].should == 3
-        m.shape[1].should == 2
-        m.dim.should == 2
+        expect(m.shape[0]).to eq(3)
+        expect(m.shape[1]).to eq(2)
+        expect(m.dim).to eq(2)
 
-        n.shape[0].should == 4
-        n.shape[1].should == 3
-        n.dim.should == 2
+        expect(n.shape[0]).to eq(4)
+        expect(n.shape[1]).to eq(3)
+        expect(n.dim).to eq(2)
 
-        n.shape[1].should == m.shape[0]
+        expect(n.shape[1]).to eq(m.shape[0])
 
         r = n.dot m
 
-        r[0,0].should == 273.0
-        r[0,1].should == 455.0
-        r[1,0].should == 243.0
-        r[1,1].should == 235.0
-        r[2,0].should == 244.0
-        r[2,1].should == 205.0
-        r[3,0].should == 102.0
-        r[3,1].should == 160.0
+        expect(r[0,0]).to eq(273.0)
+        expect(r[0,1]).to eq(455.0)
+        expect(r[1,0]).to eq(243.0)
+        expect(r[1,1]).to eq(235.0)
+        expect(r[2,0]).to eq(244.0)
+        expect(r[2,1]).to eq(205.0)
+        expect(r[3,0]).to eq(102.0)
+        expect(r[3,1]).to eq(160.0)
 
         #r.dtype.should == :float64 unless left_dtype == :float32 && right_dtype == :float32
       end
@@ -226,22 +241,22 @@ describe "math" do
 
         m = NMatrix.new([3,1], [2.0, 1.0, 0.0], dtype: right_dtype)
 
-        m.shape[0].should == 3
-        m.shape[1].should == 1
+        expect(m.shape[0]).to eq(3)
+        expect(m.shape[1]).to eq(1)
 
-        n.shape[0].should == 4
-        n.shape[1].should == 3
-        n.dim.should == 2
+        expect(n.shape[0]).to eq(4)
+        expect(n.shape[1]).to eq(3)
+        expect(n.dim).to eq(2)
 
-        n.shape[1].should == m.shape[0]
+        expect(n.shape[1]).to eq(m.shape[0])
 
         r = n.dot m
         # r.class.should == NVector
 
-        r[0,0].should == 4
-        r[1,0].should == 13
-        r[2,0].should == 22
-        r[3,0].should == 31
+        expect(r[0,0]).to eq(4)
+        expect(r[1,0]).to eq(13)
+        expect(r[2,0]).to eq(22)
+        expect(r[3,0]).to eq(31)
 
         #r.dtype.should == :float64 unless left_dtype == :float32 && right_dtype == :float32
       end

data/spec/nmatrix_yale_spec.rb

@@ -36,7 +36,7 @@ describe NMatrix do
     it "compares two empty matrices" do
       n = NMatrix.new(4, stype: :yale, dtype: :float64)
       m = NMatrix.new(4, stype: :yale, dtype: :float64)
-      n.should == m
+      expect(n).to eq(m)
     end
 
     it "compares two matrices following basic assignments" do
@@ -45,11 +45,11 @@ describe NMatrix do
 
       m[0,0] = 1
       m[0,1] = 1
-      n.should_not == m
+      expect(n).not_to eq(m)
       n[0,0] = 1
-      n.should_not == m
+      expect(n).not_to eq(m)
       n[0,1] = 1
-      n.should == m
+      expect(n).to eq(m)
     end
 
     it "compares two matrices following elementwise operations" do
@@ -58,7 +58,7 @@ describe NMatrix do
       n[0,1] = 1
       m[0,1] = -1
       x = n+m
-      (n+m).should == NMatrix.new(2, 0.0, stype: :yale)
+      expect(n+m).to eq(NMatrix.new(2, 0.0, stype: :yale))
     end
 
     it "sets diagonal values" do
@@ -66,7 +66,7 @@ describe NMatrix do
       n.extend(NMatrix::YaleFunctions)
       n[1,1] = 0.1
       n[0,0] = 0.2
-      n.yale_d.should == [0.2, 0.1]
+      expect(n.yale_d).to eq([0.2, 0.1])
     end
 
     it "gets non-diagonal rows as hashes" do
@@ -77,7 +77,7 @@ describe NMatrix do
       n[0,3] = 0.3
       n[1,5] = 0.4
       h = n.yale_nd_row(0, :hash)
-      h.should == {2 => 0.2, 3 => 0.3}
+      expect(h).to eq({2 => 0.2, 3 => 0.3})
     end
 
     it "gets non-diagonal occupied column indices for a given row" do
@@ -88,19 +88,19 @@ describe NMatrix do
       n[0,3] = 0.3
       n[1,5] = 0.4
       a = n.yale_nd_row(0, :array)
-      a.should == [2,3]
+      expect(a).to eq([2,3])
     end
 
     it "does not resize until necessary" do
       n = NMatrix.new([2,3], stype: :yale, dtype: :float64)
       n.extend(NMatrix::YaleFunctions)
-      n.yale_size.should == 3
-      n.capacity.should == 5
+      expect(n.yale_size).to eq(3)
+      expect(n.capacity).to eq(5)
       n[0,0] = 0.1
       n[0,1] = 0.2
       n[1,0] = 0.3
-      n.yale_size.should == 5
-      n.capacity.should == 5
+      expect(n.yale_size).to eq(5)
+      expect(n.capacity).to eq(5)
     end
 
 
@@ -110,8 +110,8 @@ describe NMatrix do
       n[0,0] = 0.1
       n[0,1] = 0.2
       n[1,0] = 0.3
-      n.yale_a.should == [0.1, 0.0, 0.0, 0.2, 0.3]
-      n.yale_ija.should == [3,4,5,1,0]
+      expect(n.yale_a).to eq([0.1, 0.0, 0.0, 0.2, 0.3])
+      expect(n.yale_ija).to eq([3,4,5,1,0])
     end
 
     it "sets when resizing" do
@@ -122,10 +122,10 @@ describe NMatrix do
       n[0,1] = 0.2
       n[1,0] = 0.3
       n[1,2] = 0.4
-      n.yale_d.should == [0.01, 0.1]
-      n.yale_ia.should == [3,4,6]
-      n.yale_ja.should == [1,0,2,nil]
-      n.yale_lu.should == [0.2, 0.3, 0.4, nil]
+      expect(n.yale_d).to eq([0.01, 0.1])
+      expect(n.yale_ia).to eq([3,4,6])
+      expect(n.yale_ja).to eq([1,0,2,nil])
+      expect(n.yale_lu).to eq([0.2, 0.3, 0.4, nil])
     end
 
     it "resizes without erasing values" do
@@ -138,11 +138,11 @@ describe NMatrix do
 
       associations.each_pair do |j,i|
         n[i,j] = 1
-        n[i,j].should be(1), "Value at #{i},#{j} not inserted correctly!"
+        expect(n[i,j]).to be(1), "Value at #{i},#{j} not inserted correctly!"
       end
 
       associations.each_pair do |j,i|
-        n[i,j].should be(1), "Value at #{i},#{j} erased during resize!"
+        expect(n[i,j]).to be(1), "Value at #{i},#{j} erased during resize!"
       end
     end
 
@@ -152,8 +152,8 @@ describe NMatrix do
       n[2,1]   = 1.0
       n[2,0]   = 1.5
       n[2,15]  = 2.0
-      n.yale_lu.should == [1.5, 1.0, 2.0]
-      n.yale_ja.should == [0, 1, 15]
+      expect(n.yale_lu).to eq([1.5, 1.0, 2.0])
+      expect(n.yale_ja).to eq([0, 1, 15])
     end
 
     it "gets values within rows" do
@@ -161,9 +161,9 @@ describe NMatrix do
       n[2,1]   = 1.0
       n[2,0]   = 1.5
       n[2,15]  = 2.0
-      n[2,1].should == 1.0
-      n[2,0].should == 1.5
-      n[2,15].should == 2.0
+      expect(n[2,1]).to eq(1.0)
+      expect(n[2,0]).to eq(1.5)
+      expect(n[2,15]).to eq(2.0)
     end
 
     it "sets values within large rows" do
@@ -179,8 +179,8 @@ describe NMatrix do
       n[5,293] = 2.0
       n[5,299] = 7.0
       n[5,100] = 8.0
-      n.yale_lu.should == [1.5, 1.0, 2.0, 8.0, 5.0, 6.0, 3.0, 4.0, 2.0, 7.0]
-      n.yale_ja.should == [0,   1,   15,  100, 289, 290, 291, 292, 293, 299]
+      expect(n.yale_lu).to eq([1.5, 1.0, 2.0, 8.0, 5.0, 6.0, 3.0, 4.0, 2.0, 7.0])
+      expect(n.yale_ja).to eq([0,   1,   15,  100, 289, 290, 291, 292, 293, 299])
     end
 
     it "gets values within large rows" do
@@ -199,7 +199,7 @@ describe NMatrix do
 
       n.yale_ja.each_index do |idx|
         j = n.yale_ja[idx]
-        n[5,j].should == n.yale_lu[idx]
+        expect(n[5,j]).to eq(n.yale_lu[idx])
       end
     end
 
@@ -215,7 +215,7 @@ describe NMatrix do
 
       d = NMatrix.new(4, [0,0,4,4, 0,2,0,0, 0,0,0,0, 0,0,2,2], dtype: :float64, stype: :yale)
 
-      c.should == d
+      expect(c).to eq(d)
     end
 
     it "dots two identical matrices where a positive and negative partial sum cancel on the diagonal" do
@@ -233,8 +233,8 @@ describe NMatrix do
 
       c.extend(NMatrix::YaleFunctions)
 
-      c.yale_ija.reject { |i| i.nil? }.should == [5,8,9,9,11,1,2,3,3,1,2]
-      c.yale_a.reject { |i| i.nil? }.should == [1.0, -16.0, 0.0, 0.0, 0.0, 4.0, 8.0, -16.0, -16.0, 16.0, 8.0]
+      expect(c.yale_ija.reject { |i| i.nil? }).to eq([5,8,9,9,11,1,2,3,3,1,2])
+      expect(c.yale_a.reject { |i| i.nil? }).to eq([1.0, -16.0, 0.0, 0.0, 0.0, 4.0, 8.0, -16.0, -16.0, 16.0, 8.0])
 
     end
 
@@ -264,11 +264,11 @@ describe NMatrix do
       # We want to do a structure comparison to ensure multiplication is occurring properly, but more importantly, to
       # ensure that insertion sort is occurring as it should. If the row has more than four entries, it'll run quicksort
       # instead. Quicksort calls insertion sort for small rows, so we test both with this particular multiplication.
-      nm.yale_ija[0...107].should == nmr.yale_ija[0...107]
-      nm.yale_a[0...107].should   == nmr.yale_a[0...107]
+      expect(nm.yale_ija[0...107]).to eq(nmr.yale_ija[0...107])
+      expect(nm.yale_a[0...107]).to   eq(nmr.yale_a[0...107])
 
       mn = m.dot(n)
-      mn[0,0].should == 541
+      expect(mn[0,0]).to eq(541)
     end
 
     it "calculates the row key intersections of two matrices" do
@@ -280,7 +280,7 @@ describe NMatrix do
       (0...3).each do |ai|
         (0...3).each do |bi|
           STDERR.puts (a.yale_ja_d_keys_at(ai) & b.yale_ja_d_keys_at(bi)).inspect
-          (a.yale_ja_d_keys_at(ai) & b.yale_ja_d_keys_at(bi)).should == a.yale_row_keys_intersection(ai, b, bi)
+          expect(a.yale_ja_d_keys_at(ai) & b.yale_ja_d_keys_at(bi)).to eq(a.yale_row_keys_intersection(ai, b, bi))
         end
       end