Define NonIterativeAlgorithm, make Region a subtype of that, starting testing

Author: mtfishman

src/AlgorithmsInterfaceExtensions/AlgorithmsInterfaceExtensions.jl

@@ -9,9 +9,8 @@ abstract type Algorithm <: AI.Algorithm end
 abstract type State <: AI.State end
 
 function AI.initialize_state!(
-        problem::Problem, algorithm::Algorithm, state::State; iterate = nothing
+        problem::Problem, algorithm::Algorithm, state::State; kwargs...
     )
-    !isnothing(iterate) && (state.iterate = iterate)
     AI.initialize_state!(
         problem, algorithm, algorithm.stopping_criterion, state.stopping_criterion_state
     )
@@ -278,4 +277,23 @@ end
     stopping_criterion_state::StoppingCriterionState
 end
 
+#============================ NonIterativeAlgorithm =======================================#
+
+# Algorithm that only performs a single step.
+abstract type NonIterativeAlgorithm <: Algorithm end
+
+function Base.getproperty(algorithm::NonIterativeAlgorithm, name::Symbol)
+    if name ≡ :stopping_criterion
+        return AI.StopAfterIteration(1)
+    else
+        return getfield(algorithm, name)
+    end
+end
+
+abstract type NonIterativeAlgorithmState <: State end
+
+mutable struct DefaultNonIterativeAlgorithmState{Iterate} <: NonIterativeAlgorithmState
+    iterate::Iterate
+end
+
 end

src/sweeping/eigenproblem.jl

@@ -58,36 +58,6 @@ struct EigenProblem{Operator} <: AIE.Problem
     operator::Operator
 end
 
-function AI.step!(problem::EigenProblem, algorithm::Sweep, state::AI.State; kwargs...)
-    iterate = solve_region!!(
-        problem, algorithm.region_algorithms[state.iteration](state.iterate), state.iterate
-    )
-    state.iterate = iterate
-    return state
-end
-
-# extract!, update!, insert! for the region.
-function solve_region!!(problem::EigenProblem, algorithm::RegionAlgorithm, state)
-    operator = problem.operator
-    region = algorithm.region
-    region_kwargs = algorithm.kwargs
-
-    #=
-    # Reduce the `operator` and state `x` onto the region `region`,
-    # and call `eigsolve` on the reduced operator and state using the
-    # keyword arguments determined from `region_kwargs`.
-    operator_region = reduced_operator(operator, x, region)
-    x_region = reduced_state(x, region)
-    x_region′ = eigsolve(operator_region, x_region; region_kwargs.update...)
-    x′ = insert(x, region, x_region′; region_kwargs.insert...)
-    state.state = x′
-    =#
-
-    # Dummy update for demonstration purposes.
-    state′ = "region = $region" *
-        ", update_kwargs = $(region_kwargs.update)" *
-        ", insert_kwargs = $(region_kwargs.insert)"
-    state = [state; [state′]]
-
-    return state
+function AI.step!(problem::EigenProblem, algorithm::Region, state::AIE.State; kwargs...)
+    return error("Region step for EigenProblem not implemented.")
 end

src/sweeping/sweeping.jl

@@ -2,8 +2,7 @@ import AlgorithmsInterface as AI
 import .AlgorithmsInterfaceExtensions as AIE
 
 @kwdef struct Sweeping{
-        Algorithms <: AbstractVector{<:AI.Algorithm},
-        StoppingCriterion <: AI.StoppingCriterion,
+        Algorithms <: AbstractVector, StoppingCriterion <: AI.StoppingCriterion,
     } <: AIE.NestedAlgorithm
     algorithms::Algorithms
     stopping_criterion::StoppingCriterion = AI.StopAfterIteration(length(algorithms))
@@ -24,31 +23,18 @@ which is converted into a function that always returns the same keyword argument
 for an region.
 =#
 @kwdef struct Sweep{
-        RegionAlgorithms <: AbstractVector, StoppingCriterion <: AI.StoppingCriterion,
-    } <: AIE.Algorithm
-    region_algorithms::RegionAlgorithms
-    stopping_criterion::StoppingCriterion = AI.StopAfterIteration(length(region_algorithms))
+        Algorithms <: AbstractVector, StoppingCriterion <: AI.StoppingCriterion,
+    } <: AIE.NestedAlgorithm
+    algorithms::Algorithms
+    stopping_criterion::StoppingCriterion = AI.StopAfterIteration(length(algorithms))
 end
 function Sweep(f, nalgorithms::Int; kwargs...)
-    region_algorithms = to_region_algorithm.(f.(1:nalgorithms))
-    return Sweep(; region_algorithms, kwargs...)
+    return Sweep(; algorithms = f.(1:nalgorithms), kwargs...)
 end
-to_region_algorithm(algorithm::Function) = algorithm
-to_region_algorithm(algorithm) = Returns(region_algorithm(algorithm))
-
-AIE.max_iterations(algorithm::Sweep) = length(algorithm.algorithms)
 
-abstract type RegionAlgorithm end
-region_algorithm(algorithm::RegionAlgorithm) = algorithm
-region_algorithm(algorithm::NamedTuple) = Region(; algorithm...)
-
-struct Region{R, Kwargs <: NamedTuple} <: RegionAlgorithm
+struct Region{R, Kwargs <: NamedTuple} <: AIE.NonIterativeAlgorithm
     region::R
     kwargs::Kwargs
 end
-function Region(; region, kwargs...)
-    return Region(region, (; kwargs...))
-end
-function Region(region; kwargs...)
-    return Region(region, (; kwargs...))
-end
+Region(; region, kwargs...) = Region(region, (; kwargs...))
+Region(region; kwargs...) = Region(region, (; kwargs...))

test/test_sweeping.jl

@@ -0,0 +1,33 @@
+import AlgorithmsInterface as AI
+using ITensorNetworksNext: Region, Sweep, Sweeping
+import ITensorNetworksNext.AlgorithmsInterfaceExtensions as AIE
+using Test: @test, @testset
+
+struct TestProblem <: AIE.Problem
+end
+
+function AI.step!(problem::TestProblem, algorithm::Region, state::AIE.State; kwargs...)
+    state.iterate = algorithm.region
+    return state
+end
+
+@testset "Sweeping" begin
+    @testset "Region" begin
+        algorithm = Region("region"; foo = 1, bar = 2)
+        @test algorithm isa AIE.NonIterativeAlgorithm
+        @test algorithm isa AIE.Algorithm
+        @test algorithm isa AI.Algorithm
+        @test algorithm.region == "region"
+        @test algorithm.kwargs == (; foo = 1, bar = 2)
+        @test Region(; region = "region", foo = 1, bar = 2) == algorithm
+
+        problem = TestProblem()
+        iterate = ""
+        state = AI.solve(problem, algorithm; iterate)
+        @test state.iterate == "region"
+    end
+    @testset "Sweep" begin
+    end
+    @testset "Sweeping" begin
+    end
+end