Refactor project structure and add error handling utility

- Add Printf dependency to Project.toml and examples/Manifest.toml
- Introduce `assert` utility function with custom error handling
- Rename source and test files to use hyphen-separated naming
- Remove individual substitution and LU factorization implementation files
- Update module to import Printf macro and add LinearAlgebraError type
- Modify test runner to reflect new file structure

Author: yangjunjie0320

Project.toml

@@ -5,9 +5,11 @@ version = "1.0.0-DEV"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 
 [compat]
 LinearAlgebra = "1.10.0"
+Printf = "1.11.0"
 julia = "1.10"
 
 [extras]

examples/Manifest.toml

@@ -27,12 +27,21 @@ deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]
 uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
 version = "0.3.27+1"
 
+[[deps.Printf]]
+deps = ["Unicode"]
+uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+version = "1.11.0"
+
 [[deps.SimpleLinearAlgebra]]
-deps = ["LinearAlgebra"]
-path = "/Users/yangjunjie/work/SimpleLinearAlgebra.jl/SimpleLinearAlgebra"
+deps = ["LinearAlgebra", "Printf"]
+path = "/Users/yangjunjie/.julia/dev/SimpleLinearAlgebra"
 uuid = "555e9691-8231-4cde-a0d7-6dc20204a59a"
 version = "1.0.0-DEV"
 
+[[deps.Unicode]]
+uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+version = "1.11.0"
+
 [[deps.libblastrampoline_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"

src/SimpleLinearAlgebra.jl

@@ -1,6 +1,7 @@
 module SimpleLinearAlgebra
 
-    using LinearAlgebra
+    using LinearAlgebra, Printf
+    import Printf.@sprintf  # Fixed macro import
 
     abstract type ProblemMixin end
     abstract type SolutionMixin end
@@ -9,7 +10,20 @@ module SimpleLinearAlgebra
         MethodError(kernel, (typeof(prob),)) |> throw
     end
 
-    include("forward_substitution.jl")
-    include("back_substitution.jl")
-    include("lufact.jl")
+    struct LinearAlgebraError <: Exception
+        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")
+    include("partial-pivoting-lu-factorization.jl")
 end

src/back_substitution.jl renamed to src/back-substitution.jl

@@ -4,10 +4,9 @@ struct BackSubstitutionProblem <: ProblemMixin
     tol::Real
 
     function BackSubstitutionProblem(u, b, tol)
-        if !istriu(u)
-            ArgumentError("Matrix must be upper triangular") |> throw
-        end
-        return new(u, b, tol)
+        prob = new(u, b, tol)
+        assert(prob, istriu(u), "matrix must be upper triangular")
+        return prob
     end
 end
 
@@ -25,13 +24,16 @@ function kernel(prob::BackSubstitutionProblem)
 
     # solve the system
     x = zeros(n)
-    x[n] = b[n] / u[n, n]
 
-    for i in n-1:-1:1
-        if abs(u[i, i]) < tol
-            throw(ArgumentError("Matrix is singular"))
+    for i in n:-1:1
+        assert(prob, abs(u[i, i]) > tol, "matrix is singular")
+        x[i] += b[i] / u[i, i]
+
+        if i == n
+            continue
         end
-        x[i] = (b[i] - sum(u[i, j] * x[j] for j in i+1:n)) / u[i, i]
+
+        x[i] -= u[i, i+1:n]' * x[i+1:n] / u[i, i]
     end
 
     return BackSubstitutionSolution(x)

src/forward_substitution.jl renamed to src/forward-substitution.jl

@@ -4,10 +4,9 @@ struct ForwardSubstitutionProblem <: ProblemMixin
     tol::Real
 
     function ForwardSubstitutionProblem(l, b, tol)
-        if !istril(l)
-            ArgumentError("Matrix must be lower triangular") |> throw
-        end
-        return new(l, b, tol)
+        prob = new(l, b, tol)
+        assert(prob, istril(l), "matrix must be lower triangular")
+        return prob
     end
 end
 
@@ -24,12 +23,16 @@ function kernel(prob::ForwardSubstitutionProblem)
     tol = prob.tol
 
     x = zeros(n)
-    x[1] = b[1] / l[1, 1]
-    for i in 2:n
-        if abs(l[i, i]) < tol
-            ArgumentError("Matrix is singular") |> throw
+
+    for i in 1:n
+        assert(prob, abs(l[i, i]) > tol, "matrix is singular")
+        x[i] += b[i] / l[i, i]
+
+        if i == 1
+            continue
         end
-        x[i] = (b[i] - sum(l[i, j] * x[j] for j in 1:i-1)) / l[i, i]
+        
+        x[i] -= l[i, 1:i-1]' * x[1:i-1] / l[i, i]
     end
     return ForwardSubstitutionSolution(x)
 end

src/lu-factorization.jl

@@ -0,0 +1,69 @@
+struct LUFactorizationSolution <: SolutionMixin
+    l::AbstractMatrix
+    u::AbstractMatrix
+
+    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")
+        return s
+    end
+end
+
+abstract type LUFactorizationProblemMixin <: ProblemMixin end
+
+struct Version1 <: LUFactorizationProblemMixin
+    a::AbstractMatrix
+    tol::Real
+end
+
+function kernel(p::Version1)
+    tol = p.tol
+    u = copy(p.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")
+
+        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
+    end
+
+    return LUFactorizationSolution(tril(l), triu(u))
+end
+
+struct Version2 <: LUFactorizationProblemMixin
+    a::AbstractMatrix
+    tol::Real
+end
+
+function kernel(p::Version2)
+    tol = p.tol
+    u = copy(p.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")
+        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
+
+LUFactorizationProblem = Version2
+export LUFactorizationProblem

src/lufact.jl

@@ -0,0 +1,59 @@
+struct PartialPivotingLUFactorizationSolution <: SolutionMixin
+    l::AbstractMatrix
+    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
+    end
+end
+
+struct PartialPivotingLUFactorizationProblem <: ProblemMixin
+    a::AbstractMatrix
+    tol::Real
+end
+
+function kernel(p::PartialPivotingLUFactorizationProblem)
+    tol = p.tol
+    u = copy(p.a)
+    n = size(u, 1)
+
+    l = zeros(n, n)
+    p = collect(1:n)
+
+    for k in 1:n-1
+        v, x = findmax(abs.(u[k:n, k]))
+        x += k - 1
+
+        if x != k
+            # swap row k and row x of matrix u
+            for i in 1:n
+                u[k, i], u[x, i] = u[x, i], u[k, i]
+            end
+
+            # swap row k and row x of matrix l
+            for i in 1:n
+                l[k, i], l[x, i] = l[x, i], l[k, i]
+            end
+
+            # swap row k and row x of matrix p
+            p[k], p[x] = p[x], p[k]
+        end
+
+        if abs(u[k, k]) < tol
+            continue
+        end
+
+        l[k, k] = 1.0
+        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
+
+    l[n, n] = 1.0
+    return PartialPivotingLUFactorizationSolution(tril(l), triu(u), p)
+end
+
+export PartialPivotingLUFactorizationProblem

src/partial-pivoting-lu-factorization.jl

@@ -0,0 +1,29 @@
+@testset "backward substitution" begin
+    n = 10
+    tol = 1e-10
+    u = LinearAlgebra.triu(rand(n, n))
+    b = rand(n)
+
+    p = BackSubstitution(u, b, tol)
+    s = kernel(p)
+    x = s.x
+    @test maximum(abs, u * x - b) < tol
+end
+
+# test for me error message
+@testset "not upper triangular" begin
+    n = 10
+    tol = 1e-10
+    u = rand(n, n)
+    b = rand(n)
+    @test_throws LinearAlgebraError BackSubstitution(u, b, tol)
+end
+
+@testset "singular matrix" begin
+    n = 10
+    tol = 1e-10
+    u = zeros(n, n)
+    b = rand(n)
+    prob = BackSubstitution(u, b, tol)
+    @test_throws LinearAlgebraError kernel(prob)
+end