Rename types

Author: mtfishman

src/AlgorithmsInterface.jl

@@ -1,13 +1,13 @@
 module AlgorithmsInterface
 
-abstract type AbstractProblem end
+abstract type Problem end
 
-abstract type AbstractAlgorithm end
+abstract type Algorithm end
 
-abstract type AbstractState end
+abstract type State end
 
 function increment!(
-        problem::AbstractProblem, algorithm::AbstractAlgorithm, state::AbstractState
+        problem::Problem, algorithm::Algorithm, state::State
     )
     state.iteration += 1
     return state
@@ -22,23 +22,23 @@ The "state", which stores both the tensor network state (the `iterate`) and the
 current region is `alg.regions[iteration]`, while for `alg::Sweeping`, the current sweep is
 `alg.sweeps[iteration]`.
 =#
-mutable struct State{Iterate, Iteration} <: AbstractState
+mutable struct DefaultState{Iterate, Iteration} <: State
     iterate::Iterate
     iteration::Iteration
 end
 
 function initialize_state(
-        problem::AbstractProblem, algorithm::AbstractAlgorithm, x
+        problem::Problem, algorithm::Algorithm, x
     )
-    return State(x, 0)
+    return DefaultState(x, 0)
 end
 
 using Base.ScopedValues: ScopedValue, with
 const CALLBACKS = ScopedValue(Dict{Symbol, Any}())
 function callback(
-        problem::AbstractProblem,
-        algorithm::AbstractAlgorithm,
-        state::AbstractState,
+        problem::Problem,
+        algorithm::Algorithm,
+        state::State,
         event::Symbol,
     )
     f = get(CALLBACKS[], event, Returns(nothing))
@@ -50,7 +50,7 @@ function with_callbacks(f, callbacks::Pair{Symbol}...)
 end
 
 function solve!(
-        problem::AbstractProblem, algorithm::AbstractAlgorithm, state::AbstractState
+        problem::Problem, algorithm::Algorithm, state::State
     )
     callback(problem, algorithm, state, :Start)
     while !is_finished(problem, algorithm, state)
@@ -64,42 +64,44 @@ function solve!(
 end
 
 function is_finished(
-        problem::AbstractProblem, algorithm::AbstractAlgorithm, state::AbstractState
+        problem::Problem, algorithm::Algorithm, state::State
+    )
+    return is_finished(
+        problem, algorithm, state, state.stopping_criterion, state.stopping_criterion_state
     )
-    return throw(MethodError(is_finished, (problem, algorithm, state)))
 end
 
-function step!(problem::AbstractProblem, algorithm::AbstractAlgorithm, state::AbstractState)
+function step!(problem::Problem, algorithm::Algorithm, state::State)
     return throw(MethodError(step!, (problem, algorithm, state)))
 end
 
-abstract type AbstractAlgorithmIterator end
+abstract type AlgorithmIterator end
 
-struct AlgorithmIterator{Problem, Algorithm, State} <: AbstractAlgorithmIterator
+struct DefaultAlgorithmIterator{Problem, Algorithm, State} <: AlgorithmIterator
     problem::Problem
     algorithm::Algorithm
     state::State
 end
 function iterator(
-        problem::AbstractProblem, algorithm::AbstractAlgorithm, state::AbstractState
+        problem::Problem, algorithm::Algorithm, state::State
     )
-    return return AlgorithmIterator(problem, algorithm, state)
+    return DefaultAlgorithmIterator(problem, algorithm, state)
 end
 
-function is_finished(itr::AbstractAlgorithmIterator)
+function is_finished(itr::AlgorithmIterator)
     return is_finished(itr.problem, itr.algorithm, itr.state)
 end
-function callback(itr::AbstractAlgorithmIterator, event::Symbol)
+function callback(itr::AlgorithmIterator, event::Symbol)
     return callback(itr.problem, itr.algorithm, itr.state, event)
 end
-function increment!(itr::AbstractAlgorithmIterator)
+function increment!(itr::AlgorithmIterator)
     return increment!(itr.problem, itr.algorithm, itr.state)
 end
-function step!(itr::AbstractAlgorithmIterator)
+function step!(itr::AlgorithmIterator)
     return step!(itr.problem, itr.algorithm, itr.state)
 end
 
-function Base.iterate(itr::AbstractAlgorithmIterator, init = nothing)
+function Base.iterate(itr::AlgorithmIterator, init = nothing)
     is_finished(itr) && return nothing
     callback(itr, :PreStep)
     increment!(itr)
@@ -108,4 +110,7 @@ function Base.iterate(itr::AbstractAlgorithmIterator, init = nothing)
     return itr.state, nothing
 end
 
+abstract type StoppingCriterion end
+abstract type StoppingCriterionState end
+
 end

src/eigenproblem.jl

@@ -6,12 +6,12 @@ import .AlgorithmsInterface as AI
 Represents the problem we are trying to solve and minimal algorithm-independent
 information, so for an eigenproblem it is the operator we want the eigenvector of.
 =#
-struct EigenProblem{Operator} <: AI.AbstractProblem
+struct EigenProblem{Operator} <: AI.Problem
     operator::Operator
 end
 
 function update!(
-        problem::EigenProblem, algorithm::Sweep, state::AI.AbstractState
+        problem::EigenProblem, algorithm::Sweep, state::AI.State
     )
     operator = problem.operator
     x = state.iterate

src/sweeping.jl

@@ -11,16 +11,16 @@ current region. For simplicity, it also accepts a `NamedTuple` of keyword argume
 which is converted into a function that always returns the same keyword arguments
 for an region.
 =#
-@kwdef struct Sweep{Regions <: AbstractVector, RegionKwargs <: Function} <: AI.AbstractAlgorithm
+@kwdef struct Sweep{Regions <: Vector, RegionKwargs <: Function} <: AI.Algorithm
     regions::Regions
     region_kwargs::RegionKwargs
     iteration::Int = 0
 end
-function Sweep(regions::AbstractVector, region_kwargs::NamedTuple, iteration::Int = 0)
+function Sweep(regions::Vector, region_kwargs::NamedTuple, iteration::Int = 0)
     function region_kwargs_fn(
-            problem::AI.AbstractProblem,
-            algorithm::AI.AbstractAlgorithm,
-            state::AI.AbstractState,
+            problem::AI.Problem,
+            algorithm::AI.Algorithm,
+            state::AI.State,
         )
         return region_kwargs
     end
@@ -30,7 +30,7 @@ end
 maxiter(algorithm::Sweep) = length(algorithm.regions)
 
 function AI.step!(
-        problem::AI.AbstractProblem, algorithm::Sweep, state::AI.AbstractState
+        problem::AI.Problem, algorithm::Sweep, state::AI.State
     )
     extract!(problem, algorithm, state)
     update!(problem, algorithm, state)
@@ -39,82 +39,82 @@ function AI.step!(
 end
 
 function extract!(
-        problem::AI.AbstractProblem, algorithm::Sweep, state::AI.AbstractState
+        problem::AI.Problem, algorithm::Sweep, state::AI.State
     )
     # Extraction step goes here.
     return state
 end
 function update!(
-        problem::AI.AbstractProblem, algorithm::Sweep, state::AI.AbstractState
+        problem::AI.Problem, algorithm::Sweep, state::AI.State
     )
     # Update step goes here.
     return state
 end
 function insert!(
-        problem::AI.AbstractProblem, algorithm::Sweep, state::AI.AbstractState
+        problem::AI.Problem, algorithm::Sweep, state::AI.State
     )
     # Insert step goes here.
     return state
 end
 
 # TODO: Use a proper stopping criterion.
 function AI.is_finished(
-        problem::AI.AbstractProblem, algorithm::Sweep, state::AI.AbstractState
+        problem::AI.Problem, algorithm::Sweep, state::AI.State
     )
     state.iteration == 0 && return false
     return state.iteration >= length(algorithm.regions)
 end
 
 #=
-    Sweeping(sweeps::AbstractVector{<:Sweep})
+    Sweeping(sweeps::Vector{<:Sweep})
 
 The sweeping algorithm, which just stores a list of sweeps defined above. 
 =#
-struct Sweeping{Sweeps <: AbstractVector{<:Sweep}} <: AI.AbstractAlgorithm
+struct Sweeping{Sweeps <: Vector{<:Sweep}} <: AI.Algorithm
     sweeps::Sweeps
 end
 
 maxiter(algorithm::Sweeping) = length(algorithm.sweeps)
 
 function AI.step!(
-        problem::AI.AbstractProblem, algorithm::Sweeping, state::AI.AbstractState
+        problem::AI.Problem, algorithm::Sweeping, state::AI.State
     )
     # Perform the current sweep.
     sweep = algorithm.sweeps[state.iteration]
     x = state.iterate
-    region_state = AI.State(x, 0)
+    region_state = AI.initialize_state(problem, sweep, x)
     AI.solve!(problem, sweep, region_state)
     state.iterate = region_state.iterate
     return state
 end
 
 # TODO: Use a proper stopping criterion.
 function AI.is_finished(
-        problem::AI.AbstractProblem, algorithm::Sweeping, state::AI.AbstractState
+        problem::AI.Problem, algorithm::Sweeping, state::AI.State
     )
     state.iteration == 0 && return false
     return state.iteration >= length(algorithm.sweeps)
 end
 
 # Sweeping by region.
-struct ByRegion{Algorithm <: Sweeping} <: AI.AbstractAlgorithm
+struct ByRegion{Algorithm <: Sweeping} <: AI.Algorithm
     parent::Algorithm
 end
 function AI.initialize_state(
-        problem::AI.AbstractProblem, algorithm::ByRegion, x
+        problem::AI.Problem, algorithm::ByRegion, x
     )
     return AI.State(x, (; sweep = 1, region = 0))
 end
 function AI.is_finished(
-        problem::AI.AbstractProblem, algorithm::ByRegion, state::AI.AbstractState
+        problem::AI.Problem, algorithm::ByRegion, state::AI.State
     )
     sweep_iteration = state.iteration.sweep
     region_iteration = state.iteration.region
     return sweep_iteration ≥ maxiter(algorithm.parent) &&
         region_iteration ≥ maxiter(algorithm.parent.sweeps[sweep_iteration])
 end
 function AI.increment!(
-        problem::AI.AbstractProblem, algorithm::ByRegion, state::AI.AbstractState
+        problem::AI.Problem, algorithm::ByRegion, state::AI.State
     )
     sweep_iteration = state.iteration.sweep
     region_iteration = state.iteration.region
@@ -127,7 +127,7 @@ function AI.increment!(
     state.iteration = (; sweep = sweep_iteration, region = region_iteration)
     return state
 end
-function AI.step!(problem::AI.AbstractProblem, algorithm::ByRegion, state::AI.AbstractState)
+function AI.step!(problem::AI.Problem, algorithm::ByRegion, state::AI.State)
     sweep = algorithm.parent.sweeps[state.iteration.sweep]
     sweep_state = AI.State(state.iterate, state.iteration.region)
     AI.step!(problem, sweep, sweep_state)