Add Rayleigh Quotient method for eigenvalue computation

- Rename PowerIteration to PowerMethod for clarity
- Implement RayleighQuotient method for eigenvalue estimation
- Update test suite to include Rayleigh Quotient method tests
- Improve test case matrix size and tolerance calculation

Author: yangjunjie0320

src/eig.jl

@@ -18,18 +18,18 @@ module Eigen
     """
     Power Iteration Method - finds the dominant eigenvalue and eigenvector
     """
-    struct PowerIteration <: EigenProblemMixin
+    struct PowerMethod <: EigenProblemMixin
         a::AbstractMatrix
         max_cycle::Int
         tol::Real
 
-        function PowerIteration(a::AbstractMatrix, max_cycle::Int=1000, tol::Real=1e-10)
+        function PowerMethod(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)
+    function kernel(prob::PowerMethod)
         a = prob.a
         n = size(a, 1)
         max_cycle = prob.max_cycle
@@ -61,8 +61,57 @@ module Eigen
             cycle += 1
         end
 
-        return EigenSolution([e_cur], reshape(v_cur, n, 1), is_converged)
+        soln = EigenSolution([e_cur], reshape(v_cur, n, 1), is_converged)
+        return soln
     end
+
+    struct RayleighQuotient <: EigenProblemMixin
+        a::AbstractMatrix
+        max_cycle::Int
+        tol::Real
+
+        function RayleighQuotient(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::RayleighQuotient)
+        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
+
+            e_cur = v_pre' * a * v_pre
+            v_cur = (a - e_cur * I) \ v_pre
+            v_cur = normalize(v_cur)
+
+            de = abs(e_cur - e_pre)
+            e_pre = e_cur
+            v_pre = v_cur
+            cycle += 1
+        end
+
+        soln = EigenSolution([e_cur], reshape(v_cur, n, 1), is_converged)
+        return soln
+    end
+    
 end
 
 kernel(prob::EigenProblemMixin) = Eigen.kernel(prob)

test/eig.jl

@@ -2,23 +2,34 @@ import SimpleLinearAlgebra.Eigen
 
 @testset "Power Iteration Method" begin
     # Create a matrix with a known dominant eigenvalue
-    n = 4
+    n = 8
     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)
+    prob = Eigen.PowerMethod(a, 1000, 1e-8)
+    tol = sqrt(prob.tol * n)
 
     soln = kernel(prob)
     e = soln.e[1]
     c = soln.c[:, 1]
+
+    @test isapprox(a * c, e * c, atol=tol)
+end
+
+@testset "Rayleigh Quotient Method" begin
+    # Create a matrix with a known dominant eigenvalue
+    n = 8
+    a = randn(n, n)
+    # Make the first eigenvalue significantly larger
+    a = a * a'  # Create a symmetric positive-definite matrix
+
+    prob = Eigen.RayleighQuotient(a, 1000, 1e-8)
+    tol = sqrt(prob.tol * n)
 
-    # Check eigenvector property: Ax = λx
-    if soln.is_converged
-        @test isapprox(a * c, e * c, atol=tol)
-    end
+    soln = kernel(prob)
+    e = soln.e[1]
+    c = soln.c[:, 1]
+
+    @test isapprox(a * c, e * c, atol=tol)
 end