nmatrix 0.1.0.rc1 → 0.1.0.rc2

data/spec/blas_spec.rb

@@ -46,15 +46,15 @@ describe NMatrix::BLAS do
         # These test results all come from actually running a matrix through BLAS. We use them to ensure that NMatrix's
         # version of these functions (for rationals) give similar results.
 
-        b[0].should == -1.quo(4)
-        b[1].should == 33.quo(4)
-        b[2].should == -13
+        expect(b[0]).to eq(-1.quo(4))
+        expect(b[1]).to eq(33.quo(4))
+        expect(b[2]).to eq(-13)
 
         NMatrix::BLAS::cblas_trsm(:row, :right, :upper, :transpose, :unit, 1, 3, 1.0, a, 3, b, 3)
 
-        b[0].should == -15.quo(2)
-        b[1].should == 5
-        b[2].should == -13
+        expect(b[0]).to eq(-15.quo(2))
+        expect(b[1]).to eq(5)
+        expect(b[2]).to eq(-13)
       end
     end
   end
@@ -77,11 +77,11 @@ describe NMatrix::BLAS do
         y = NMatrix.new([5,1], [-5,-4,-3,-2,-1], dtype: dtype)
         x, y = NMatrix::BLAS::rot(x, y, 1.quo(2), Math.sqrt(3).quo(2), -1)
 
-        x.should be_within(1e-4).of(
+        expect(x).to be_within(1e-4).of(
                    NMatrix.new([5,1], [-0.3660254037844386, -0.7320508075688772, -1.098076211353316, -1.4641016151377544, -1.8301270189221928], dtype: dtype)
                  )
 
-        y.should be_within(1e-4).of(
+        expect(y).to be_within(1e-4).of(
                    NMatrix.new([5,1], [-6.830127018922193, -5.464101615137754, -4.098076211353316, -2.732050807568877, -1.3660254037844386], dtype: dtype)
                  )
       end
@@ -99,16 +99,16 @@ describe NMatrix::BLAS do
         c,s = NMatrix::BLAS::rotg(ab)
 
         if [:float32, :float64].include?(dtype)
-          ab[0].should be_within(1e-6).of(-10)
-          ab[1].should be_within(1e-6).of(-5.quo(3))
-          c.should be_within(1e-6).of(-3.quo(5))
+          expect(ab[0]).to be_within(1e-6).of(-10)
+          expect(ab[1]).to be_within(1e-6).of(-5.quo(3))
+          expect(c).to be_within(1e-6).of(-3.quo(5))
         else
           pending "need correct test cases"
-          ab[0].should be_within(1e-6).of(10)
-          ab[1].should be_within(1e-6).of(5.quo(3))
-          c.should be_within(1e-6).of(3.quo(5))
+          expect(ab[0]).to be_within(1e-6).of(10)
+          expect(ab[1]).to be_within(1e-6).of(5.quo(3))
+          expect(c).to be_within(1e-6).of(3.quo(5))
         end
-        s.should be_within(1e-6).of(4.quo(5))
+        expect(s).to be_within(1e-6).of(4.quo(5))
       end
 
       # Note: this exposes gemm, not cblas_gemm (which is the unfriendly CBLAS no-error-checking version)
@@ -120,7 +120,7 @@ describe NMatrix::BLAS do
         r = NMatrix::BLAS.gemm(n, m) #, c)
         #c.should equal(r) # check that both are same memory address
 
-        r.should == NMatrix.new([4,2], [273,455,243,235,244,205,102,160], dtype: dtype)
+        expect(r).to eq(NMatrix.new([4,2], [273,455,243,235,244,205,102,160], dtype: dtype))
       end
 
 
@@ -133,13 +133,13 @@ describe NMatrix::BLAS do
 
       it "exposes asum" do
         x = NMatrix.new([4,1], [1,2,3,4], dtype: :float64)
-        NMatrix::BLAS.asum(x).should == 10.0
+        expect(NMatrix::BLAS.asum(x)).to eq(10.0)
       end
 
 
       it "exposes nrm2" do
         x = NMatrix.new([4,1], [2,-4,3,5], dtype: :float64)
-        NMatrix::BLAS.nrm2(x, 1, 3).should be_within(1e-10).of(5.385164807134504)
+        expect(NMatrix::BLAS.nrm2(x, 1, 3)).to be_within(1e-10).of(5.385164807134504)
       end
 
     end

data/spec/elementwise_spec.rb

@@ -50,15 +50,15 @@ describe NMatrix do
 
     it "should perform scalar math" do
       x = @n * 3
-      x[0,0].should == 52 * 3
-      x[0,1].should == 30 * 3
-      x[0,2].should == 5 * 3
-      x[1,1].should == 40 * 3
-      x[2,0].should == 6 * 3
+      expect(x[0,0]).to eq(52 * 3)
+      expect(x[0,1]).to eq(30 * 3)
+      expect(x[0,2]).to eq(5 * 3)
+      expect(x[1,1]).to eq(40 * 3)
+      expect(x[2,0]).to eq(6 * 3)
 
       r = NMatrix.new(3, stype: :yale, dtype: :int64)
       y = r + 3
-      y[0,0].should == 3
+      expect(y[0,0]).to eq(3)
     end
 
     it "should refuse to perform a dot operation on a yale with non-zero default" do
@@ -69,52 +69,52 @@ describe NMatrix do
     end
 
     it "should perform element-wise addition" do
-      (@n+@m).should == NMatrix.new(:dense, 3, [52,30,0,0,-8,0,6,0,0], :int64).cast(:yale, :int64)
+      expect(@n+@m).to eq(NMatrix.new(:dense, 3, [52,30,0,0,-8,0,6,0,0], :int64).cast(:yale, :int64))
     end
 
     it "should perform element-wise subtraction" do
-      (@n-@m).should == NMatrix.new(:dense, 3, [52,30,10,0,88,0,6,0,0], :int64).cast(:yale, :int64)
+      expect(@n-@m).to eq(NMatrix.new(:dense, 3, [52,30,10,0,88,0,6,0,0], :int64).cast(:yale, :int64))
     end
 
     it "should perform element-wise multiplication" do
       r = NMatrix.new(:dense, 3, [0,0,-25,0,-1920,0,0,0,0], :int64).cast(:yale, :int64)
       m = NMatrix.new(2, stype: :yale, dtype: :int64)
-      (@n*@m).should == r
+      expect(@n*@m).to eq(r)
     end
 
     it "should perform element-wise division" do
       r = NMatrix.new(:dense, 3, [52, 30, -2, 0, -1, 0, 6, 0, 0], :int64).cast(:yale, :int64)
-      (@n/(@m+1)).should == r
+      expect(@n/(@m+1)).to eq(r)
     end
 
     it "should perform element-wise modulo" do
       m = NMatrix.new(3, stype: :yale, dtype: :int64, default: 0) + 5
-      (@n % m).should == NMatrix.new(:dense, 3, [2,0,0,0,0,0,1,0,0], :int64).cast(:yale, :int64)
+      expect(@n % m).to eq(NMatrix.new(:dense, 3, [2,0,0,0,0,0,1,0,0], :int64).cast(:yale, :int64))
     end
 
     it "should handle element-wise equality (=~)" do
-      (@n =~ @m).should == NMatrix.new(:dense, 3, [false,false,false,true,false,true,false,true,true], :object).cast(:yale, :object, false)
+      expect(@n =~ @m).to eq(NMatrix.new(:dense, 3, [false,false,false,true,false,true,false,true,true], :object).cast(:yale, :object, false))
     end
 
     it "should handle element-wise inequality (!~)" do
-      (@n !~ @m).should == NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, true)
+      expect(@n !~ @m).to eq(NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, true))
     end
 
     it "should handle element-wise less-than (<)" do
-      (@m < @n).should == NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, true)
+      expect(@m < @n).to eq(NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, true))
     end
 
     it "should handle element-wise greater-than (>)" do
-      (@n > @m).should == NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, false)
+      expect(@n > @m).to eq(NMatrix.new(:dense, 3, [true,true,true,false,true,false,true,false,false], :object).cast(:yale, :object, false))
     end
 
     it "should handle element-wise greater-than-or-equals (>=)" do
-      (@n >= @m).should == NMatrix.new(:dense, 3, true, :object).cast(:yale,:object, true)
+      expect(@n >= @m).to eq(NMatrix.new(:dense, 3, true, :object).cast(:yale,:object, true))
     end
 
     it "should handle element-wise less-than-or-equals (<=)" do
       r = NMatrix.new(:dense, 3, [false,false,false,true,false,true,false,true,true], :object).cast(:yale, :object, false)
-      (@n <= @m).should == r
+      expect(@n <= @m).to eq(r)
     end
   end
 
@@ -130,13 +130,13 @@ describe NMatrix do
 
     it "should perform scalar math" do
       x = @n * 3
-      x[0,0].should == 52 * 3
-      x[1,1].should == 40 * 3
-      x[0,1].should == 0
+      expect(x[0,0]).to eq(52 * 3)
+      expect(x[1,1]).to eq(40 * 3)
+      expect(x[0,1]).to eq(0)
 
       r = NMatrix.new(3, stype: :list, default: 1)
       y = r + 3
-      y[0,0].should == 4
+      expect(y[0,0]).to eq(4)
     end
 
     it "should perform element-wise addition" do
@@ -144,26 +144,26 @@ describe NMatrix do
       r[0,0] = 52
       r[1,1] = -8
       q = @n + @m
-      q.should == r
+      expect(q).to eq(r)
     end
 
     it "should perform element-wise subtraction" do
       r = NMatrix.new(:dense, 2, [52, 0, 0, 88], :int64).cast(:list, :int64)
-      (@n-@m).should == r
+      expect(@n-@m).to eq(r)
     end
 
     it "should perform element-wise multiplication" do
       r = NMatrix.new(:dense, 2, [52, 0, 0, -1920], :int64).cast(:list, :int64)
       m = NMatrix.new(:list, 2, 1, :int64)
       m[1,1] = -48
-      (@n*m).should == r
+      expect(@n*m).to eq(r)
     end
 
     it "should perform element-wise division" do
       m = NMatrix.new(:list, 2, 1, :int64)
       m[1,1] = 2
       r = NMatrix.new(:dense, 2, [52, 0, 0, 20], :int64).cast(:list, :int64)
-      (@n/m).should == r
+      expect(@n/m).to eq(r)
     end
 
     it "should perform element-wise modulo" do
@@ -178,7 +178,7 @@ describe NMatrix do
       r[0,1] = true
       r[1,0] = true
 
-      (@n =~ @m).should == r
+      expect(@n =~ @m).to eq(r)
     end
 
     it "should handle element-wise inequality (!~)" do
@@ -186,29 +186,29 @@ describe NMatrix do
       r[0,0] = true
       r[1,1] = true
 
-      (@n !~ @m).should == r
+      expect(@n !~ @m).to eq(r)
     end
 
     it "should handle element-wise less-than (<)" do
-      (@n < @m).should == NMatrix.new(:list, 2, false, :object)
+      expect(@n < @m).to eq(NMatrix.new(:list, 2, false, :object))
     end
 
     it "should handle element-wise greater-than (>)" do
       r = NMatrix.new(:list, 2, false, :object)
       r[0,0] = true
       r[1,1] = true
-      (@n > @m).should == r
+      expect(@n > @m).to eq(r)
     end
 
     it "should handle element-wise greater-than-or-equals (>=)" do
-      (@n >= @m).should == NMatrix.new(:list, 2, true, :object)
+      expect(@n >= @m).to eq(NMatrix.new(:list, 2, true, :object))
     end
 
     it "should handle element-wise less-than-or-equals (<=)" do
       r = NMatrix.new(:list, 2, false, :object)
       r[0,1] = true
       r[1,0] = true
-      (@n <= @m).should == r
+      expect(@n <= @m).to eq(r)
     end
   end
 
@@ -219,7 +219,7 @@ describe NMatrix do
       end
 
       it "works for integers" do
-        (@n+1).should == NMatrix.new(:dense, 2, [2,3,4,5], :int64)
+        expect(@n+1).to eq(NMatrix.new(:dense, 2, [2,3,4,5], :int64))
       end
 
       #it "works for complex64" do
@@ -236,34 +236,34 @@ describe NMatrix do
 
       it "adds" do
         r = @n+@m
-        r.should == NMatrix.new(:dense, [2,2], [-3, 1, 3, 70], :int64)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [-3, 1, 3, 70], :int64))
       end
 
       it "subtracts" do
         r = @n-@m
-        r.should == NMatrix.new(:dense, [2,2], [5, 3, 3, -62], :int64)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [5, 3, 3, -62], :int64))
       end
 
       it "multiplies" do
         r = @n*@m
-        r.should == NMatrix.new(:dense, [2,2], [-4, -2, 0, 264], :int64)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [-4, -2, 0, 264], :int64))
       end
 
       it "divides in the Ruby way" do
         m = @m.clone
         m[1,0] = 3
         r = @n/m
-        r.should == NMatrix.new(:dense, [2,2], [-1, -2, 1, 0], :int64)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [-1, -2, 1, 0], :int64))
       end
 
       it "exponentiates" do
         r = @n ** 2
         # TODO: We might have problems with the dtype.
-        r.should == NMatrix.new(:dense, [2,2], [1, 4, 9, 16], :int64)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [1, 4, 9, 16], :int64))
       end
 
       it "modulo" do
-        (@n % (@m + 2)).should == NMatrix.new(:dense, [2,2], [-1, 0, 1, 4], :int64)
+        expect(@n % (@m + 2)).to eq(NMatrix.new(:dense, [2,2], [-1, 0, 1, 4], :int64))
       end
     end
 
@@ -275,33 +275,33 @@ describe NMatrix do
 
       it "equals" do
         r = @n =~ @m
-        r.should == NMatrix.new(:dense, [2,2], [false, false, true, false], :object)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [false, false, true, false], :object))
       end
 
       it "is not equal" do
         r = @n !~ @m
-        r.should == NMatrix.new(:dense, [2,2], [true, true, false, true], :object)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [true, true, false, true], :object))
       end
 
       it "is less than" do
         r = @n < @m
-        r.should == NMatrix.new(:dense, [2,2], false, :object)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], false, :object))
       end
 
       it "is greater than" do
         r = @n > @m
-        r.should == NMatrix.new(:dense, [2,2], [true, true, false, true], :object)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [true, true, false, true], :object))
       end
 
       it "is less than or equal to" do
         r = @n <= @m
-        r.should == NMatrix.new(:dense, [2,2], [false, false, true, false], :object)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [false, false, true, false], :object))
       end
 
       it "is greater than or equal to" do
         n = NMatrix.new(:dense, [2,2], [1, 2, 2, 4], :int64)
         r = n >= @m
-        r.should == NMatrix.new(:dense, [2,2], [true, true, false, true], :object)
+        expect(r).to eq(NMatrix.new(:dense, [2,2], [true, true, false, true], :object))
       end
     end
   end

data/spec/io_spec.rb

@@ -40,49 +40,56 @@ describe NMatrix::IO do
   end
 
   it "repacks a string" do
-    NMatrix::IO::Matlab.repack("hello", :miUINT8, :byte).should == "hello"
+    expect(NMatrix::IO::Matlab.repack("hello", :miUINT8, :byte)).to eq("hello")
   end
 
   it "creates yale from internal byte-string function" do
     ia = NMatrix::IO::Matlab.repack("\0\1\3\3\4", :miUINT8, :itype)
     ja = NMatrix::IO::Matlab.repack("\0\1\3\0\0\0\0\0\0\0\0", :miUINT8, :itype)
     n = NMatrix.new(:yale, [4,4], :byte, ia, ja, "\2\3\5\4", :byte)
-    n[0,0].should == 2
-    n[1,1].should == 3
-    n[1,3].should == 5
-    n[3,0].should == 4
-    n[2,2].should == 0
-    n[3,3].should == 0
+    expect(n[0,0]).to eq(2)
+    expect(n[1,1]).to eq(3)
+    expect(n[1,3]).to eq(5)
+    expect(n[3,0]).to eq(4)
+    expect(n[2,2]).to eq(0)
+    expect(n[3,3]).to eq(0)
   end
 
   it "reads MATLAB .mat file containing a single square sparse matrix" do
     # Note: same matrix as above
     n = NMatrix::IO::Matlab.load_mat("spec/4x4_sparse.mat")
-    n[0,0].should == 2
-    n[1,1].should == 3
-    n[1,3].should == 5
-    n[3,0].should == 4
-    n[2,2].should == 0
-    n[3,3].should == 0
+    expect(n[0,0]).to eq(2)
+    expect(n[1,1]).to eq(3)
+    expect(n[1,3]).to eq(5)
+    expect(n[3,0]).to eq(4)
+    expect(n[2,2]).to eq(0)
+    expect(n[3,3]).to eq(0)
   end
 
   it "reads MATLAB .mat file containing a single dense integer matrix" do
     n = NMatrix::IO::Matlab.load_mat("spec/4x5_dense.mat")
     m = NMatrix.new([4,5], [16,17,18,19,20,15,14,13,12,11,6,7,8,9,10,5,4,3,2,1])
-    n.should == m
+    expect(n).to eq(m)
   end
 
   it "reads MATLAB .mat file containing a single dense double matrix" do
     n = NMatrix::IO::Matlab.load_mat("spec/2x2_dense_double.mat")
     m = NMatrix.new(2, [1.1, 2.0, 3.0, 4.0], dtype: :float64)
-    n.should == m
+    expect(n).to eq(m)
   end
 
   it "loads and saves MatrixMarket .mtx file containing a single large sparse double matrix" do
     pending "spec disabled because it's so slow"
     n = NMatrix::IO::Market.load("spec/utm5940.mtx")
     NMatrix::IO::Market.save(n, "spec/utm5940.saved.mtx")
-    `wc -l spec/utm5940.mtx`.split[0].should == `wc -l spec/utm5940.saved.mtx`.split[0]
+    expect(`wc -l spec/utm5940.mtx`.split[0]).to eq(`wc -l spec/utm5940.saved.mtx`.split[0])
+  end
+
+  it "loads a Point Cloud Library PCD file" do
+    n = NMatrix::IO::PointCloud.load("spec/test.pcd")
+    expect(n.column(0).sort.uniq.size).to eq(1)
+    expect(n.column(0).sort.uniq.first).to eq(207.008)
+    expect(n[0,3]).to eq(0)
   end
 
   it "raises an error when reading a non-existent file" do
@@ -98,7 +105,7 @@ describe NMatrix::IO do
     n.write(@test_out)
 
     m = NMatrix.read(@test_out)
-    n.should == m
+    expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as symmetric" do
@@ -106,7 +113,7 @@ describe NMatrix::IO do
     n.write(@test_out, :symmetric)
 
     m = NMatrix.read(@test_out)
-    n.should == m
+    expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as skew" do
@@ -114,7 +121,7 @@ describe NMatrix::IO do
     n.write(@test_out, :skew)
 
     m = NMatrix.read(@test_out)
-    n.should == m
+    expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as hermitian" do
@@ -122,7 +129,7 @@ describe NMatrix::IO do
     n.write(@test_out, :hermitian)
 
     m = NMatrix.read(@test_out)
-    n.should == m
+    expect(n).to eq(m)
   end
 
   it "reads and writes NMatrix dense as upper" do
@@ -132,8 +139,8 @@ describe NMatrix::IO do
     m = NMatrix.new(:dense, 3, [-1,1,2,0,4,5,0,0,8], :int32) # lower version of the same
 
     o = NMatrix.read(@test_out)
-    o.should == m
-    o.should_not == n
+    expect(o).to eq(m)
+    expect(o).not_to eq(n)
   end
 
   it "reads and writes NMatrix dense as lower" do
@@ -143,7 +150,7 @@ describe NMatrix::IO do
     m = NMatrix.new(:dense, 3, [-1,0,0,3,4,0,6,7,8], :int32) # lower version of the same
 
     o = NMatrix.read(@test_out)
-    o.should == m
-    o.should_not == n
+    expect(o).to eq(m)
+    expect(o).not_to eq(n)
   end
 end