Add eigenvalue problem support

- Implement eigenvalue problem module (eig.jl)
- Include eigenvalue tests in test suite
- Remove unused OMEinsum dependency

Author: yangjunjie0320

src/SimpleLinearAlgebra.jl

@@ -1,7 +1,5 @@
 module SimpleLinearAlgebra
-
     using LinearAlgebra, Printf
-    using OMEinsum
 
     abstract type ProblemMixin end
     abstract type SolutionMixin end
@@ -18,6 +16,7 @@ module SimpleLinearAlgebra
     include("back.jl")
     include("lu.jl")
     include("qr.jl")
+    include("eig.jl")
 
     export kernel
 end

src/eig.jl

@@ -0,0 +1,69 @@
+abstract type EigenProblemMixin <: ProblemMixin end
+
+module Eigen
+    using LinearAlgebra, Printf
+
+    import SimpleLinearAlgebra.EigenProblemMixin
+    import SimpleLinearAlgebra.SolutionMixin
+    
+    """
+    Base struct for eigenvalue solution that contains eigenvalues and eigenvectors
+    """
+    struct EigenSolution <: SolutionMixin
+        e::AbstractVector # Eigenvalues
+        c::AbstractMatrix # Eigenvectors as columns
+        is_converged::Bool
+    end
+
+    """
+    Power Iteration Method - finds the dominant eigenvalue and eigenvector
+    """
+    struct PowerIteration <: EigenProblemMixin
+        a::AbstractMatrix
+        max_cycle::Int
+        tol::Real
+        
+        function PowerIteration(a::AbstractMatrix, max_cycle::Int=1000, tol::Real=1e-10)
+            @assert size(a, 1) == size(a, 2) "Matrix must be square"
+            new(a, max_cycle, tol)
+        end
+    end
+
+    function kernel(prob::PowerIteration)
+        a = prob.a
+        n = size(a, 1)
+        max_cycle = prob.max_cycle
+        tol = prob.tol
+        
+        # Initialize with random vector
+        de = 1.0
+        e_pre = 0.0
+        e_cur = 0.0
+
+        v_pre = normalize(rand(n))
+        v_cur = v_pre
+        
+        cycle = 1
+        is_converged = false
+        is_max_cycle = false
+
+        while !is_converged && !is_max_cycle
+            is_converged = de < tol
+            is_max_cycle = cycle >= max_cycle
+
+            v_cur = a * v_pre
+            e_cur = v_pre' * v_cur
+            v_cur = normalize(v_cur)
+
+            de = abs(e_cur - e_pre)
+            e_pre = e_cur
+            v_pre = v_cur
+            cycle += 1
+        end
+
+        return EigenSolution([e_cur], reshape(v_cur, n, 1), is_converged)
+    end
+end
+
+kernel(prob::EigenProblemMixin) = Eigen.kernel(prob)
+export Eigen

test/eig.jl

@@ -0,0 +1,24 @@
+import SimpleLinearAlgebra.Eigen
+
+@testset "Power Iteration Method" begin
+    # Create a matrix with a known dominant eigenvalue
+    n = 4
+    a = randn(n, n)
+    # Make the first eigenvalue significantly larger
+    a = a * a'  # Create a symmetric positive-definite matrix
+    eig_true = eigen(a)
+
+    println(eig_true.values)
+    
+    prob = Eigen.PowerIteration(a, 1000, 1e-8)
+    tol = sqrt(prob.tol)
+    
+    soln = kernel(prob)
+    e = soln.e[1]
+    c = soln.c[:, 1]
+    
+    # Check eigenvector property: Ax = λx
+    if soln.is_converged
+        @test isapprox(a * c, e * c, atol=tol)
+    end
+end

test/runtests.jl

@@ -16,3 +16,7 @@ end
 @testset "QR factorization" begin
     include("qr.jl")
 end
+
+@testset "Eigenvalue problems" begin
+    include("eig.jl")
+end