nmatrix 0.1.0 → 0.2.0

data/spec/math_spec.rb

@@ -28,16 +28,13 @@
 
 require 'spec_helper'
 
-ALL_DTYPES = [:byte,:int8,:int16,:int32,:int64, :float32,:float64, :object,
-  :rational32,:rational64,:rational128, :complex64, :complex128]
-
 describe "math" do
   context "elementwise math functions" do
 
     [:dense,:list,:yale].each do |stype|
       context stype do
 
-        [:int64,:float64,:rational128].each do |dtype|
+        [:int64,:float64].each do |dtype|
           context dtype do
             before :each do
               @size = [2,2]
@@ -146,7 +143,7 @@ describe "math" do
                       expect(@m.send(meth).integer_dtype?).to eq true
                     end
                   end
-                elsif dtype.to_s.match(/float/) or dtype.to_s.match(/rational/) 
+                elsif dtype.to_s.match(/float/)
                   it "should return dtype int64 for #{dtype}" do
 
                     expect(@m.send(meth)).to eq N.new(@size, @a.map { |e| e.send(meth) }, dtype: dtype, stype: stype)
@@ -177,13 +174,23 @@ describe "math" do
                 @ans  = @mat.to_a.flatten
               end
 
-              it "rounds #{dtype} for #{stype}" do
+              it "rounds" do
                 expect(@mat.round).to eq(N.new(@size, @ans.map { |a| a.round}, 
                   dtype: dtype, stype: stype))
               end unless(/complex/ =~ dtype)
 
-              it "rounds complex dtype #{dtype} for #{stype}" do
-                
+              it "rounds with args" do
+                expect(@mat.round(2)).to eq(N.new(@size, @ans.map { |a| a.round(2)}, 
+                  dtype: dtype, stype: stype))
+              end unless(/complex/ =~ dtype)
+
+              it "rounds complex with args" do
+                puts @mat.round(2)
+                expect(@mat.round(2)).to be_within(0.0001).of(N.new [2,2], @ans.map {|a| 
+                  Complex(a.real.round(2), a.imag.round(2))},dtype: dtype, stype: stype)
+              end if(/complex/ =~ dtype)
+
+              it "rounds complex" do
                 expect(@mat.round).to eq(N.new [2,2], @ans.map {|a| 
                   Complex(a.real.round, a.imag.round)},dtype: dtype, stype: stype)
               end if(/complex/ =~ dtype)
@@ -195,65 +202,139 @@ describe "math" do
     end
   end
 
-  [:float32, :float64, :complex64, :complex128, :rational32, :rational64, :rational128].each do |dtype|
+  NON_INTEGER_DTYPES.each do |dtype|
+    next if dtype == :object
     context dtype do
+      before do
+        @m = NMatrix.new([3,4], GETRF_EXAMPLE_ARRAY, dtype: dtype)
+        @err = case dtype
+                 when :float32, :complex64
+                   1e-6
+                 when :float64, :complex128
+                   1e-14
+               end
+      end
+
+      #haven't check this spec yet. Also it doesn't check all the elements of the matrix.
       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
-        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)
+        a = @m.factorize_lu
+        expect(a).to be_within(@err).of(NMatrix.new([3,4], GETRF_SOLUTION_ARRAY, dtype: dtype))
+      end
+
+      it "also returns the permutation matrix" do
+        a, p = @m.factorize_lu perm_matrix: true
+
+        expect(a).to be_within(@err).of(NMatrix.new([3,4], GETRF_SOLUTION_ARRAY, dtype: dtype))
+
+        p_true = NMatrix.new([3,3], [0,0,1,1,0,0,0,1,0], dtype: dtype)
+        expect(p).to eq(p_true)
       end
     end
+  end
 
+  NON_INTEGER_DTYPES.each do |dtype|
+    next if dtype == :object
     context dtype do
-      it "should correctly invert a matrix in place (bang)", :focus => true do
-        a = NMatrix.new(:dense, 3, [1,2,3,0,1,4,5,6,0], dtype)
-        b = NMatrix.new(:dense, 3, [-24,18,5,20,-15,-4,-5,4,1], dtype)
+
+      it "calculates cholesky decomposition using potrf (lower)" do
+        #a = NMatrix.new([3,3],[1,1,1, 1,2,2, 1,2,6], dtype: dtype)
+        # We use the matrix
+        # 1 1 1
+        # 1 2 2
+        # 1 2 6
+        # which is symmetric and positive-definite as required, but
+        # we need only store the lower-half of the matrix.
+        a = NMatrix.new([3,3],[1,0,0, 1,2,0, 1,2,6], dtype: dtype)
         begin
-          a.invert!
-        rescue NotImplementedError => e
-          if dtype.to_s =~ /rational/
-            pending "getri needs rational implementation"
-          else
-            pending e.to_s
-          end
+          r = a.potrf!(:lower)
+
+          b = NMatrix.new([3,3],[1,0,0, 1,1,0, 1,1,2], dtype: dtype)
+          expect(a).to eq(b)
+          expect(r).to eq(b)
+        rescue NotImplementedError
+          pending "potrf! not implemented without plugins"
+        end
+      end
+
+      it "calculates cholesky decomposition using potrf (upper)" do
+        a = NMatrix.new([3,3],[1,1,1, 0,2,2, 0,0,6], dtype: dtype)
+        begin
+          r = a.potrf!(:upper)
+
+          b = NMatrix.new([3,3],[1,1,1, 0,1,1, 0,0,2], dtype: dtype)
+          expect(a).to eq(b)
+          expect(r).to eq(b)
+        rescue NotImplementedError
+          pending "potrf! not implemented without plugins"
         end
-        expect(a.round).to eq(b)
       end
 
-      unless NMatrix.has_clapack?
-        it "should correctly invert a matrix in place" do
-          a = NMatrix.new(:dense, 5, [1, 8,-9, 7, 5, 
-                                      0, 1, 0, 4, 4, 
-                                      0, 0, 1, 2, 5, 
-                                      0, 0, 0, 1,-5,
-                                      0, 0, 0, 0, 1 ], dtype)
-          b = NMatrix.new(:dense, 5, [1,-8, 9, 7, 17,
-                                      0, 1, 0,-4,-24,
-                                      0, 0, 1,-2,-15,
-                                      0, 0, 0, 1,  5,
-                                      0, 0, 0, 0,  1,], dtype)
-          expect(a.invert).to eq(b)
+      it "calculates cholesky decomposition using #factorize_cholesky" do
+        a = NMatrix.new([3,3],[1,2,1, 2,13,5, 1,5,6], dtype: dtype)
+        begin
+          u,l = a.factorize_cholesky
+
+          l_true = NMatrix.new([3,3],[1,0,0, 2,3,0, 1,1,2], dtype: dtype)
+          u_true = l_true.transpose
+          expect(u).to eq(u_true)
+          expect(l).to eq(l_true)
+        rescue NotImplementedError
+          pending "potrf! not implemented without plugins"
+        end
+      end
+    end
+  end
+
+  ALL_DTYPES.each do |dtype|
+    next if dtype == :byte #doesn't work for unsigned types
+    next if dtype == :object
+
+    context dtype do
+      err = case dtype
+              when :float32, :complex64
+                1e-4
+              else #integer matrices will return :float64
+                1e-13
+            end
+
+      it "should correctly invert a matrix in place (bang)" do
+        a = NMatrix.new(:dense, 5, [1, 8,-9, 7, 5, 
+                                    0, 1, 0, 4, 4, 
+                                    0, 0, 1, 2, 5, 
+                                    0, 0, 0, 1,-5,
+                                    0, 0, 0, 0, 1 ], dtype)
+        b = NMatrix.new(:dense, 5, [1,-8, 9, 7, 17,
+                                    0, 1, 0,-4,-24,
+                                    0, 0, 1,-2,-15,
+                                    0, 0, 0, 1,  5,
+                                    0, 0, 0, 0,  1,], dtype)
+        if a.integer_dtype?
+          expect{a.invert!}.to raise_error(DataTypeError)
+        else
+          #should return inverse as well as modifying a
+          r = a.invert!
+          expect(a).to be_within(err).of(b)
+          expect(r).to be_within(err).of(b)
         end
       end
 
       it "should correctly invert a matrix out-of-place" do
         a = NMatrix.new(:dense, 3, [1,2,3,0,1,4,5,6,0], dtype)
-        b = NMatrix.new(:dense, 3, [-24,18,5,20,-15,-4,-5,4,1], dtype)
 
-        expect(a.invert(3,3)).to eq(b)
+        if a.integer_dtype?
+          b = NMatrix.new(:dense, 3, [-24,18,5,20,-15,-4,-5,4,1], :float64)
+        else
+          b = NMatrix.new(:dense, 3, [-24,18,5,20,-15,-4,-5,4,1], dtype)
+        end
+
+        expect(a.invert).to be_within(err).of(b)
       end
     end
   end
 
   # TODO: Get it working with ROBJ too
-  [: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|
+  [:byte,:int8,:int16,:int32,:int64,:float32,:float64].each do |left_dtype|
+    [:byte,:int8,:int16,:int32,:int64,:float32,:float64].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)
@@ -266,16 +347,12 @@ describe "math" do
 
         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
@@ -309,8 +386,8 @@ describe "math" do
     end
   end
 
-  [: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|
+  [:byte,:int8,:int16,:int32,:int64,:float32,:float64].each do |left_dtype|
+    [:byte,:int8,:int16,:int32,:int64,:float32,:float64].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)
@@ -343,4 +420,311 @@ describe "math" do
       end
     end
   end
+
+  ALL_DTYPES.each do |dtype|
+    next if integer_dtype?(dtype)
+    context "#cov dtype #{dtype}" do
+      before do 
+        @n = NMatrix.new( [5,3], [4.0,2.0,0.60,
+                                  4.2,2.1,0.59,
+                                  3.9,2.0,0.58,
+                                  4.3,2.1,0.62,
+                                  4.1,2.2,0.63], dtype: dtype)
+      end
+
+      it "calculates variance co-variance matrix (sample)" do
+        expect(@n.cov).to be_within(0.0001).of(NMatrix.new([3,3], 
+          [0.025  , 0.0075, 0.00175,
+           0.0075, 0.007 , 0.00135,
+           0.00175, 0.00135 , 0.00043 ], dtype: dtype)
+        )
+      end
+
+      it "calculates variance co-variance matrix (population)" do
+        expect(@n.cov(for_sample_data: false)).to be_within(0.0001).of(NMatrix.new([3,3], 
+                  [2.0000e-02, 6.0000e-03, 1.4000e-03,
+                   6.0000e-03, 5.6000e-03, 1.0800e-03,
+                   1.4000e-03, 1.0800e-03, 3.4400e-04], dtype: dtype)
+                )
+      end
+    end
+
+    context "#corr #{dtype}" do
+      it "calculates the correlation matrix" do
+        n = NMatrix.new([5,3], [4.0,2.0,0.60,
+                                4.2,2.1,0.59,
+                                3.9,2.0,0.58,
+                                4.3,2.1,0.62,
+                                4.1,2.2,0.63], dtype: dtype)
+        expect(n.corr).to be_within(0.001).of(NMatrix.new([3,3], 
+          [1.00000, 0.56695, 0.53374,
+           0.56695, 1.00000, 0.77813,
+           0.53374, 0.77813, 1.00000], dtype: dtype))
+      end unless dtype =~ /complex/
+    end
+
+    context "#symmetric? for #{dtype}" do
+      it "should return true for symmetric matrix" do 
+        n = NMatrix.new([3,3], [1.00000, 0.56695, 0.53374,
+                                0.56695, 1.00000, 0.77813,
+                                0.53374, 0.77813, 1.00000], dtype: dtype)
+        expect(n.symmetric?).to be_truthy
+      end
+    end
+
+    context "#hermitian? for #{dtype}" do
+      it "should return true for complex hermitian or non-complex symmetric matrix" do 
+        n = NMatrix.new([3,3], [1.00000, 0.56695, 0.53374,
+                                0.56695, 1.00000, 0.77813,
+                                0.53374, 0.77813, 1.00000], dtype: dtype) unless dtype =~ /complex/
+        n = NMatrix.new([3,3], [1.1, Complex(1.2,1.3), Complex(1.4,1.5),
+                                Complex(1.2,-1.3), 1.9, Complex(1.8,1.7),
+                                Complex(1.4,-1.5), Complex(1.8,-1.7), 1.3], dtype: dtype) if dtype =~ /complex/
+        expect(n.hermitian?).to be_truthy
+      end
+    end
+
+    context "#permute_columns for #{dtype}" do
+      it "check that #permute_columns works correctly by considering every premutation of a 3x3 matrix" do
+        n = NMatrix.new([3,3], [1,0,0,
+                                0,2,0,
+                                0,0,3], dtype: dtype)
+        expect(n.permute_columns([0,1,2], {convention: :intuitive})).to eq(NMatrix.new([3,3], [1,0,0,
+                                                                                              0,2,0,
+                                                                                              0,0,3], dtype: dtype))
+        expect(n.permute_columns([0,2,1], {convention: :intuitive})).to eq(NMatrix.new([3,3], [1,0,0,
+                                                                                              0,0,2,
+                                                                                              0,3,0], dtype: dtype))
+        expect(n.permute_columns([1,0,2], {convention: :intuitive})).to eq(NMatrix.new([3,3], [0,1,0,
+                                                                                              2,0,0,
+                                                                                              0,0,3], dtype: dtype))
+        expect(n.permute_columns([1,2,0], {convention: :intuitive})).to eq(NMatrix.new([3,3], [0,0,1,
+                                                                                              2,0,0,
+                                                                                              0,3,0], dtype: dtype))
+        expect(n.permute_columns([2,0,1], {convention: :intuitive})).to eq(NMatrix.new([3,3], [0,1,0,
+                                                                                              0,0,2,
+                                                                                              3,0,0], dtype: dtype))
+        expect(n.permute_columns([2,1,0], {convention: :intuitive})).to eq(NMatrix.new([3,3], [0,0,1,
+                                                                                              0,2,0,
+                                                                                              3,0,0], dtype: dtype))
+        expect(n.permute_columns([0,1,2], {convention: :lapack})).to eq(NMatrix.new([3,3], [1,0,0,
+                                                                                           0,2,0,
+                                                                                           0,0,3], dtype: dtype))
+        expect(n.permute_columns([0,2,2], {convention: :lapack})).to eq(NMatrix.new([3,3], [1,0,0,
+                                                                                           0,0,2,
+                                                                                           0,3,0], dtype: dtype))
+        expect(n.permute_columns([1,1,2], {convention: :lapack})).to eq(NMatrix.new([3,3], [0,1,0,
+                                                                                           2,0,0,
+                                                                                           0,0,3], dtype: dtype))
+        expect(n.permute_columns([1,2,2], {convention: :lapack})).to eq(NMatrix.new([3,3], [0,0,1,
+                                                                                           2,0,0,
+                                                                                           0,3,0], dtype: dtype))
+        expect(n.permute_columns([2,2,2], {convention: :lapack})).to eq(NMatrix.new([3,3], [0,1,0,
+                                                                                           0,0,2,
+                                                                                           3,0,0], dtype: dtype))
+        expect(n.permute_columns([2,1,2], {convention: :lapack})).to eq(NMatrix.new([3,3], [0,0,1,
+                                                                                           0,2,0,
+                                                                                           3,0,0], dtype: dtype))
+      end
+      it "additional tests for  #permute_columns with convention :intuitive" do
+        m = NMatrix.new([1,4], [0,1,2,3], dtype: dtype)
+        perm = [1,0,3,2]
+        expect(m.permute_columns(perm, {convention: :intuitive})).to eq(NMatrix.new([1,4], perm, dtype: dtype))
+
+        m = NMatrix.new([1,5], [0,1,2,3,4], dtype: dtype)
+        perm = [1,0,4,3,2]
+        expect(m.permute_columns(perm, {convention: :intuitive})).to eq(NMatrix.new([1,5], perm, dtype: dtype))
+
+        m = NMatrix.new([1,6], [0,1,2,3,4,5], dtype: dtype)
+        perm = [2,4,1,0,5,3]
+        expect(m.permute_columns(perm, {convention: :intuitive})).to eq(NMatrix.new([1,6], perm, dtype: dtype))
+
+        m = NMatrix.new([1,7], [0,1,2,3,4,5,6], dtype: dtype)
+        perm = [1,3,5,6,0,2,4]
+        expect(m.permute_columns(perm, {convention: :intuitive})).to eq(NMatrix.new([1,7], perm, dtype: dtype))
+
+        m = NMatrix.new([1,8], [0,1,2,3,4,5,6,7], dtype: dtype)
+        perm = [6,7,5,4,1,3,0,2]
+        expect(m.permute_columns(perm, {convention: :intuitive})).to eq(NMatrix.new([1,8], perm, dtype: dtype))
+      end
+    end
+  end
+
+  context "#solve" do
+    NON_INTEGER_DTYPES.each do |dtype|
+      next if dtype == :object # LU factorization doesnt work for :object yet
+      it "solves linear equation for dtype #{dtype}" do
+        a = NMatrix.new [2,2], [3,1,1,2], dtype: dtype
+        b = NMatrix.new [2,1], [9,8], dtype: dtype
+
+        expect(a.solve(b)).to eq(NMatrix.new [2,1], [2,3], dtype: dtype)
+      end
+
+      it "solves linear equation for #{dtype} (non-symmetric matrix)" do
+        a = NMatrix.new [3,3], [1,1,1, -1,0,1, 3,4,6], dtype: dtype
+        b = NMatrix.new [3,1], [6,2,29], dtype: dtype
+
+        err = case dtype
+                when :float32, :complex64
+                  1e-5
+                else
+                  1e-14
+              end
+
+        expect(a.solve(b)).to be_within(err).of(NMatrix.new([3,1], [1,2,3], dtype: dtype))
+      end
+
+      it "solves linear equation for dtype #{dtype} (non-vector rhs)" do
+        a = NMatrix.new [3,3], [1,0,0, -1,0,1, 2,1,1], dtype: dtype
+        b = NMatrix.new [3,2], [1,0, 1,2, 4,2], dtype: dtype
+
+        expect(a.solve(b)).to eq(NMatrix.new [3,2], [1,0, 0,0, 2,2], dtype: dtype)
+      end
+    end
+  end
+
+  context "#hessenberg" do
+    FLOAT_DTYPES.each do |dtype|
+      context dtype do
+        before do
+          @n = NMatrix.new [5,5], 
+            [0, 2, 0, 1, 1,
+             2, 2, 3, 2, 2,
+             4,-3, 0, 1, 3,
+             6, 1,-6,-5, 4,
+             5, 6, 4, 1, 5], dtype: dtype
+        end
+
+        it "transforms a matrix to Hessenberg form" do
+          expect(@n.hessenberg).to be_within(0.0001).of(NMatrix.new([5,5],    
+            [0.00000,-1.66667, 0.79432,-0.45191,-1.54501,
+            -9.00000, 2.95062,-6.89312, 3.22250,-0.19012,
+             0.00000,-8.21682,-0.57379, 5.26966,-1.69976,
+             0.00000, 0.00000,-3.74630,-0.80893, 3.99708,
+             0.00000, 0.00000, 0.00000, 0.04102, 0.43211], dtype: dtype))
+        end
+      end
+    end
+  end
+
+  ALL_DTYPES.each do |dtype|
+    [:dense, :yale].each do |stype|
+      answer_dtype = integer_dtype?(dtype) ? :int64 : dtype
+      next if dtype == :byte
+      
+      context "#pow #{dtype} #{stype}" do
+        before do 
+          @n = NMatrix.new [4,4], [0, 2, 0, 1,
+                                  2, 2, 3, 2,
+                                  4,-3, 0, 1,
+                                  6, 1,-6,-5], dtype: dtype, stype: stype
+        end
+
+        it "raises a square matrix to even power" do
+          expect(@n.pow(4)).to eq(NMatrix.new([4,4], [292, 28,-63, -42, 
+                                                     360, 96, 51, -14,
+                                                     448,-231,-24,-87,
+                                                   -1168, 595,234, 523], 
+                                                   dtype: answer_dtype, 
+                                                   stype: stype))
+        end
+
+        it "raises a square matrix to odd power" do
+          expect(@n.pow(9)).to eq(NMatrix.new([4,4],[-275128,  279917, 176127, 237451,
+                                                    -260104,  394759, 166893,  296081,
+                                                    -704824,  285700, 186411,  262002,
+                                                    3209256,-1070870,-918741,-1318584],
+                                                    dtype: answer_dtype, stype: stype))
+        end
+
+        it "raises a sqaure matrix to negative power" do
+          expect(@n.pow(-3)).to be_within(0.00001).of (NMatrix.new([4,4],
+            [1.0647e-02, 4.2239e-04,-6.2281e-05, 2.7680e-03,
+            -1.6415e-02, 2.1296e-02, 1.0718e-02, 4.8589e-03,   
+             8.6956e-03,-8.6569e-03, 2.8993e-02, 7.2015e-03,
+             5.0034e-02,-1.7500e-02,-3.6777e-02,-1.2128e-02], dtype: answer_dtype, 
+             stype: stype)) 
+        end unless stype =~ /yale/ or dtype == :object or ALL_DTYPES.grep(/int/).include? dtype
+
+        it "raises a square matrix to zero" do
+          expect(@n.pow(0)).to eq(NMatrix.eye([4,4], dtype: answer_dtype, 
+            stype: stype))
+        end
+
+        it "raises a square matrix to one" do
+          expect(@n.pow(1)).to eq(@n)
+        end
+      end
+    end
+  end
+
+  ALL_DTYPES.each do |dtype|
+    [:dense, :yale].each do |stype|
+      context "#kron_prod #{dtype} #{stype}" do
+        before do 
+          @a = NMatrix.new([2,2], [1,2,
+                                   3,4], dtype: dtype, stype: stype)
+          @b = NMatrix.new([2,3], [1,1,1,
+                                   1,1,1], dtype: dtype, stype: stype)
+          @c = NMatrix.new([4,6], [1, 1, 1, 2, 2, 2,
+                                   1, 1, 1, 2, 2, 2,
+                                   3, 3, 3, 4, 4, 4,
+                                   3, 3, 3, 4, 4, 4], dtype: dtype, stype: stype) 
+        end
+        it "Compute the Kronecker product of two NMatrix" do
+          expect(@a.kron_prod(@b)).to eq(@c)
+        end
+      end
+    end
+  end
+
+  context "determinants" do
+    ALL_DTYPES.each do |dtype|
+      next if dtype == :object
+      context dtype do
+        before do
+          @a = NMatrix.new([2,2], [1,2,
+                                   3,4], dtype: dtype)
+          @b = NMatrix.new([3,3], [1,2,3,
+                                   5,0,1,
+                                   4,1,3], dtype: dtype)
+          @c = NMatrix.new([4,4], [1, 0, 1, 1,
+                                   1, 2, 3, 1,
+                                   3, 3, 3, 1,
+                                   1, 2, 3, 4], dtype: dtype)
+          @err = case dtype
+                  when :float32, :complex64
+                    1e-6
+                  when :float64, :complex128
+                    1e-14
+                  else
+                    1e-64 # FIXME: should be 0, but be_within(0) does not work.
+                end
+        end
+        it "computes the determinant of 2x2 matrix" do
+          expect(@a.det).to be_within(@err).of(-2)
+        end
+        it "computes the determinant of 3x3 matrix" do
+          expect(@b.det).to be_within(@err).of(-8)
+        end
+        it "computes the determinant of 4x4 matrix" do
+          expect(@c.det).to be_within(@err).of(-18)
+        end
+        it "computes the exact determinant of 2x2 matrix" do
+          if dtype == :byte
+            expect{@a.det_exact}.to raise_error(DataTypeError)
+          else
+            expect(@a.det_exact).to be_within(@err).of(-2)
+          end
+        end
+        it "computes the exact determinant of 3x3 matrix" do
+          if dtype == :byte
+            expect{@a.det_exact}.to raise_error(DataTypeError)
+          else
+            expect(@b.det_exact).to be_within(@err).of(-8)
+          end
+        end
+      end
+    end
+  end
 end