numo-linalg 0.1.2 → 0.1.3

data/spec/linalg/function/eigh_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'eigh' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_symmetric_mat(m) }
+    let(:mat_b) { rand_symmetric_mat(m) + 5.1 * Numo::DFloat.eye(m) } # for avoiding non-singular matrix
+    let(:mat_c) { rand_hermitian_mat(m) }
+    let(:mat_d) { rand_hermitian_mat(m) + 5.1 * Numo::DFloat.eye(m) } # for avoiding non-singular matrix
+
+    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 by solving eigenvalue problem for a symmetric matrix' do
+      v, w = described_class.eigh(mat_a)
+      r = w.transpose.dot(mat_a.dot(w))
+      r = r[r.diag_indices]
+      expect((v - r).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and eigenvectors by solving eigenvalue problem for a hermitian matrix' do
+      v, w = described_class.eigh(mat_c)
+      r = w.transpose.conj.dot(mat_c.dot(w))
+      r = r[r.diag_indices].real
+      expect((v - r).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and eigenvectors by solving generalized eigenvalue problem for symmetric matrices' do
+      v, w = described_class.eigh(mat_a, mat_b)
+      r = w.transpose.dot(mat_a.dot(w))
+      r = r[r.diag_indices]
+      e = w.transpose.dot(mat_b.dot(w))
+      e = e[e.diag_indices]
+      expect((v - r).abs.mean).to be < ERR_TOL
+      expect((Numo::DFloat.ones(m) - e).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and eigenvectors by solving generalized eigenvalue problem for hermitian matrices' do
+      v, w = described_class.eigh(mat_c, mat_d)
+      r = w.transpose.conj.dot(mat_c.dot(w))
+      r = r[r.diag_indices].real
+      e = w.transpose.conj.dot(mat_d.dot(w))
+      e = e[e.diag_indices].real
+      expect((v - r).abs.mean).to be < ERR_TOL
+      expect((Numo::DFloat.ones(m) - e).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and eigenvectors by solving generalized eigenvalue problem for symmetric and hermitian matrices' do
+      v, w = described_class.eigh(mat_a, mat_d)
+      r = w.transpose.conj.dot(mat_a.dot(w))
+      r = r[r.diag_indices].real
+      e = w.transpose.conj.dot(mat_d.dot(w))
+      e = e[e.diag_indices].real
+      expect((v - r).abs.mean).to be < ERR_TOL
+      expect((Numo::DFloat.ones(m) - e).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and eigenvectors for a symmetric matrix with divide and conquer algorithm' do
+      v, w = described_class.eigh(mat_a, turbo: true)
+      r = w.transpose.dot(mat_a.dot(w))
+      r = r[r.diag_indices]
+      expect((v - r).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues and eigenvectors in the range of the specified indices' do
+      v1, w1 = described_class.eigh(mat_a, mat_b)
+      v2, w2 = described_class.eigh(mat_a, mat_b, vals_range: 0...n)
+      r = w2.transpose.dot(mat_a.dot(w2))
+      r = r[r.diag_indices]
+      e = w2.transpose.dot(mat_b.dot(w2))
+      e = e[e.diag_indices]
+      expect((v2 - r).abs.mean).to be < ERR_TOL
+      expect((v1[0...n] - r).abs.mean).to be < ERR_TOL
+      expect((Numo::DFloat.ones(n) - e).abs.mean).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/eigvals_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'eigvals' do
+    let(:m) { 5 }
+    let(:mat_a) { Numo::DFloat.new(m, m).rand - 0.5 }
+    let(:mat_b) { mat_a + Complex::I * (Numo::DFloat.new(m, m).rand - 0.5) }
+
+    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 for a square nonsymmetric matrix' do
+      w1 = described_class.eigvals(mat_a)
+      w2, = described_class.eig(mat_a, left: false, right: false)
+      expect((w1 - w2).abs.max).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues for a square complex nonsymmetric matrix' do
+      w1 = described_class.eigvals(mat_b)
+      w2, = described_class.eig(mat_b, left: false, right: false)
+      expect((w1 - w2).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/eigvalsh_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'eigvash' do
+    let(:m) { 5 }
+    let(:n) { 3 }
+    let(:mat_a) { rand_symmetric_mat(m) }
+    let(:mat_b) { rand_symmetric_mat(m) + 5.1 * Numo::DFloat.eye(m) } # for avoiding non-singular matrix
+    let(:mat_c) { rand_hermitian_mat(m) }
+    let(:mat_d) { rand_hermitian_mat(m) + 5.1 * Numo::DFloat.eye(m) } # for avoiding non-singular matrix
+
+    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 by solving eigenvalue problem for a symmetric matrix' do
+      v1 = described_class.eigvalsh(mat_a)
+      v2, = described_class.eigh(mat_a)
+      expect((v1 - v2).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues by solving eigenvalue problem for a hermitian matrix' do
+      v1 = described_class.eigvalsh(mat_c)
+      v2, = described_class.eigh(mat_c)
+      expect((v1 - v2).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues by solving generalized eigenvalue problem for symmetric matrices' do
+      v1 = described_class.eigvalsh(mat_a, mat_b)
+      v2, = described_class.eigh(mat_a, mat_b)
+      expect((v1 - v2).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues by solving generalized eigenvalue problem for hermitian matrices' do
+      v1 = described_class.eigvalsh(mat_c, mat_d)
+      v2, = described_class.eigh(mat_c, mat_d)
+      expect((v1 - v2).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues by solving generalized eigenvalue problem for symmetric and hermitian matrices' do
+      v1 = described_class.eigvalsh(mat_a, mat_d)
+      v2, = described_class.eigh(mat_a, mat_d)
+      expect((v1 - v2).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues for a symmetric matrix with divide and conquer algorithm' do
+      v1 = described_class.eigvalsh(mat_a, turbo: true)
+      v2, = described_class.eigh(mat_a, turbo: true)
+      expect((v1 - v2).abs.mean).to be < ERR_TOL
+    end
+
+    it 'finds eigenvalues in the range of the specified indices' do
+      v1 = described_class.eigvalsh(mat_a, mat_b, vals_range: 0...n)
+      v2, = described_class.eigh(mat_a, mat_b, vals_range: 0...n)
+      expect((v1 - v2).abs.mean).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/inv_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'inv' do
+    let(:m) { 5 }
+    let(:mat_a) { rand_square_real_mat(m) }
+    let(:mat_b) { rand_square_complex_mat(m) }
+    let(:mat_s) { rand_symmetric_mat(m) }
+    let(:mat_h) { rand_hermitian_mat(m) }
+
+    it 'raises ArgumentError given a invalid driver option' do
+      expect { described_class.inv(mat_a, driver: 'foo') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates the inverse of a square real matrix solving linear equation' do
+      inv_mat_a = described_class.inv(mat_a, driver: 'gesv')
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a square complex matrix solving linear equation' do
+      inv_mat_b = described_class.inv(mat_b, driver: 'gesv')
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a symmetric matrix solving linear equation' do
+      inv_mat_s = described_class.inv(mat_s, driver: 'sysv')
+      expect((inv_mat_s.dot(mat_s) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a hermitian matrix solving linear equation' do
+      inv_mat_h = described_class.inv(mat_h, driver: 'hesv')
+      expect((inv_mat_h.dot(mat_h) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a square real matrix using the LU factorization' do
+      inv_mat_a = described_class.inv(mat_a, driver: 'getrf')
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a square complex matrix using the LU factorization' do
+      inv_mat_b = described_class.inv(mat_b, driver: 'getrf')
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a symmetric matrix using the LU factorization' do
+      inv_mat_s = described_class.inv(mat_s, driver: 'sytrf')
+      expect((inv_mat_s.dot(mat_s) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a hermitian matrix using the LU factorization' do
+      inv_mat_h = described_class.inv(mat_h, driver: 'hetrf')
+      expect((inv_mat_h.dot(mat_h) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/ldl_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'ldl' do
+    let(:m) { 5 }
+    let(:mat_s) { rand_symmetric_mat(m) }
+    let(:mat_c) { rand_symmetric_mat(m) + Complex::I * rand_symmetric_mat(m) }
+    let(:mat_h) { rand_hermitian_mat(m) }
+
+    it 'raises ShapeError given a vector' do
+      expect { described_class.ldl(Numo::DFloat.new(3).rand) }.to raise_error(Numo::NArray::ShapeError)
+    end
+
+    it 'raises ShapeError given a rectangular matrix' do
+      expect { described_class.ldl(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.ldl(mat_s, uplo: 'A') }.to raise_error(ArgumentError)
+    end
+
+    it 'calculates the LDLt or Bunch-Kaufman factorization of a symmetric real matrix' do
+      mat_u, mat_d, perm = described_class.ldl(mat_s, uplo: 'U')
+      expect((mat_s - mat_u.dot(mat_d.dot(mat_u.transpose))).abs.max).to be < ERR_TOL
+      expect(mat_u[perm, true].tril(-1)).to eq(Numo::DFloat.zeros(m, m))
+      mat_l, mat_d, perm = described_class.ldl(mat_s, uplo: 'L')
+      expect((mat_s - mat_l.dot(mat_d.dot(mat_l.transpose))).abs.max).to be < ERR_TOL
+      expect(mat_l[perm, true].triu(1)).to eq(Numo::DFloat.zeros(m, m))
+    end
+
+    it 'calculates the LDLt or Bunch-Kaufman factorization of a symmetric complex matrix' do
+      mat_u, mat_d, perm = described_class.ldl(mat_c, uplo: 'U', hermitian: false)
+      expect((mat_c - mat_u.dot(mat_d.dot(mat_u.transpose))).abs.max).to be < ERR_TOL
+      expect(mat_u[perm, true].tril(-1)).to eq(Numo::DComplex.zeros(m, m))
+      mat_l, mat_d, perm = described_class.ldl(mat_c, uplo: 'L', hermitian: false)
+      expect((mat_c - mat_l.dot(mat_d.dot(mat_l.transpose))).abs.max).to be < ERR_TOL
+      expect(mat_l[perm, true].triu(1)).to eq(Numo::DComplex.zeros(m, m))
+    end
+
+    it 'calculates the LDLt or Bunch-Kaufman factorization of a hermitian matrix' do
+      mat_u, mat_d, perm = described_class.ldl(mat_h, uplo: 'U')
+      expect((mat_h - mat_u.dot(mat_d.dot(mat_u.transpose.conj))).abs.max).to be < ERR_TOL
+      expect(mat_u[perm, true].tril(-1)).to eq(Numo::DComplex.zeros(m, m))
+      mat_l, mat_d, perm = described_class.ldl(mat_h, uplo: 'L')
+      expect((mat_h - mat_l.dot(mat_d.dot(mat_l.transpose.conj))).abs.max).to be < ERR_TOL
+      expect(mat_l[perm, true].triu(1)).to eq(Numo::DComplex.zeros(m, m))
+    end
+  end
+end

data/spec/linalg/function/lstsq_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'lstsq' do
+    #let(:m) { 5 }
+    #let(:n) { 3 }
+    let(:m) { 3 }
+    let(:n) { 8 }
+    let(:nrhs) { 2 }
+    let(:mat_a) { rand_rect_real_mat(m, n) }
+    let(:mat_b) { rand_rect_real_mat(m, nrhs) }
+    let(:vec_b) { rand_real_vec(m) }
+    let(:mat_c) { rand_rect_complex_mat(m, n) }
+    let(:mat_d) { rand_rect_complex_mat(m, nrhs) }
+    let(:vec_d) { rand_complex_vec(m) }
+
+    it 'raises ArgumentError given a invalid driver option' do
+      expect { described_class.lstsq(mat_a, vec_b, driver: 'foo') }.to raise_error(ArgumentError)
+    end
+
+    it 'solves a linear least square problem min||b-Ax|| using the singuar value decomposition' do
+      vec_x, = described_class.lstsq(mat_a, vec_b, driver: 'lss')
+      expect(((vec_b - mat_a.dot(vec_x))**2).sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_a, mat_b, driver: 'lss')
+      expect(((mat_b - mat_a.dot(mat_x))**2).sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_a, vec_d, driver: 'lss')
+      expect(((vec_d - mat_a.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_a, mat_d, driver: 'lss')
+      expect(((mat_d - mat_a.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_c, vec_d, driver: 'lss')
+      expect(((vec_d - mat_c.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_c, mat_d, driver: 'lss')
+      expect(((mat_d - mat_c.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_c, vec_b, driver: 'lss')
+      expect(((vec_b - mat_c.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_c, mat_b, driver: 'lss')
+      expect(((mat_b - mat_c.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+    end
+
+    it 'solves a linear least square problem min||b-Ax|| using the singuar value decomposition with divide and conquer method' do
+      vec_x, = described_class.lstsq(mat_a, vec_b, driver: 'lsd')
+      expect(((vec_b - mat_a.dot(vec_x))**2).sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_a, mat_b, driver: 'lsd')
+      expect(((mat_b - mat_a.dot(mat_x))**2).sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_a, vec_d, driver: 'lsd')
+      expect(((vec_d - mat_a.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_a, mat_d, driver: 'lsd')
+      expect(((mat_d - mat_a.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_c, vec_d, driver: 'lsd')
+      expect(((vec_d - mat_c.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_c, mat_d, driver: 'lsd')
+      expect(((mat_d - mat_c.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_c, vec_b, driver: 'lsd')
+      expect(((vec_b - mat_c.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_c, mat_b, driver: 'lsd')
+      expect(((mat_b - mat_c.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+    end
+
+    it 'solves a linear least square problem min||b-Ax|| using a complete orthogonal factorization of A' do
+      vec_x, = described_class.lstsq(mat_a, vec_b, driver: 'lsy')
+      expect(((vec_b - mat_a.dot(vec_x))**2).sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_a, mat_b, driver: 'lsy')
+      expect(((mat_b - mat_a.dot(mat_x))**2).sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_a, vec_d, driver: 'lsy')
+      expect(((vec_d - mat_a.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_a, mat_d, driver: 'lsy')
+      expect(((mat_d - mat_a.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_c, vec_d, driver: 'lsy')
+      expect(((vec_d - mat_c.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_c, mat_d, driver: 'lsy')
+      expect(((mat_d - mat_c.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+      vec_x, = described_class.lstsq(mat_c, vec_b, driver: 'lsy')
+      expect(((vec_b - mat_c.dot(vec_x))**2).abs.sum).to be < ERR_TOL
+      mat_x, = described_class.lstsq(mat_c, mat_b, driver: 'lsy')
+      expect(((mat_b - mat_c.dot(mat_x))**2).abs.sum(0).max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/lu_fact_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'lu_fact' 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) }
+
+    def permutation_mat(ipiv)
+      Numo::DFloat.eye(m).tap do |mat|
+        ipiv.to_a.each_with_index { |a, b| mat[[a - 1, b], true] = mat[[b, a - 1], true].dup }
+      end
+    end
+
+    it 'calculates the LU factorization of a rectangular real matrix' do
+      lu, ipiv = described_class.lu_fact(mat_a)
+      mat_l = lu.tril.tap { |mat| mat[mat.diag_indices(0)] = 1.0 }
+      mat_u = lu.triu[0...n, 0...n]
+      mat_p = permutation_mat(ipiv)
+      expect((mat_p.dot(mat_a) - mat_l.dot(mat_u)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the LU factorization of a rectangular complex matrix' do
+      lu, ipiv = described_class.lu_fact(mat_b)
+      mat_l = lu.tril.tap { |mat| mat[mat.diag_indices(0)] = 1.0 }
+      mat_u = lu.triu[0...n, 0...n]
+      mat_p = permutation_mat(ipiv)
+      expect((mat_p.dot(mat_b) - mat_l.dot(mat_u)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/lu_inv_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'lu_inv' do
+    let(:m) { 5 }
+    let(:mat_a) { rand_square_real_mat(m) }
+    let(:mat_b) { rand_square_complex_mat(m) }
+
+    it 'calculates the inverse of a square real matrix' do
+      inv_mat_a = described_class.inv(mat_a)
+      expect((inv_mat_a.dot(mat_a) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+
+    it 'calculates the inverse of a square complex matrix' do
+      inv_mat_b = described_class.inv(mat_b)
+      expect((inv_mat_b.dot(mat_b) - Numo::DFloat.eye(m)).abs.max).to be < ERR_TOL
+    end
+  end
+end

data/spec/linalg/function/lu_solve_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Numo::Linalg do
+  describe 'lu_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) }
+
+    it 'solves the linear equation A x = b with a square real matrix A' do
+      lu, ipiv = described_class.lu_fact(mat_a)
+      vec_x = described_class.lu_solve(lu, ipiv, vec_b)
+      expect((mat_a.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.lu_solve(lu, ipiv, mat_b)
+      expect((mat_a.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.lu_solve(lu, ipiv, vec_d)
+      expect((mat_a.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.lu_solve(lu, ipiv, 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
+      lu, ipiv = described_class.lu_fact(mat_c)
+      vec_x = described_class.lu_solve(lu, ipiv, vec_b)
+      expect((mat_c.dot(vec_x) - vec_b).abs.max).to be < ERR_TOL
+      mat_x = described_class.lu_solve(lu, ipiv, mat_b)
+      expect((mat_c.dot(mat_x) - mat_b).abs.max).to be < ERR_TOL
+      vec_x = described_class.lu_solve(lu, ipiv, vec_d)
+      expect((mat_c.dot(vec_x) - vec_d).abs.max).to be < ERR_TOL
+      mat_x = described_class.lu_solve(lu, ipiv, mat_d)
+      expect((mat_c.dot(mat_x) - mat_d).abs.max).to be < ERR_TOL
+    end
+  end
+end