numo-linalg 0.1.2 → 0.1.3

data/spec/linalg/function/lu_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'lu' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_rect_real_mat(m, n) }
+    let(:mat_b) { rand_rect_real_mat(n, m) }
+    let(:mat_c) { rand_rect_complex_mat(m, n) }
+    let(:mat_d) { rand_rect_complex_mat(n, m) }
+
+    it 'raises ShapeError given a vector' do
+      expect { described_class.lu(Numo::DFloat.new(3).rand) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'calculates the LU factorization of a rectangular real matrix' do
+      mat_p, mat_l, mat_u = described_class.lu(mat_a)
+      expect((mat_a - mat_p.dot(mat_l.dot(mat_u))).abs.max).to be < ERR_TOL
+      mat_p, mat_l, mat_u = described_class.lu(mat_b)
+      expect((mat_b - mat_p.dot(mat_l.dot(mat_u))).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the LU factorization of a rectangular real matrix including permutation of L' do
+      mat_l, mat_u = described_class.lu(mat_a, permute_l: true)
+      expect((mat_a - mat_l.dot(mat_u)).abs.max).to be < ERR_TOL
+      mat_l, mat_u = described_class.lu(mat_b, permute_l: true)
+      expect((mat_b - mat_l.dot(mat_u)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the LU factorization of a rectangular complex matrix' do
+      mat_p, mat_l, mat_u = described_class.lu(mat_c)
+      expect((mat_c - mat_p.dot(mat_l.dot(mat_u))).abs.max).to be < ERR_TOL
+      mat_p, mat_l, mat_u = described_class.lu(mat_d)
+      expect((mat_d - mat_p.dot(mat_l.dot(mat_u))).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the LU factorization of a rectangular complex matrix including permutation of L' do
+      mat_l, mat_u = described_class.lu(mat_c, permute_l: true)
+      expect((mat_c - mat_l.dot(mat_u)).abs.max).to be < ERR_TOL
+      mat_l, mat_u = described_class.lu(mat_d, permute_l: true)
+      expect((mat_d - mat_l.dot(mat_u)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/matmul_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'matmul' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    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 matrices' do
+      expect((described_class.matmul(mat_s, mat_s.transpose) - dot_mat_mat(mat_s, mat_s.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_s, mat_d.transpose) - dot_mat_mat(mat_s, mat_d.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_s, mat_c.transpose) - dot_mat_mat(mat_s, mat_c.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_s, mat_z.transpose) - dot_mat_mat(mat_s, mat_z.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_d, mat_d.transpose) - dot_mat_mat(mat_d, mat_d.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_d, mat_c.transpose) - dot_mat_mat(mat_d, mat_c.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_d, mat_z.transpose) - dot_mat_mat(mat_d, mat_z.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_c, mat_c.transpose) - dot_mat_mat(mat_c, mat_c.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_c, mat_z.transpose) - dot_mat_mat(mat_c, mat_z.transpose)).abs).to be < ERR_TOL
+      expect((described_class.matmul(mat_z, mat_z.transpose) - dot_mat_mat(mat_z, mat_z.transpose)).abs).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/matrix_power_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'matrix_power' do
+    let(:m) { 5 }
+    let(:mat_a) { rand_square_real_mat(m) }
+
+    it 'raises ShapeError given a rectangular matrix' do
+      expect { described_class.matrix_power(Numo::DFloat.new(2, 4).rand, 2) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'raises ArgumentError given a non-integer exponent' do
+      expect { described_class.matrix_power(Numo::DFloat.new(2, 2).rand, 0.5) }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates a square matrix to the n-th power' do
+      expect(described_class.matrix_power(mat_a, 0)).to eq(Numo::DFloat.eye(m))
+      pow_mat_a = described_class.matrix_power(mat_a, 2)
+      expect((pow_mat_a - mat_a.dot(mat_a)).abs.max).to be < ERR_TOL
+      pow_mat_a = described_class.matrix_power(mat_a, 5)
+      expect((pow_mat_a - (((mat_a.dot(mat_a)).dot(mat_a)).dot(mat_a)).dot(mat_a)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a square matrix' do
+      inv_mat_a = described_class.matrix_power(mat_a, -1)
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/matrix_rank_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'matrix_rank' do
+    let(:r) { 2 }
+    let(:m) { 6 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_rect_real_mat(m, r).dot(rand_rect_real_mat(r, n)) }
+    let(:mat_b) { rand_rect_complex_mat(m, r).dot(rand_rect_complex_mat(r, n)) }
+
+    it 'raises ArgumentError given a invalid driver option' do
+      expect { described_class.matrix_rank(mat_a, driver: 'foo') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculate the matrix rank of a real matrix' do
+      expect(described_class.matrix_rank(mat_a)).to eq(r)
+    end
+
+    it 'calculate the matrix rank of a real matrix with divide and conquer method' do
+      expect(described_class.matrix_rank(mat_a, driver: 'sdd')).to eq(r)
+    end
+
+    it 'calculate the matrix rank of a complex matrix' do
+      expect(described_class.matrix_rank(mat_b)).to eq(r)
+    end
+
+    it 'calculate the matrix rank of a complex matrix with divide and conquer method' do
+      expect(described_class.matrix_rank(mat_b, driver: 'sdd')).to eq(r)
+    end
+  end
+end

data/spec/linalg/function/norm_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'norm' do
+    let(:m) { 6 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_rect_real_mat(m, n) }
+    let(:mat_b) { rand_rect_complex_mat(m, n) }
+    let(:vec_a) { rand_real_vec(m) }
+    let(:vec_b) { rand_complex_vec(m) }
+    let(:vec_s) do
+      a = rand_real_vec(10)
+      a * (a > 0.0)
+    end
+    let(:vec_t) do
+      b = rand_real_vec(10) > 0.0
+      rand_complex_vec(10) * b
+    end
+
+    it 'raises ArgumentError given an invalid order option' do
+      expect { described_class.norm(mat_a, 0) }.to raise_error(ArgumentError)
+      expect { described_class.norm(mat_a, 5) }.to raise_error(ArgumentError)
+      expect { described_class.norm(mat_a, 'frobenius') }.to raise_error(ArgumentError)
+      expect { described_class.norm(vec_a, 'fro') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates the Froubenius norm of a real matrix' do
+      norm = Math.sqrt(mat_a.transpose.dot(mat_a).trace)
+      expect(described_class.norm(mat_a)).to be_within(norm).of(ERR_TOL)
+      expect(described_class.norm(mat_a, 'fro')).to be_within(norm).of(ERR_TOL)
+    end
+
+    it 'calculates the L1 norm of a real matrix' do
+      expect(described_class.norm(mat_a, 1)).to be_within(mat_a.abs.sum(axis: -2).max).of(ERR_TOL)
+    end
+
+    it 'calculates the L2 norm of a real matrix' do
+      expect(described_class.norm(mat_a, 2)).to be_within(described_class.svdvals(mat_a).max).of(ERR_TOL)
+    end
+
+    it 'calculates the inifinity norm of a real matrix' do
+      expect(described_class.norm(mat_a, 'inf')).to be_within(mat_a.abs.sum(axis: -1).max).of(ERR_TOL)
+    end
+
+    it 'calculates the Froubenius norm of a complex matrix' do
+      norm = Math.sqrt(mat_b.transpose.conj.dot(mat_b).trace.real)
+      expect(described_class.norm(mat_b)).to be_within(norm).of(ERR_TOL)
+      expect(described_class.norm(mat_b, 'fro')).to be_within(norm).of(ERR_TOL)
+    end
+
+    it 'calculates the L1 norm of a complex matrix' do
+      expect(described_class.norm(mat_b, 1)).to be_within(mat_b.abs.sum(axis: -2).max).of(ERR_TOL)
+    end
+
+    it 'calculates the L2 norm of a complex matrix' do
+      expect(described_class.norm(mat_b, 2)).to be_within(described_class.svdvals(mat_b).max).of(ERR_TOL)
+    end
+
+    it 'calculates the inifinity norm of a complex matrix' do
+      expect(described_class.norm(mat_b, 'inf')).to be_within(mat_b.abs.sum(axis: -1).max).of(ERR_TOL)
+    end
+
+    it 'calculates the L0 norm of a complex vector' do
+      expect(described_class.norm(vec_t, 0).real).to be_within((vec_t.abs.ne(0)).count).of(ERR_TOL)
+    end
+
+    it 'calculates the L1 norm of a complex vector' do
+      expect(described_class.norm(vec_b, 1)).to be_within(vec_b.abs.sum).of(ERR_TOL)
+    end
+
+    it 'calculates the L2 norm of a complex vector' do
+      expect(described_class.norm(vec_b, 2)).to be_within(Math.sqrt((vec_b.abs**2).sum)).of(ERR_TOL)
+    end
+
+    it 'calculates the infinity norm of a complex vector' do
+      expect(described_class.norm(vec_b, 'inf')).to be_within(vec_b.abs.max).of(ERR_TOL)
+    end
+  end
+end

data/spec/linalg/function/pinv_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'pinv' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_rect_real_mat(m, n) }
+    let(:mat_b) { rand_rect_complex_mat(m, n) }
+
+    it 'raises ArgumentError given a invalid driver option' do
+      expect { described_class.pinv(mat_a, driver: 'foo') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates the (Moore-Penrose) pseudo-inverse of a rectangular real matrix using svd' do
+      inv_mat_a = described_class.pinv(mat_a, driver: 'svd')
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+      inv_mat_a = described_class.pinv(mat_a, driver: 'sdd')
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the (Moore-Penrose) pseudo-inverse of a rectangular complex matrix using svd' do
+      inv_mat_b = described_class.pinv(mat_b, driver: 'svd')
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+      inv_mat_b = described_class.pinv(mat_b, driver: 'sdd')
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the (Moore-Penrose) pseudo-inverse of a rectangular real matrix using lstsq' do
+      inv_mat_a = described_class.pinv(mat_a, driver: 'lsd')
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+      inv_mat_a = described_class.pinv(mat_a, driver: 'lss')
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+      inv_mat_a = described_class.pinv(mat_a, driver: 'lsy')
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the (Moore-Penrose) pseudo-inverse of a rectangular complex matrix using lstsq' do
+      inv_mat_b = described_class.pinv(mat_b, driver: 'lsd')
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+      inv_mat_b = described_class.pinv(mat_b, driver: 'lss')
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+      inv_mat_b = described_class.pinv(mat_b, driver: 'lsy')
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/qr_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'qr' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_rect_real_mat(m, n) }
+    let(:mat_b) { rand_rect_complex_mat(m, n) }
+
+    it 'raises ArgumentError given a invalid mode option' do
+      expect { described_class.qr(Numo::DFloat.new(2, 4).rand, mode: 'foo') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates the QR factorization of a real matrix with reduce mode' do
+      q, r = described_class.qr(mat_a, mode: 'reduce')
+      expect((q.dot(r) - mat_a).abs.max).to be < ERR_TOL
+      expect((q.transpose.dot(q) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+      q, r = described_class.qr(mat_a.transpose, mode: 'reduce')
+      expect((q.dot(r) - mat_a.transpose).abs.max).to be < ERR_TOL
+      expect((q.transpose.dot(q) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the QR factorization of a complex matrix with reduce mode' do
+      q, r = described_class.qr(mat_b, mode: 'reduce')
+      expect((q.dot(r) - mat_b).abs.max).to be < ERR_TOL
+      expect((q.transpose.conj.dot(q) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+      q, r = described_class.qr(mat_b.transpose.conj, mode: 'reduce')
+      expect((q.dot(r) - mat_b.transpose.conj).abs.max).to be < ERR_TOL
+      expect((q.transpose.conj.dot(q) - Numo::DFloat.eye(n)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the QR factorization of a real matrix with r mode' do
+      q_, r = described_class.qr(mat_a, mode: 'reduce')
+      r2 = described_class.qr(mat_a, mode: 'r')
+      expect((r - r2).abs.max).to be < ERR_TOL
+      q_, r = described_class.qr(mat_a.transpose, mode: 'reduce')
+      r2 = described_class.qr(mat_a.transpose, mode: 'r')
+      expect((r - r2).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the QR factorization of a complex matrix with r mode' do
+      q_, r = described_class.qr(mat_b, mode: 'reduce')
+      r2 = described_class.qr(mat_b, mode: 'r')
+      expect((r - r2).abs.max).to be < ERR_TOL
+      q_, r = described_class.qr(mat_b.transpose.conj, mode: 'reduce')
+      r2 = described_class.qr(mat_b.transpose.conj, mode: 'r')
+      expect((r - r2).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the QR factorization of a real matrix with economic mode' do
+      q, r = described_class.qr(mat_a, mode: 'economic')
+      expect(q.shape[0]).to eq(m)
+      expect(q.shape[1]).to eq(n)
+      expect(r.shape[0]).to eq(n)
+      expect(r.shape[1]).to eq(n)
+      expect((q.dot(r) - mat_a).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the QR factorization of a complex matrix with economic mode' do
+      q, r = described_class.qr(mat_b, mode: 'economic')
+      expect(q.shape[0]).to eq(m)
+      expect(q.shape[1]).to eq(n)
+      expect(r.shape[0]).to eq(n)
+      expect(r.shape[1]).to eq(n)
+      expect((q.dot(r) - mat_b).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the QR factorization of a real matrix with raw mode' do
+      q_, r =  described_class.qr(mat_a)
+      q, tau = described_class.qr(mat_a, mode: 'raw')
+      expect((q.triu - r).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the QR factorization of a complex matrix with raw mode' do
+      q_, r =  described_class.qr(mat_b)
+      q, tau = described_class.qr(mat_b, mode: 'raw')
+      expect((q.triu - r).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/slogdet_spec.rb

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

data/spec/linalg/function/solve_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'solve' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_square_real_mat(m) }
+    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) }
+    let(:mat_s) { rand_symmetric_mat(m) }
+    let(:mat_h) { rand_hermitian_mat(m) }
+    let(:mat_p) { mat_s.dot(mat_s.transpose) }
+    let(:mat_q) { mat_h.dot(mat_h.transpose.conj) }
+
+    it 'raises ArgumentError given a invalid driver option' do
+      expect { described_class.solve(mat_a, vec_b, driver: 'foo') }.to raise_error(ArgumentError)
+    end
+
+    it 'raises ShapeError when the number of rows of matrices are different' do
+      expect { described_class.solve(mat_a, mat_b.transpose) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'raises ShapeError given a rectangular matrix as matrix A' do
+      expect { described_class.solve(mat_b, mat_a) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'solves the linear equation A x = b with a square real matrix A' do
+      vec_x = described_class.solve(mat_a, vec_b)
+      expect((mat_a.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_a, mat_b)
+      expect((mat_a.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.solve(mat_a, vec_d)
+      expect((mat_a.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_a, mat_d)
+      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 square complex matrix A' do
+      vec_x = described_class.solve(mat_c, vec_b)
+      expect((mat_c.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_c, mat_b)
+      expect((mat_c.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.solve(mat_c, vec_d)
+      expect((mat_c.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_c, mat_d)
+      expect((mat_c.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+    end
+
+    it 'solves the linear equation A x = b with a symmetric matrix A' do
+      vec_x = described_class.solve(mat_s, vec_b, driver: 'sym')
+      expect((mat_s.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_s, mat_b, driver: 'sym')
+      expect((mat_s.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.solve(mat_s, vec_d, driver: 'sym')
+      expect((mat_s.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_s, mat_d, driver: 'sym')
+      expect((mat_s.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+    end
+
+    it 'solves the linear equation A x = b with a hermitian matrix A' do
+      vec_x = described_class.solve(mat_h, vec_b, driver: 'her')
+      expect((mat_h.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_h, mat_b, driver: 'her')
+      expect((mat_h.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.solve(mat_h, vec_d, driver: 'her')
+      expect((mat_h.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_h, mat_d, driver: 'her')
+      expect((mat_h.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+    end
+
+    it 'solves the linear equation A x = b with a symmetric positive-definite matrix A' do
+      vec_x = described_class.solve(mat_p, vec_b, driver: 'pos')
+      expect((mat_p.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_p, mat_b, driver: 'pos')
+      expect((mat_p.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.solve(mat_p, vec_d, driver: 'pos')
+      expect((mat_p.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_p, mat_d, driver: 'pos')
+      expect((mat_p.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 A' do
+      vec_x = described_class.solve(mat_q, vec_b, driver: 'pos')
+      expect((mat_q.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_q, mat_b, driver: 'pos')
+      expect((mat_q.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.solve(mat_q, vec_d, driver: 'pos')
+      expect((mat_q.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.solve(mat_q, mat_d, driver: 'pos')
+      expect((mat_q.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+    end
+  end
+end