implement styles for states and operators and add tests

Author: AFeuerpfeil

src/operators/multilinempo.jl

@@ -12,7 +12,6 @@ Type that represents multiple lines of `MPO` objects.
 See also: [`Multiline`](@ref), [`AbstractMPO`](@ref)
 """
 const MultilineMPO = Multiline{<:AbstractMPO}
-OperatorStyle(mpos::MultilineMPO) = OperatorStyle(O)
 
 function MultilineMPO(Os::AbstractMatrix)
     return MultilineMPO(map(FiniteMPO, eachrow(Os)))

src/states/quasiparticle_state.jl

@@ -208,6 +208,7 @@ end
 
 # gauge independent code
 const QP{S, T1, T2} = Union{LeftGaugedQP{S, T1, T2}, RightGaugedQP{S, T1, T2}}
+# TODO: Remove FiniteQP and InfiniteQP in favor of styles.
 const FiniteQP{S <: FiniteMPS, T1, T2} = QP{S, T1, T2}
 const InfiniteQP{S <: InfiniteMPS, T1, T2} = QP{S, T1, T2}
 const MultilineQP{Q <: QP} = Multiline{Q}
@@ -228,6 +229,8 @@ eachsite(state::QP) = eachsite(state.left_gs)
 istopological(qp::QP) = qp.left_gs !== qp.right_gs
 istrivial(qp::QP) = !istopological(qp) && isone(auxiliarysector(qp))
 
+IsfiniteStyle(qp::QP) = IsfiniteStyle(qp.left_gs)
+
 Base.copy(a::QP) = copy!(similar(a), a)
 Base.copyto!(a::QP, b::QP) = copy!(a, b)
 function Base.copy!(a::T, b::T) where {T <: QP}

src/utility/styles.jl

@@ -1,9 +1,36 @@
+"""
+`OperatorStyle`
+
+Holy trait used as a dispatch tag for operator representations.
+Concrete subtypes (`MPOStyle` and `HamiltonianStyle`) indicate
+whether an operator is stored as an MPO or as a Hamiltonian.
+Use `OperatorStyle` in method signatures to select implementation-
+specific code paths for different operator types.
+
+To opt a custom operator type into this dispatch scheme implement:
+```julia
+OperatorStyle(::T) where {T<:YourOperatorType}
+```
+"""
 abstract type OperatorStyle end
 
 struct MPOStyle <: OperatorStyle end
 struct HamiltonianStyle <: OperatorStyle end
 
 
+"""
+`IsfiniteStyle`
+Holy trait used as a dispatch tag to distinguish between finite
+and infinite types. Concrete subtypes (`FiniteStyle` and
+`InfiniteStyle`) indicate whether a system is finite or infinite.
+Use `IsfiniteStyle` in method signatures to select implementation-
+specific code paths for different types.
+
+To opt a custom type into this dispatch scheme implement:
+```julia
+IsfiniteStyle(::T) where {T<:YourType}
+```
+"""
 abstract type IsfiniteStyle end
 
 struct FiniteStyle <: IsfiniteStyle end

test/operators.jl

@@ -10,6 +10,8 @@ module TestOperators
     using MPSKit
     using MPSKit: _transpose_front, _transpose_tail, C_hamiltonian, AC_hamiltonian,
         AC2_hamiltonian
+    using MPSKit: IsfiniteStyle, FiniteStyle, InfiniteStyle, OperatorStyle, MPOStyle,
+        HamiltonianStyle
     using TensorKit
     using TensorKit: ℙ
     using VectorInterface: One
@@ -32,6 +34,10 @@ module TestOperators
             mpo₂ = FiniteMPO(O₂)
             mpo₃ = FiniteMPO(O₃)
 
+            @test IsfiniteStyle(mpo₁) == FiniteStyle()
+            @test OperatorStyle(mpo₁) == MPOStyle()
+
+
             @test @constinferred physicalspace(mpo₁) == fill(V, L)
             Vleft = @constinferred left_virtualspace(mpo₁)
             Vright = @constinferred right_virtualspace(mpo₂)
@@ -81,6 +87,18 @@ module TestOperators
         end
     end
 
+    @testset "InfiniteMPO" begin
+        P = ℂ^2
+        T = Float64
+
+        H1 = randn(T, P ← P)
+        H1 += H1'
+        H = InfiniteMPO(H1)
+
+        @test IsfiniteStyle(H) == InfiniteStyle()
+        @test OperatorStyle(H) == MPOStyle()
+    end
+
     @testset "MPOHamiltonian constructors" begin
         P = ℂ^2
         T = Float64
@@ -109,6 +127,9 @@ module TestOperators
         H′ = FiniteMPOHamiltonian(map(Base.Fix1(collect, Any), Ws)) # without type info
         @test H ≈ H′
 
+        @test IsfiniteStyle(H) == FiniteStyle()
+        @test OperatorStyle(H) == HamiltonianStyle()
+
         # Infinite
         Ws = [Wmid]
         H = InfiniteMPOHamiltonian(
@@ -119,6 +140,9 @@ module TestOperators
 
         H′ = InfiniteMPOHamiltonian(map(Base.Fix1(collect, Any), Ws)) # without type info
         @test all(parent(H) .≈ parent(H′))
+
+        @test IsfiniteStyle(H) == InfiniteStyle()
+        @test OperatorStyle(H) == HamiltonianStyle()
     end
 
     @testset "Finite MPOHamiltonian" begin

test/states.jl

@@ -9,6 +9,7 @@ module TestStates
     using Test, TestExtras
     using MPSKit
     using MPSKit: _transpose_front, _transpose_tail
+    using MPSKit: IsfiniteStyle, FiniteStyle, InfiniteStyle
     using MPSKit: TransferMatrix
     using TensorKit
     using TensorKit: ℙ
@@ -25,6 +26,7 @@ module TestStates
         ψ = FiniteMPS(rand, elt, L, d, D)
 
         @test isfinite(ψ)
+        @test IsfiniteStyle(ψ) == FiniteStyle()
         @test @constinferred physicalspace(ψ) == fill(d, L)
         @test all(x -> x ≾ D, @constinferred left_virtualspace(ψ))
         @test all(x -> x ≾ D, @constinferred right_virtualspace(ψ))
@@ -101,6 +103,8 @@ module TestStates
         ψ = InfiniteMPS([rand(elt, D * d, D), rand(elt, D * d, D)]; tol)
 
         @test !isfinite(ψ)
+        @test IsfiniteStyle(ψ) == InfiniteStyle()
+
         @test physicalspace(ψ) == fill(d, 2)
         @test all(x -> x ≾ D, left_virtualspace(ψ))
         @test all(x -> x ≾ D, right_virtualspace(ψ))
@@ -231,6 +235,8 @@ module TestStates
             ϕ₁ = LeftGaugedQP(rand, ψ)
             ϕ₂ = LeftGaugedQP(rand, ψ)
 
+            @test IsfiniteStyle(ϕ₁) == FiniteStyle()
+
             @test @constinferred physicalspace(ϕ₁) == physicalspace(ψ)
             @test @constinferred left_virtualspace(ϕ₁) == left_virtualspace(ψ)
             @test @constinferred right_virtualspace(ϕ₁) == right_virtualspace(ψ)
@@ -266,6 +272,8 @@ module TestStates
             ϕ₁ = LeftGaugedQP(rand, ψ)
             ϕ₂ = LeftGaugedQP(rand, ψ)
 
+            @test IsfiniteStyle(ϕ₁) == InfiniteStyle()
+
             @test @constinferred physicalspace(ϕ₁) == physicalspace(ψ)
             @test @constinferred left_virtualspace(ϕ₁) == left_virtualspace(ψ)
             @test @constinferred right_virtualspace(ϕ₁) == right_virtualspace(ψ)