numo-linalg 0.1.2 → 0.1.3

data/lib/numo/linalg/loader.rb

@@ -16,24 +16,16 @@ module Numo
         if dir && !dir.empty?
           base = File.join(dir,base)
         end
-        path = base+".#{EXT}"
-        if NEED_VERSION_SUFFIX
-          if ver
-            path += ".#{ver}"
-          end
-          recvr.send(:dlopen,path)
-        else
+        if ver && EXT=='so'
           begin
+            path = "#{base}.#{EXT}.#{ver}"
             recvr.send(:dlopen,path)
-          rescue => e
-            if ver
-              path += ".#{ver}"
-              recvr.send(:dlopen,path)
-            else
-              raise e
-            end
+            return path
+          rescue
           end
         end
+        path = "#{base}.#{EXT}"
+        recvr.send(:dlopen,path)
         path
       end
       private :dlopen

data/lib/numo/linalg/version.rb

@@ -1,5 +1,5 @@
 module Numo
   module Linalg
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/numo-linalg.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
                         "ext/numo/linalg/lapack/extconf.rb"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake", "~> 0"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_runtime_dependency "numo-narray", ">= 0.9.0.7"
 end

data/spec/linalg/autoloader_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg::Autoloader do
+  it 'succeses loading backend libraries' do
+    expect { described_class.load_library }.to_not raise_error
+    expect(described_class.libs).to_not be_nil
+  end
+
+  describe 'private method' do
+    let(:autoloader) do
+      class DummyLoader
+        include Numo::Linalg::Autoloader
+      end
+      DummyLoader.new
+    end
+
+    it 'finds BLAS/LAPACK libraries' do
+      lapack_libs = autoloader.send(:find_lapack_libs, ['/usr/lib', '/usr/local/lib', '/usr/local/opt/lapack/lib'])
+      expect(lapack_libs[:blas]).to_not be_nil
+      expect(lapack_libs[:cblas]).to_not be_nil
+      expect(lapack_libs[:lapack]).to_not be_nil
+      expect(lapack_libs[:lapacke]).to_not be_nil
+    end
+  end
+end

data/spec/linalg/function/cho_fact_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'cho_fact' do
+    let(:m) { 5 }
+    let(:mat_a) do
+      a = rand_symmetric_mat(m)
+      a.dot(a.transpose)
+    end
+    let(:mat_b) do
+      b = rand_hermitian_mat(m)
+      b.dot(b.transpose.conj)
+    end
+
+    it 'calculates the cholesky factorization of a symmetric positive-definite matrix' do
+      mat_u = described_class.cho_fact(mat_a, uplo: 'U').triu
+      expect((mat_a - mat_u.transpose.dot(mat_u)).abs.max).to be < ERR_TOL
+      # mat_l = described_class.cho_fact(mat_a, uplo: 'L').tril
+      # expect((mat_a - mat_l.dot(mat_l.transpose)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the cholesky factorization of a hermitian positive-definite matrix' do
+      mat_u = described_class.cho_fact(mat_b, uplo: 'U').triu
+      expect((mat_b - mat_u.transpose.conj.dot(mat_u)).abs.max).to be < ERR_TOL
+      # mat_l = described_class.cho_fact(mat_b, uplo: 'L').tril
+      # expect((mat_b - mat_l.dot(mat_l.transpose)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/cho_inv_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'cho_inv' do
+    let(:m) { 5 }
+    let(:mat_a) do
+      a = rand_symmetric_mat(m)
+      a.dot(a.transpose)
+    end
+    let(:mat_b) do
+      b = rand_hermitian_mat(m)
+      b.dot(b.transpose.conj)
+    end
+
+    it 'calculates the inverse of a symmetric positive-definite matrix' do
+      mat_u = described_class.cho_fact(mat_a, uplo: 'U').triu
+      tri_inv_mat_a = described_class.cho_inv(mat_u, uplo: 'U')
+      inv_mat_a = tri_inv_mat_a + tri_inv_mat_a.transpose - tri_inv_mat_a.diagonal.diag
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+      # mat_l = described_class.cho_fact(mat_a, uplo: 'L').tril
+      # tri_inv_mat_a = described_class.cho_inv(mat_l, uplo: 'L')
+      # inv_mat_a = tri_inv_mat_a + tri_inv_mat_a.transpose - tri_inv_mat_a.diagonal.diag
+      # expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a hermitian positive-definite matrix' do
+      mat_u = described_class.cho_fact(mat_b, uplo: 'U').triu
+      tri_inv_mat_b = described_class.cho_inv(mat_u, uplo: 'U')
+      inv_mat_b = tri_inv_mat_b + tri_inv_mat_b.transpose.conj - tri_inv_mat_b.diagonal.diag
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+      # mat_l = described_class.cho_fact(mat_b, uplo: 'L').tril
+      # tri_inv_mat_b = described_class.cho_inv(mat_l, uplo: 'L')
+      # inv_mat_b = tri_inv_mat_b + tri_inv_mat_b.transpose.conj - tri_inv_mat_b.diagonal.diag
+      # expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/cho_solve_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'cho_solve' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:mat_a) do
+      a = rand_symmetric_mat(m)
+      a.dot(a.transpose)
+    end
+    let(:mat_h) do
+      b = rand_hermitian_mat(m)
+      b.dot(b.transpose.conj)
+    end
+    let(:mat_b) { rand_rect_real_mat(m, n) }
+    let(:vec_b) { rand_real_vec(m) }
+    let(:mat_c) { rand_square_complex_mat(m) }
+    let(:mat_d) { rand_rect_complex_mat(m, n) }
+    let(:vec_d) { rand_complex_vec(m) }
+
+
+    it 'solves the linear equation A x = b with a symmetric positive-definite matrix A' do
+      mat_u = described_class.cho_fact(mat_a, uplo: 'U').triu
+      vec_x = described_class.cho_solve(mat_u, vec_b, uplo: 'U')
+      expect((mat_a.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.cho_solve(mat_u, mat_b, uplo: 'U')
+      expect((mat_a.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.cho_solve(mat_u, vec_d, uplo: 'U')
+      expect((mat_a.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.cho_solve(mat_u, mat_d, uplo: 'U')
+      expect((mat_a.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+      # mat_l = described_class.cho_fact(mat_a, uplo: 'L').tril
+      # vec_x = described_class.cho_solve(mat_l, vec_b, uplo: 'L')
+      # expect((mat_a.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      # mat_x = described_class.cho_solve(mat_l, mat_b, uplo: 'L')
+      # expect((mat_a.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      # vec_x = described_class.cho_solve(mat_l, vec_d, uplo: 'L')
+      # expect((mat_a.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      # mat_x = described_class.cho_solve(mat_l, mat_d, uplo: 'L')
+      # expect((mat_a.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+    end
+
+    it 'solves the linear equation A x = b with a hermitian positive-definite matrix' do
+      mat_u = described_class.cho_fact(mat_h, uplo: 'U').triu
+      vec_x = described_class.cho_solve(mat_u, vec_b, uplo: 'U')
+      expect((mat_h.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.cho_solve(mat_u, mat_b, uplo: 'U')
+      expect((mat_h.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.cho_solve(mat_u, vec_d, uplo: 'U')
+      expect((mat_h.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.cho_solve(mat_u, mat_d, uplo: 'U')
+      expect((mat_h.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+      # mat_l = described_class.cho_fact(mat_h, uplo: 'L').tril
+      # vec_x = described_class.cho_solve(mat_l, vec_b, uplo: 'L')
+      # expect((mat_h.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      # mat_x = described_class.cho_solve(mat_l, mat_b, uplo: 'L')
+      # expect((mat_h.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      # vec_x = described_class.cho_solve(mat_l, vec_d, uplo: 'L')
+      # expect((mat_h.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      # mat_x = described_class.cho_solve(mat_l, mat_d, uplo: 'L')
+      # expect((mat_h.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/cholesky_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'cholesky' do
+    let(:m) { 5 }
+    let(:mat_a) do
+      a = rand_symmetric_mat(m)
+      a.dot(a.transpose)
+    end
+    let(:mat_b) do
+      b = rand_hermitian_mat(m)
+      b.dot(b.transpose.conj)
+    end
+
+    it 'raises ShapeError given a vector' do
+      expect { described_class.cholesky(Numo::DFloat.new(3).rand) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'raises ShapeError given a rectangular matrix' do
+      expect { described_class.cholesky(Numo::DFloat.new(2, 4).rand) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'raises ArgumentError given an invalid uplo option' do
+      expect { described_class.cholesky(mat_a, uplo: 'A') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates the cholesky factorization of a symmetric positive-definite matrix' do
+      mat_u = described_class.cholesky(mat_a, uplo: 'U')
+      expect((mat_a - mat_u.transpose.dot(mat_u)).abs.max).to be < ERR_TOL
+      mat_l = described_class.cholesky(mat_a, uplo: 'L')
+      expect((mat_a - mat_l.dot(mat_l.transpose)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the cholesky factorization of a hermitian positive-definite matrix' do
+      mat_u = described_class.cholesky(mat_b, uplo: 'U')
+      expect((mat_b - mat_u.transpose.conj.dot(mat_u)).abs.max).to be < ERR_TOL
+      mat_l = described_class.cholesky(mat_b, uplo: 'L')
+      expect((mat_b - mat_l.dot(mat_l.transpose.conj)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/cond_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'cond' do
+    let(:m) { 6 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_square_real_mat(m) }
+    let(:mat_b) { rand_square_complex_mat(m) }
+
+    def cond(mat, ord)
+      described_class.norm(mat, ord) * described_class.norm(described_class.inv(mat), ord)
+    end
+
+    it 'raises ArgumentError given an invalid order option' do
+      expect { described_class.cond(mat_a, 0) }.to raise_error(ArgumentError)
+      expect { described_class.cond(mat_a, 'frobenius') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates the condition number of a real matrix with Froubenius norm' do
+      expect(described_class.cond(mat_a, 'fro')).to be_within(cond(mat_a, 'fro')).of(ERR_TOL)
+    end
+
+    it 'calculates the condition number of a real matrix with L1 norm' do
+      expect(described_class.cond(mat_a, 1)).to be_within(cond(mat_a, 1)).of(ERR_TOL)
+    end
+
+    it 'calculates the condition number of a real matrix with L2 norm' do
+      condnum = cond(mat_a, 2)
+      expect(described_class.cond(mat_a)).to be_within(condnum).of(ERR_TOL)
+      expect(described_class.cond(mat_a, 2)).to be_within(condnum).of(ERR_TOL)
+    end
+
+    it 'calculates the condition number of a real matrix with inifinity norm' do
+      expect(described_class.cond(mat_a, 'inf')).to be_within(cond(mat_a, 'inf')).of(ERR_TOL)
+    end
+
+    it 'calculates the condition number of a complex matrix with Froubenius norm' do
+      expect(described_class.cond(mat_b, 'fro')).to be_within(cond(mat_b, 'fro')).of(ERR_TOL)
+    end
+
+    it 'calculates the condition number of a complex matrix with L1 norm' do
+      expect(described_class.cond(mat_b, 1)).to be_within(cond(mat_b, 1)).of(ERR_TOL)
+    end
+
+    it 'calculates the condition number of a complex matrix with L2 norm' do
+      condnum = cond(mat_b, 2)
+      expect(described_class.cond(mat_b)).to be_within(condnum).of(ERR_TOL)
+      expect(described_class.cond(mat_b, 2)).to be_within(condnum).of(ERR_TOL)
+    end
+
+    it 'calculates the condition number of a complex matrix with inifinity norm' do
+      expect(described_class.cond(mat_b, 'inf')).to be_within(cond(mat_b, 'inf')).of(ERR_TOL)
+    end
+  end
+end

data/spec/linalg/function/det_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'det' do
+    let(:m) { 5 }
+    let(:mat_a) { rand_square_real_mat(m) }
+    let(:mat_b) { rand_square_complex_mat(m) }
+
+    it 'calculates the dererminant of a square real matrix' do
+      det = described_class.eigvals(mat_a).prod.real
+      expect(described_class.det(mat_a)).to be_within(det).of(ERR_TOL)
+    end
+
+    it 'calculates the dererminant of a square complex matrix' do
+      det = described_class.eigvals(mat_b).prod
+      expect((described_class.det(mat_b) - det).abs).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/dot_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'dot' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:vec_s) { Numo::SFloat.new(m).rand }
+    let(:vec_d) { Numo::DFloat.new(m).rand }
+    let(:vec_c) { Numo::SComplex.new(m).rand }
+    let(:vec_z) { Numo::DComplex.new(m).rand }
+    let(:mat_s) { Numo::SFloat.new(m, n).rand }
+    let(:mat_d) { Numo::DFloat.new(m, n).rand }
+    let(:mat_c) { Numo::SComplex.new(m, n).rand }
+    let(:mat_z) { Numo::DComplex.new(m, n).rand }
+
+    def dot_vec_vec(a, b)
+      Array.new(a.size) { |idx| a[idx] * b[idx] }.reduce(&:+)
+    end
+
+    def dot_mat_vec(a, b)
+      n, = a.shape
+      Numo::NArray.asarray(Array.new(n) { |idx| dot_vec_vec(a[idx, true], b) })
+    end
+
+    def dot_mat_mat(a, b)
+      _m, n = b.shape
+      Numo::NArray.asarray(Array.new(n) { |idx| dot_mat_vec(a, b[true, idx]) })
+    end
+
+    it 'calculates the dot product of vectors' do
+      expect(described_class.dot(vec_s, vec_s)).to be_within(dot_vec_vec(vec_s, vec_s)).of(ERR_TOL)
+      expect(described_class.dot(vec_s, vec_d)).to be_within(dot_vec_vec(vec_s, vec_d)).of(ERR_TOL)
+      expect(described_class.dot(vec_d, vec_d)).to be_within(dot_vec_vec(vec_d, vec_d)).of(ERR_TOL)
+      expect((described_class.dot(vec_s, vec_c) - dot_vec_vec(vec_s, vec_c)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_s, vec_z) - dot_vec_vec(vec_s, vec_z)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_d, vec_c) - dot_vec_vec(vec_d, vec_c)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_d, vec_z) - dot_vec_vec(vec_d, vec_z)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_c, vec_c) - dot_vec_vec(vec_c, vec_c)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_c, vec_z) - dot_vec_vec(vec_c, vec_z)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_z, vec_z) - dot_vec_vec(vec_z, vec_z)).abs).to be < ERR_TOL
+    end
+
+    it 'calculates the dot product of matrices' do
+      expect((described_class.dot(mat_s, mat_s.transpose) - dot_mat_mat(mat_s, mat_s.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_s, mat_d.transpose) - dot_mat_mat(mat_s, mat_d.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_s, mat_c.transpose) - dot_mat_mat(mat_s, mat_c.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_s, mat_z.transpose) - dot_mat_mat(mat_s, mat_z.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_d, mat_d.transpose) - dot_mat_mat(mat_d, mat_d.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_d, mat_c.transpose) - dot_mat_mat(mat_d, mat_c.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_d, mat_z.transpose) - dot_mat_mat(mat_d, mat_z.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_c, mat_c.transpose) - dot_mat_mat(mat_c, mat_c.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_c, mat_z.transpose) - dot_mat_mat(mat_c, mat_z.transpose)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_z, mat_z.transpose) - dot_mat_mat(mat_z, mat_z.transpose)).abs).to be < ERR_TOL
+    end
+
+    it 'calculates the dot product of matrix and vector' do
+      expect((described_class.dot(mat_s.transpose, vec_s) - dot_mat_vec(mat_s.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_d.transpose, vec_s) - dot_mat_vec(mat_d.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_c.transpose, vec_s) - dot_mat_vec(mat_c.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_z.transpose, vec_s) - dot_mat_vec(mat_z.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_d.transpose, vec_d) - dot_mat_vec(mat_d.transpose, vec_d)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_c.transpose, vec_d) - dot_mat_vec(mat_c.transpose, vec_d)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_z.transpose, vec_d) - dot_mat_vec(mat_z.transpose, vec_d)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_c.transpose, vec_c) - dot_mat_vec(mat_c.transpose, vec_c)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_z.transpose, vec_c) - dot_mat_vec(mat_z.transpose, vec_c)).abs).to be < ERR_TOL
+      expect((described_class.dot(mat_z.transpose, vec_z) - dot_mat_vec(mat_z.transpose, vec_z)).abs).to be < ERR_TOL
+    end
+
+    it 'calculates the dot product of vector and matrix' do
+      expect((described_class.dot(vec_s, mat_s) - dot_mat_vec(mat_s.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_s, mat_d) - dot_mat_vec(mat_d.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_s, mat_c) - dot_mat_vec(mat_c.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_s, mat_z) - dot_mat_vec(mat_z.transpose, vec_s)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_d, mat_d) - dot_mat_vec(mat_d.transpose, vec_d)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_d, mat_c) - dot_mat_vec(mat_c.transpose, vec_d)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_d, mat_z) - dot_mat_vec(mat_z.transpose, vec_d)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_c, mat_c) - dot_mat_vec(mat_c.transpose, vec_c)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_c, mat_z) - dot_mat_vec(mat_z.transpose, vec_c)).abs).to be < ERR_TOL
+      expect((described_class.dot(vec_z, mat_z) - dot_mat_vec(mat_z.transpose, vec_z)).abs).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/eig_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+#
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'eig' do
+    let(:m) { 5 }
+    let(:mat_a) { rand_square_real_mat(m) }
+    let(:mat_b) { rand_square_complex_mat(m) }
+
+    it 'raises ShapeError given a rectangular matrix' do
+      expect { described_class.eigh(Numo::DFloat.new(2, 4).rand) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'finds eigenvalues and eigenvectors for a square nonsymmetric matrix' do
+      w, vl, vr = described_class.eig(mat_a, left: true, right: true)
+      expect(vl).not_to be_nil
+      expect(vr).not_to be_nil
+      expect((mat_a.dot(vr) - vr.dot(w.diag)).abs.max).to be < ERR_TOL
+      expect((vl.transpose.conj.dot(mat_a) - w.diag.dot(vl.transpose.conj)).abs.max).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and right eigenvectors for a square nonsymmetric matrix' do
+      w, vl, vr = described_class.eig(mat_a, left: false, right: true)
+      expect(vl).to be_nil
+      expect((mat_a.dot(vr) - vr.dot(w.diag)).abs.max).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and left eigenvectors for a square nonsymmetric matrix' do
+      w, vl, vr = described_class.eig(mat_a, left: true, right: false)
+      expect((vl.transpose.conj.dot(mat_a) - w.diag.dot(vl.transpose.conj)).abs.max).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and eigenvectors for a square complex nonsymmetric matrix' do
+      w, vl, vr = described_class.eig(mat_b, left: true, right: true)
+      expect(vl).not_to be_nil
+      expect(vr).not_to be_nil
+      expect((mat_b.dot(vr) - vr.dot(w.diag)).abs.max).to be < ERR_TOL
+      expect((vl.transpose.conj.dot(mat_b) - w.diag.dot(vl.transpose.conj)).abs.max).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and right eigenvectors for a square complex nonsymmetric matrix' do
+      w, vl, vr = described_class.eig(mat_b, left: false, right: true)
+      expect(vl).to be_nil
+      expect((mat_b.dot(vr) - vr.dot(w.diag)).abs.max).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and left eigenvectors for a square complex nonsymmetric matrix' do
+      w, vl, vr = described_class.eig(mat_b, left: true, right: false)
+      expect((vl.transpose.conj.dot(mat_b) - w.diag.dot(vl.transpose.conj)).abs.max).to be < ERR_TOL
+    end
+  end
+end