nmatrix 0.1.0.rc1 → 0.1.0.rc2

data/spec/rspec_spec.rb

@@ -28,7 +28,7 @@ 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))
+    expect(NMatrix.new(:dense, [4,1], 1.0, :complex128) / 10000.0).to be_within(0.00000001).of(NMatrix.new(:dense, [4,1], 0.0001, :float64))
+    expect(NMatrix.new(:dense, [4,1], 1.0, :complex128) / 10000.0).not_to be_within(0.00000001).of(NMatrix.new(:dense, [4,1], 1.0, :float64))
   end
 end

data/spec/shortcuts_spec.rb

@@ -38,53 +38,71 @@ describe NMatrix do
     m = NMatrix.zeros(3)
     n = NMatrix.new([3, 3], 0)
 
-    m.should.eql? n
+    expect(m).to eq n
   end
 
   it "ones() creates a matrix of ones" do
     m = NMatrix.ones(3)
     n = NMatrix.new([3, 3], 1)
 
-    m.should.eql? n
+    expect(m).to eq 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
+    expect(m).to eq identity3
   end
 
   it "diag() creates a matrix with pre-supplied diagonal" do
     arr = [1,2,3,4]
     m = NMatrix.diag(arr)
-    m.is_a?(NMatrix).should be_true
+    expect(m.is_a?(NMatrix)).to be_true
   end
 
   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])
+    expect(m[0,0]).to eq(arr[0])
+    expect(m[1,1]).to eq(arr[1])
+    expect(m[2,2]).to eq(arr[2])
+    expect(m[3,3]).to eq(arr[3])
   end
 
-  it "random() creates a matrix of random numbers" do
-    m = NMatrix.random(2)
+  context "::random" do
+    it "creates a matrix of random numbers" do
+      m = NMatrix.random(2)
 
-    m.stype.should == :dense
-    m.dtype.should == :float64
-  end
+      expect(m.stype).to eq(:dense)
+      expect(m.dtype).to eq(:float64)
+    end
+
+    it "creates a complex matrix of random numbers" do
+      m = NMatrix.random(2, :dtype => :complex128)
+    end
+
+    it "forbids generation of a rational matrix" do
+      expect { m = NMatrix.random(2, dtype: :rational128) }.to raise_error
+    end
 
-  it "random() only accepts an integer or an array as dimension" do
-    m = NMatrix.random([2, 2])
+    it "correctly accepts :scale parameter" do
+      m = NMatrix.random([2,2], dtype: :byte, scale: 255)
+      m.each do |v|
+        expect(v).to be > 0
+        expect(v).to be < 255
+      end
+    end
 
-    m.stype.should == :dense
-    m.dtype.should == :float64
+    it "only accepts an integer or an array as dimension" do
+      m = NMatrix.random([2, 2])
 
-    expect { NMatrix.random(2.0) }.to raise_error
-    expect { NMatrix.random("not an array or integer") }.to raise_error
+      expect(m.stype).to eq(:dense)
+      expect(m.dtype).to eq(:float64)
+
+      expect { NMatrix.random(2.0) }.to raise_error
+      expect { NMatrix.random("not an array or integer") }.to raise_error
+    end
   end
 
   it "seq() creates a matrix of integers, sequentially" do
@@ -93,7 +111,7 @@ describe NMatrix do
 
     2.times do |i|
       2.times do |j|
-        m[i,j].should == value
+        expect(m[i,j]).to eq(value)
         value += 1
       end
     end
@@ -106,7 +124,7 @@ describe NMatrix do
 
     2.times do |i|
       2.times do |j|
-        m[i, j].should == value
+        expect(m[i, j]).to eq(value)
         value += 1
       end
     end
@@ -118,7 +136,7 @@ describe NMatrix do
 
     2.times do |i|
       2.times do |j|
-        (m[i, j]/10).should be_within(Float::EPSILON).of(value.to_f/10)
+        expect(m[i, j]/10).to be_within(Float::EPSILON).of(value.to_f/10)
         value += 1
       end
     end
@@ -130,7 +148,7 @@ describe NMatrix do
 
     2.times do |i|
       2.times do |j|
-        m[i, j].should == value
+        expect(m[i, j]).to eq(value)
         value += 1
       end
     end
@@ -142,8 +160,8 @@ describe NMatrix do
 
     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)
+        expect(m[i, j].real).to be_within(Float::EPSILON).of(value)
+        expect(m[i, j].imag).to be_within(Float::EPSILON).of(0.0)
         value += 1
       end
     end
@@ -152,28 +170,28 @@ describe NMatrix do
   it "column() returns a NMatrix" do
     m = NMatrix.random(3)
 
-    m.column(2).is_a?(NMatrix).should be_true
+    expect(m.column(2).is_a?(NMatrix)).to be_true
   end
 
   it "row() returns a NMatrix" do
     m = NMatrix.random(3)
 
-    m.row(2).is_a?(NMatrix).should be_true
+    expect(m.row(2).is_a?(NMatrix)).to be_true
   end
 
   it "diagonals() creates an NMatrix" do
     arr = [1,2,3,4]
     m = NMatrix.diagonals(arr)
-    m.is_a?(NMatrix).should be_true
+    expect(m.is_a?(NMatrix)).to be_true
   end
 
   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])
+    expect(m[0,0]).to eq(arr[0])
+    expect(m[1,1]).to eq(arr[1])
+    expect(m[2,2]).to eq(arr[2])
+    expect(m[3,3]).to eq(arr[3])
   end
 
   context "_like constructors" do
@@ -183,13 +201,13 @@ describe NMatrix do
     end
 
     it "should create an nmatrix of ones with dimensions and type the same as its argument" do
-      NMatrix.ones_like(@nm_1d).should eq NMatrix[1.0, 1.0, 1.0, 1.0, 1.0]
-      NMatrix.ones_like(@nm_2d).should eq NMatrix[[1.0, 1.0], [1.0, 1.0]]
+      expect(NMatrix.ones_like(@nm_1d)).to eq NMatrix[1.0, 1.0, 1.0, 1.0, 1.0]
+      expect(NMatrix.ones_like(@nm_2d)).to eq NMatrix[[1.0, 1.0], [1.0, 1.0]]
     end
 
     it "should create an nmatrix of zeros with dimensions and type the same as its argument" do
-      NMatrix.zeros_like(@nm_1d).should eq NMatrix[0.0, 0.0, 0.0, 0.0, 0.0]
-      NMatrix.zeros_like(@nm_2d).should eq NMatrix[[0.0, 0.0], [0.0, 0.0]]
+      expect(NMatrix.zeros_like(@nm_1d)).to eq NMatrix[0.0, 0.0, 0.0, 0.0, 0.0]
+      expect(NMatrix.zeros_like(@nm_2d)).to eq NMatrix[[0.0, 0.0], [0.0, 0.0]]
     end
   end
 
@@ -201,7 +219,7 @@ describe "NVector" do
     v = NVector.zeros(4)
 
     4.times do |i|
-      v[i].should == 0
+      expect(v[i]).to eq(0)
     end
   end
 
@@ -209,19 +227,19 @@ describe "NVector" do
     v = NVector.ones(3)
 
     3.times do |i|
-      v[i].should == 1
+      expect(v[i]).to eq(1)
     end
   end
 
   it "random() creates a vector of random numbers" do
     v = NVector.random(4)
-    v.dtype.should == :float64
-    v.stype.should == :dense
+    expect(v.dtype).to eq(:float64)
+    expect(v.stype).to eq(:dense)
   end
 
   it "seq() creates a vector of integers, sequentially" do
     v = NVector.seq(7)
-    v.should == NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6])
+    expect(v).to eq(NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6]))
   end
 
   it "seq() only accepts integers as dimension" do
@@ -233,32 +251,32 @@ describe "NVector" do
 
   it "indgen() creates a vector of integers as well as seq()" do
     v = NVector.indgen(7)
-    v.should == NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6])
+    expect(v).to eq(NMatrix.new([7,1], [0, 1, 2, 3, 4, 5, 6]))
   end
 
   it "findgen creates a vector of floats, sequentially" do
     v = NVector.findgen(2)
-    v.should == NMatrix.new([2,1], [0.0, 1.0])
+    expect(v).to eq(NMatrix.new([2,1], [0.0, 1.0]))
   end
 
   it "bindgen() creates a vector of bytes, sequentially" do
     v = NVector.bindgen(4)
-    v.should == NMatrix.new([4,1], [0, 1, 2, 3], dtype: :byte)
+    expect(v).to eq(NMatrix.new([4,1], [0, 1, 2, 3], dtype: :byte))
   end
 
   it "cindgen() creates a vector of complexes, sequentially" do
     v = NVector.cindgen(2)
-    v.should == NMatrix.new([2,1], [Complex(0.0, 0.0), Complex(1.0, 0.0)], dtype: :complex64)
+    expect(v).to eq(NMatrix.new([2,1], [Complex(0.0, 0.0), Complex(1.0, 0.0)], dtype: :complex64))
   end
 
   it "linspace() creates a vector with n values equally spaced between a and b" do
     v = NVector.linspace(0, 2, 5)
-    v.should == NMatrix.new([5,1], [0.0, 0.5, 1.0, 1.5, 2.0])
+    expect(v).to eq(NMatrix.new([5,1], [0.0, 0.5, 1.0, 1.5, 2.0]))
   end
 
   it "logspace() creates a vector with n values logarithmically spaced between decades 10^a and 10^b" do
     v = NVector.logspace(0, 3, 4)
-    v.should == NMatrix.new([4,1], [1.0, 10.0, 100.0, 1000.0])
+    expect(v).to eq(NMatrix.new([4,1], [1.0, 10.0, 100.0, 1000.0]))
   end
 end
 
@@ -268,6 +286,6 @@ describe "Inline constructor" do
     m = NMatrix.new([2, 2], [1, 4, 6, 7])
     n = NMatrix[[1, 4], [6, 7]]
 
-    m.should.eql? n
+    expect(m).to eq n
   end
 end

data/spec/slice_set_spec.rb

@@ -45,8 +45,8 @@ describe "Set slice operation" do
         if stype == :yale
           step "verify correct arrangement of Yale IJA and A arrays" do
             @m.extend NMatrix::YaleFunctions
-            @m.yale_ija.should == [4,6,8,10,1,2,0,2,0,1]
-            @m.yale_a.should   == [0,4,8,0, 1,2,3,5,6,7]
+            expect(@m.yale_ija).to eq([4,6,8,10,1,2,0,2,0,1])
+            expect(@m.yale_a).to   eq([0,4,8,0, 1,2,3,5,6,7])
           end
         end
 
@@ -54,30 +54,30 @@ describe "Set slice operation" do
           n = @m.clone
           old_val = @m[0,0]
           @m[0,0] = 100
-          @m[0,0].should == 100
+          expect(@m[0,0]).to eq(100)
           @m[0,0] = old_val
-          @m.should == n
+          expect(@m).to eq(n)
         end
 
         if stype == :yale
           n = @m.clone
           step "set a row of entries" do
             n[0,0..2] = 0
-            n[0,0..2].to_flat_array.should == [0,0,0]
-            n[1,0..2].to_flat_array.should == [3,4,5]
-            n[2,0..2].to_flat_array.should == [6,7,8]
+            expect(n[0,0..2].to_flat_array).to eq([0,0,0])
+            expect(n[1,0..2].to_flat_array).to eq([3,4,5])
+            expect(n[2,0..2].to_flat_array).to eq([6,7,8])
           end
 
           step "set a second row of entries" do
             n[2,0..2] = 0
-            n[2,0..2].to_flat_array.should == [0,0,0]
-            n[1,0..2].to_flat_array.should == [3,4,5]
+            expect(n[2,0..2].to_flat_array).to eq([0,0,0])
+            expect(n[1,0..2].to_flat_array).to eq([3,4,5])
           end
 
           step "reset both rows of entries" do
             n[0,0..2] = [0,1,2]
             n[2,0..2] = [6,7,8]
-            n.should == @m
+            expect(n).to eq(@m)
           end
         end
 
@@ -89,62 +89,62 @@ describe "Set slice operation" do
           m[0..1,0..1] = 100
 
           if stype == :yale
-            m.yale_ija.should == [4,   6,   8,   10,   1,   2,   0,   2,  0,  1]
-            m.yale_a.should   == [100, 100, 8,   0,   100,  2, 100,   5,  6,  7]
+            expect(m.yale_ija).to eq([4,   6,   8,   10,   1,   2,   0,   2,  0,  1])
+            expect(m.yale_a).to   eq([100, 100, 8,   0,   100,  2, 100,   5,  6,  7])
           end
 
-          m[0..1,0..1].should == slice_result_a
-          m[2,0..1].should == @m[2,0..1]
-          m[0..1,2].should == @m[0..1,2]
+          expect(m[0..1,0..1]).to eq(slice_result_a)
+          expect(m[2,0..1]).to eq(@m[2,0..1])
+          expect(m[0..1,2]).to eq(@m[0..1,2])
         end
 
         step "set upper left-hand 2x2 corner to 0" do
           m[0..1,0..1] = 0
           if stype == :yale
-            [4,5,6,8,2,2,0,1].should == m.yale_ija
-            [0,0,8,0,2,5,6,7].should == m.yale_a
+            expect([4,5,6,8,2,2,0,1]).to eq(m.yale_ija)
+            expect([0,0,8,0,2,5,6,7]).to eq(m.yale_a)
           end
 
-          m[0..1,0..1].should == slice_result_b
+          expect(m[0..1,0..1]).to eq(slice_result_b)
         end
 
         m = @m.clone
         step "set lower left-hand 2x2 corner to 100" do
           m[1..2,0..1] = 100
-          m[1..2,0..1].should == slice_result_a
-          m[0,0..1].should == @m[0,0..1]
-          m[1..2,2].should == @m[1..2,2]
+          expect(m[1..2,0..1]).to eq(slice_result_a)
+          expect(m[0,0..1]).to eq(@m[0,0..1])
+          expect(m[1..2,2]).to eq(@m[1..2,2])
         end
 
         step "set lower left-hand 2x2 corner to 0" do
           m[1..2,0..1] = 0
-          m[1..2,0..1].should == slice_result_b
+          expect(m[1..2,0..1]).to eq(slice_result_b)
         end
 
         m = @m.clone
         step "set lower right-hand 2x2 corner to 100" do
           m[1..2,1..2] = 100
-          m[1..2,1..2].should == slice_result_a
-          m[0,1..2].should == @m[0,1..2]
-          m[1..2,0].should == @m[1..2,0]
+          expect(m[1..2,1..2]).to eq(slice_result_a)
+          expect(m[0,1..2]).to eq(@m[0,1..2])
+          expect(m[1..2,0]).to eq(@m[1..2,0])
         end
 
         step "set lower right-hand 2x2 corner to 0" do
           m[1..2,1..2] = 0
-          m[1..2,1..2].should == slice_result_b
+          expect(m[1..2,1..2]).to eq(slice_result_b)
         end
 
         m = @m.clone
         step "set upper right-hand 2x2 corner to 100" do
           m[0..1,1..2] = 100
-          m[0..1,1..2].should == slice_result_a
-          m[2,1..2].should == @m[2,1..2]
-          m[0..1,0].should == @m[0..1,0]
+          expect(m[0..1,1..2]).to eq(slice_result_a)
+          expect(m[2,1..2]).to eq(@m[2,1..2])
+          expect(m[0..1,0]).to eq(@m[0..1,0])
         end
 
         step "set upper right-hand 2x2 corner to 0" do
           m[0..1,1..2] = 0
-          m[0..1,1..2].should == slice_result_b
+          expect(m[0..1,1..2]).to eq(slice_result_b)
         end
       end
 
@@ -152,7 +152,7 @@ describe "Set slice operation" do
         x = NMatrix.new(4, stype: :yale, dtype: :int16)
         x.extend NMatrix::YaleFunctions if stype == :yale
         x[1..3,1..3] = @m
-        x.to_flat_array.should == [0,0,0,0, 0,0,1,2, 0,3,4,5, 0,6,7,8]
+        expect(x.to_flat_array).to eq([0,0,0,0, 0,0,1,2, 0,3,4,5, 0,6,7,8])
       end
 
     end

data/spec/stat_spec.rb

@@ -39,43 +39,43 @@ describe "Statistical functions" do
         end
 
         it "behaves like Enumerable#reduce with no argument to reduce" do
-          @nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f.should eq 11 unless stype == :yale
-          @nm_2d.reduce_along_dim(1) { |acc, el| acc + el }.should eq NMatrix.new([2,1], [1.0, 5.0], stype: stype)
+          expect(@nm_1d.reduce_along_dim(0) { |acc, el| acc + el }.to_f).to eq 11 unless stype == :yale
+          expect(@nm_2d.reduce_along_dim(1) { |acc, el| acc + el }).to eq NMatrix.new([2,1], [1.0, 5.0], stype: stype)
         end
 
         it "should calculate the mean along the specified dimension" do
           unless stype == :yale then
             puts @nm_1d.mean
-            @nm_1d.mean.should eq NMatrix.new([1], [2.2], stype: stype, dtype: :float64)
+            expect(@nm_1d.mean).to eq NMatrix.new([1], [2.2], stype: stype, dtype: :float64)
           end
-          @nm_2d.mean.should eq NMatrix[[1.0,2.0], stype: stype]
-          @nm_2d.mean(1).should eq NMatrix[[0.5], [2.5], stype: stype]
+          expect(@nm_2d.mean).to eq NMatrix[[1.0,2.0], stype: stype]
+          expect(@nm_2d.mean(1)).to eq NMatrix[[0.5], [2.5], stype: stype]
         end
 
         it "should calculate the minimum along the specified dimension" do
-          @nm_1d.min.should eq 0.0 unless stype == :yale
-          @nm_2d.min.should eq NMatrix[[0.0, 1.0], stype: stype]
-          @nm_2d.min(1).should eq NMatrix[[0.0], [2.0], stype: stype]
+          expect(@nm_1d.min).to eq 0.0 unless stype == :yale
+          expect(@nm_2d.min).to eq NMatrix[[0.0, 1.0], stype: stype]
+          expect(@nm_2d.min(1)).to eq NMatrix[[0.0], [2.0], stype: stype]
         end
 
         it "should calculate the maximum along the specified dimension" do
-          @nm_1d.max.should eq 5.0  unless stype == :yale
-          @nm_2d.max.should eq NMatrix[[2.0, 3.0], stype: stype]
+          expect(@nm_1d.max).to eq 5.0  unless stype == :yale
+          expect(@nm_2d.max).to eq NMatrix[[2.0, 3.0], stype: stype]
         end
 
         it "should calculate the variance along the specified dimension" do
-          @nm_1d.variance.should eq NMatrix[3.7, stype: stype] unless stype == :yale
-          @nm_2d.variance(1).should eq NMatrix[[0.5], [0.5], stype: stype]
+          expect(@nm_1d.variance).to eq NMatrix[3.7, stype: stype] unless stype == :yale
+          expect(@nm_2d.variance(1)).to eq NMatrix[[0.5], [0.5], stype: stype]
         end
 
         it "should calculate the sum along the specified dimension" do
-          @nm_1d.sum.should eq NMatrix[11.0, stype: stype] unless stype == :yale
-          @nm_2d.sum.should eq NMatrix[[2.0, 4.0], stype: stype]
+          expect(@nm_1d.sum).to eq NMatrix[11.0, stype: stype] unless stype == :yale
+          expect(@nm_2d.sum).to eq NMatrix[[2.0, 4.0], stype: stype]
         end
 
         it "should calculate the standard deviation along the specified dimension" do
-          @nm_1d.std.should eq NMatrix[Math.sqrt(3.7), stype: stype] unless stype == :yale
-          @nm_2d.std(1).should eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)], stype: stype]
+          expect(@nm_1d.std).to eq NMatrix[Math.sqrt(3.7), stype: stype] unless stype == :yale
+          expect(@nm_2d.std(1)).to eq NMatrix[[Math.sqrt(0.5)], [Math.sqrt(0.5)], stype: stype]
         end
 
         it "should raise an ArgumentError when any invalid dimension is provided" do
@@ -84,9 +84,9 @@ describe "Statistical functions" do
         end
 
         it "should convert to float if it contains only a single element" do
-          NMatrix[4.0, stype: stype].to_f.should eq 4.0  unless stype == :yale
-          NMatrix[[[[4.0]]], stype: stype].to_f.should eq 4.0  unless stype == :yale
-          NMatrix[[4.0], stype: stype].to_f.should eq 4.0
+          expect(NMatrix[4.0, stype: stype].to_f).to eq 4.0  unless stype == :yale
+          expect(NMatrix[[[[4.0]]], stype: stype].to_f).to eq 4.0  unless stype == :yale
+          expect(NMatrix[[4.0], stype: stype].to_f).to eq 4.0
         end
 
         it "should raise an index error if it contains more than a single element" do
@@ -96,8 +96,8 @@ describe "Statistical functions" do
 
         it "should map a block to all elements" do
           #binding.pry if stype == :list
-          @nm_1d.map { |e| e ** 2 }.should eq NMatrix[25.0,0.0,1.0,4.0,9.0, stype: stype] unless stype == :yale
-          @nm_2d.map { |e| e ** 2 }.should eq NMatrix[[0.0,1.0],[4.0,9.0], stype: stype]
+          expect(@nm_1d.map { |e| e ** 2 }).to eq NMatrix[25.0,0.0,1.0,4.0,9.0, stype: stype] unless stype == :yale
+          expect(@nm_2d.map { |e| e ** 2 }).to eq NMatrix[[0.0,1.0],[4.0,9.0], stype: stype]
         end
 
         it "should map! a block to all elements in place" do
@@ -105,39 +105,39 @@ describe "Statistical functions" do
           unless stype == :yale then
             expected1 = @nm_1d.map &fct
             @nm_1d.map! &fct
-            @nm_1d.should eq expected1
+            expect(@nm_1d).to eq expected1
           end
           expected2 = @nm_2d.map &fct
           @nm_2d.map! &fct
-          @nm_2d.should eq expected2
+          expect(@nm_2d).to eq expected2
         end
 
         it "should return an enumerator for map without a block" do
-          @nm_2d.map.should be_a Enumerator
+          expect(@nm_2d.map).to be_a Enumerator
         end
 
         it "should return an enumerator for reduce without a block" do
-          @nm_2d.reduce_along_dim(0).should be_a Enumerator
+          expect(@nm_2d.reduce_along_dim(0)).to be_a Enumerator
         end
 
         it "should return an enumerator for each_along_dim without a block" do
-          @nm_2d.each_along_dim(0).should be_a Enumerator
+          expect(@nm_2d.each_along_dim(0)).to be_a Enumerator
         end
 
         it "should iterate correctly for map without a block" do
           en = @nm_1d.map unless stype == :yale
-          en.each { |e| e**2 }.should eq @nm_1d.map { |e| e**2 } unless stype == :yale
+          expect(en.each { |e| e**2 }).to eq @nm_1d.map { |e| e**2 } unless stype == :yale
           en = @nm_2d.map
-          en.each { |e| e**2 }.should eq @nm_2d.map { |e| e**2 }
+          expect(en.each { |e| e**2 }).to eq @nm_2d.map { |e| e**2 }
         end
 
         it "should iterate correctly for reduce without a block" do
           unless stype == :yale then
             en = @nm_1d.reduce_along_dim(0, 1.0)
-            en.each { |a, e| a+e }.to_f.should eq 12
+            expect(en.each { |a, e| a+e }.to_f).to eq 12
           end
           en = @nm_2d.reduce_along_dim(1, 1.0)
-          en.each { |a, e| a+e }.should eq NMatrix[[2.0],[6.0], stype: stype]
+          expect(en.each { |a, e| a+e }).to eq NMatrix[[2.0],[6.0], stype: stype]
         end
 
         it "should iterate correctly for each_along_dim without a block" do
@@ -145,31 +145,31 @@ describe "Statistical functions" do
             res = NMatrix.zeros_like(@nm_1d[0...1])
             en = @nm_1d.each_along_dim(0)
             en.each { |e| res += e }
-            res.to_f.should eq 11
+            expect(res.to_f).to eq 11
           end
           res = NMatrix.zeros_like (@nm_2d[0...2, 0])
           en = @nm_2d.each_along_dim(1)
           en.each { |e| res += e }
-          res.should eq NMatrix[[1.0], [5.0], stype: stype]
+          expect(res).to eq NMatrix[[1.0], [5.0], stype: stype]
         end
 
         it "should yield matrices of matching dtype for each_along_dim" do
           m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128, stype: stype)
           m.each_along_dim(1) do |sub_m|
-            sub_m.dtype.should eq :complex128
+            expect(sub_m.dtype).to eq :complex128
           end
         end
 
         it "should reduce to a matrix of matching dtype for reduce_along_dim" do
           m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128, stype: stype)
           m.reduce_along_dim(1) do |acc, sub_m|
-            sub_m.dtype.should eq :complex128
+            expect(sub_m.dtype).to eq :complex128
             acc
           end
 
           m = NMatrix.new([2,3], [1,2,3,3,4,5], dtype: :complex128, stype: stype)
           m.reduce_along_dim(1, 0.0) do |acc, sub_m|
-            sub_m.dtype.should eq :complex128
+            expect(sub_m.dtype).to eq :complex128
             acc
           end
         end
@@ -177,30 +177,30 @@ describe "Statistical functions" do
         it "should allow overriding the dtype for reduce_along_dim" do
           m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128]
           m.reduce_along_dim(1, 0.0, :float64) do |acc, sub_m|
-            acc.dtype.should eq :float64
+            expect(acc.dtype).to eq :float64
             acc
           end
 
           m = NMatrix[[1,2,3], [3,4,5], dtype: :complex128, stype: stype]
           m.reduce_along_dim(1, nil, :float64) do |acc, sub_m|
-            acc.dtype.should eq :float64
+            expect(acc.dtype).to eq :float64
             acc
           end
         end
 
         it "should convert integer dtypes to float when calculating mean" do
           m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
-          m.mean(0).dtype.should eq :float64
+          expect(m.mean(0).dtype).to eq :float64
         end
 
         it "should convert integer dtypes to float when calculating variance" do
           m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
-          m.variance(0).dtype.should eq :float64
+          expect(m.variance(0).dtype).to eq :float64
         end
 
         it "should convert integer dtypes to float when calculating standard deviation" do
           m = NMatrix[[1,2,3], [3,4,5], dtype: :int32, stype: stype]
-          m.std(0).dtype.should eq :float64
+          expect(m.std(0).dtype).to eq :float64
         end
       end
     end