Refactor error handling and rename type aliases

- Replace custom `assert` function with Julia's built-in `@assert` macro
- Update error type from `LinearAlgebraError` to standard `AssertionError`
- Rename type aliases for LU factorization and partial pivoting LU factorization
- Simplify variable names in kernel methods
- Update test cases to expect `AssertionError`

Author: yangjunjie0320

src/SimpleLinearAlgebra.jl

@@ -14,14 +14,6 @@ module SimpleLinearAlgebra
         message::String
     end
 
-    function assert(obj, condition::Bool, message::String)
-        if !condition
-            cls = split(string(typeof(obj)), ".")[2]
-            message = @sprintf("%s failed: %s", cls, message)
-            LinearAlgebraError(message) |> throw
-        end
-    end
-
     include("forward-substitution.jl")
     include("back-substitution.jl")
     include("lu-factorization.jl")

src/back-substitution.jl

@@ -5,7 +5,7 @@ struct BackSubstitutionProblem <: ProblemMixin
 
     function BackSubstitutionProblem(u, b, tol)
         prob = new(u, b, tol)
-        assert(prob, istriu(u), "matrix must be upper triangular")
+        @assert istriu(u) "matrix must be upper triangular"
         return prob
     end
 end
@@ -26,7 +26,7 @@ function kernel(prob::BackSubstitutionProblem)
     x = zeros(n)
 
     for i in n:-1:1
-        assert(prob, abs(u[i, i]) > tol, "matrix is singular")
+        @assert abs(u[i, i]) > tol "matrix is singular"
         x[i] += b[i] / u[i, i]
 
         if i == n

src/forward-substitution.jl

@@ -5,7 +5,7 @@ struct ForwardSubstitutionProblem <: ProblemMixin
 
     function ForwardSubstitutionProblem(l, b, tol)
         prob = new(l, b, tol)
-        assert(prob, istril(l), "matrix must be lower triangular")
+        @assert istril(l) "matrix must be lower triangular"
         return prob
     end
 end
@@ -25,7 +25,7 @@ function kernel(prob::ForwardSubstitutionProblem)
     x = zeros(n)
 
     for i in 1:n
-        assert(prob, abs(l[i, i]) > tol, "matrix is singular")
+        @assert abs(l[i, i]) > tol "matrix is singular"
         x[i] += b[i] / l[i, i]
 
         if i == 1

src/lu-factorization.jl

@@ -4,8 +4,8 @@ struct LUFactorizationSolution <: SolutionMixin
 
     function LUFactorizationSolution(l, u)
         s = new(l, u)
-        assert(s, istril(l), "matrix must be lower triangular")
-        assert(s, istriu(u), "matrix must be upper triangular")
+        @assert istril(l) "matrix must be lower triangular"
+        @assert istriu(u) "matrix must be upper triangular"
         return s
     end
 end
@@ -17,23 +17,23 @@ struct Version1 <: LUFactorizationProblemMixin
     tol::Real
 end
 
-function kernel(p::Version1)
-    tol = p.tol
-    u = copy(p.a)
+function kernel(prob::Version1)
+    tol = prob.tol
+    u = copy(prob.a)
     n = size(u, 1)
 
     l = Matrix{Float64}(I, n, n)
 
     for k in 1:n-1
-        assert(p, abs(u[k, k]) > tol, "Gaussian elimination failed")
+        @assert abs(u[k, k]) > tol "Gaussian elimination failed"
 
         m_k = Matrix{Float64}(I, n, n)
         for i in k+1:n
             m_k[i, k] = -u[i, k] / u[k, k]
         end
 
         l = l * inv(m_k)
-        u .= m_k * u
+        u = m_k * u
     end
 
     return LUFactorizationSolution(tril(l), triu(u))
@@ -44,26 +44,26 @@ struct Version2 <: LUFactorizationProblemMixin
     tol::Real
 end
 
-function kernel(p::Version2)
-    tol = p.tol
-    u = copy(p.a)
+function kernel(prob::Version2)
+    tol = prob.tol
+    u = copy(prob.a)
     n = size(u, 1)
 
     # initialize l to be the identity matrix
     l = Matrix{Float64}(I, n, n)
 
     for k in 1:n-1
-        assert(p, abs(u[k, k]) > tol, "Gaussian elimination failed")
+        @assert abs(u[k, k]) > tol "Gaussian elimination failed"
         l[k+1:n, k] = u[k+1:n, k] / u[k, k]
         u[k+1:n, k+1:n] -= l[k+1:n, k] * u[k, k+1:n]'
     end
 
     return LUFactorizationSolution(tril(l), triu(u))
 end
 
-LUFactVersion1 = Version1
-LUFactVersion2 = Version2
-export LUFactVersion1, LUFactVersion2
+LUFactorizationV1 = Version1
+LUFactorizationV2 = Version2
+export LUFactorizationV1, LUFactorizationV2
 
-LUFactorizationProblem = Version2
-export LUFactorizationProblem
+LUFactorization = LUFactorizationV2
+export LUFactorization

src/partial-pivoting-lu-factorization.jl

@@ -3,11 +3,11 @@ struct PartialPivotingLUFactorizationSolution <: SolutionMixin
     u::AbstractMatrix
     p::Vector{Int}
     function PartialPivotingLUFactorizationSolution(l, u, p)
-        s = new(l, u, p)
-        assert(s, istril(l), "matrix must be lower triangular")
-        assert(s, istriu(u), "matrix must be upper triangular")
-        assert(s, isperm(p), "matrix must be a permutation matrix")
-        return s
+        sol = new(l, u, p)
+        @assert istril(l) "matrix must be lower triangular"
+        @assert istriu(u) "matrix must be upper triangular"
+        @assert isperm(p) "matrix must be a permutation matrix"
+        return sol
     end
 end
 
@@ -16,9 +16,11 @@ struct PartialPivotingLUFactorizationProblem <: ProblemMixin
     tol::Real
 end
 
-function kernel(p::PartialPivotingLUFactorizationProblem)
-    tol = p.tol
-    u = copy(p.a)
+PartialPivotingLUFactorization = PartialPivotingLUFactorizationProblem
+
+function kernel(prob::PartialPivotingLUFactorizationProblem)
+    tol = prob.tol
+    u = copy(prob.a)
     n = size(u, 1)
 
     l = zeros(n, n)
@@ -56,4 +58,4 @@ function kernel(p::PartialPivotingLUFactorizationProblem)
     return PartialPivotingLUFactorizationSolution(tril(l), triu(u), p)
 end
 
-export PartialPivotingLUFactorizationProblem
+export PartialPivotingLUFactorization

test/back-substitution.jl

@@ -16,7 +16,7 @@ end
     tol = 1e-10
     u = rand(n, n)
     b = rand(n)
-    @test_throws LinearAlgebraError BackSubstitution(u, b, tol)
+    @test_throws AssertionError BackSubstitution(u, b, tol)
 end
 
 @testset "singular matrix" begin
@@ -25,5 +25,5 @@ end
     u = zeros(n, n)
     b = rand(n)
     prob = BackSubstitution(u, b, tol)
-    @test_throws LinearAlgebraError kernel(prob)
+    @test_throws AssertionError kernel(prob)
 end

test/forward-substitution.jl

@@ -15,7 +15,7 @@ end
     tol = 1e-10
     l = rand(n, n)
     b = rand(n)
-    @test_throws LinearAlgebraError ForwardSubstitution(l, b, tol)
+    @test_throws AssertionError ForwardSubstitution(l, b, tol)
 end
 
 @testset "singular matrix" begin
@@ -24,5 +24,5 @@ end
     l = zeros(n, n)
     b = rand(n)
     prob = ForwardSubstitution(l, b, tol)
-    @test_throws LinearAlgebraError kernel(prob)
+    @test_throws AssertionError kernel(prob)
 end

test/lu-factorization.jl

@@ -3,7 +3,7 @@
     tol = 1e-10
     a = rand(n, n)
 
-    p = LUFactVersion1(a, tol)
+    p = LUFactorizationV1(a, tol)
     s = kernel(p)
     l = s.l
     u = s.u
@@ -18,7 +18,7 @@ end
     tol = 1e-10
     a = rand(n, n)
 
-    p = LUFactVersion2(a, tol)
+    p = LUFactorizationV2(a, tol)
     s = kernel(p)
     l = s.l
     u = s.u
@@ -33,7 +33,7 @@ end
     tol = 1e-10
     a = rand(n, n)
 
-    p = LUFactorizationProblem(a, tol)
+    p = LUFactorization(a, tol)
     s = kernel(p)
     l = s.l
     u = s.u
@@ -47,6 +47,6 @@ end
     n = 10
     tol = 1e-10
     a = zeros(n, n)
-    p = LUFactorizationProblem(a, tol)
-    @test_throws LinearAlgebraError kernel(p)
+    p = LUFactorization(a, tol)
+    @test_throws AssertionError kernel(p)
 end

test/partial-pivoting-lu-factorization.jl

@@ -3,7 +3,7 @@
     tol = 1e-10
     a = rand(n, n)
 
-    p = PartialPivotingLUFactorizationProblem(a, tol)
+    p = PartialPivotingLUFactorization(a, tol)
     s = kernel(p)
 
     @test istril(s.l)
@@ -14,7 +14,7 @@
     u = s.u
     p = zeros(Int, n, n)
     setindex!.(Ref(p), 1, 1:n, s.p)
-    
+
     @test minimum(a[s.p, :] - l * u) < tol
     @test minimum(p * a - l * u) < tol
 end