implement changes

Author: AFeuerpfeil

src/operators/abstractmpo.jl

@@ -11,6 +11,7 @@ abstract type AbstractMPO{O} <: AbstractVector{O} end
 const SparseMPO{O <: SparseBlockTensorMap} = AbstractMPO{O}
 
 # By default, define things in terms of parent
+Base.isfinite(mpo::AbstractMPO) = isfinite(typeof(mpo))
 Base.size(mpo::AbstractMPO, args...) = size(parent(mpo), args...)
 Base.length(mpo::AbstractMPO) = length(parent(mpo))
 eachsite(mpo::AbstractMPO) = eachindex(mpo)

src/states/windowmps.jl

@@ -50,8 +50,6 @@ struct WindowMPS{A <: GenericMPSTensor, B <: MPSBondTensor} <: AbstractFiniteMPS
     end
 end
 
-GeometryStyle(::Type{<:WindowMPS}) = WindowChainStyle()
-
 #===========================================================================================
 Constructors
 ===========================================================================================#

src/utility/multiline.jl

@@ -29,6 +29,7 @@ function Base.axes(m::Multiline, i::Int)
         i == 2 ? axes(parent(m)[1], 1) : throw(ArgumentError("Invalid index $i"))
 end
 Base.eachindex(m::Multiline) = CartesianIndices(size(m))
+Base.isfinite(m::Multiline) = isfinite(typeof(m))
 
 eachsite(m::Multiline) = eachsite(first(parent(m)))
 

src/utility/styles.jl

@@ -1,15 +1,14 @@
 """
-`OperatorStyle`
+    abstract type OperatorStyle end
 
 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.
+whether an operator represents a Hamiltonian operator (sum of terms)
+or a transfer matrix (product of factors).
 
 To opt a custom operator type into this dispatch scheme implement:
 ```julia
-OperatorStyle(::T) where {T<:YourOperatorType}
+OperatorStyle(::T) where {T <: YourOperatorType}
 ```
 """
 abstract type OperatorStyle end
@@ -21,17 +20,16 @@ struct HamiltonianStyle <: OperatorStyle end
 
 
 """
-`GeometryStyle`
+    abstract type GeometryStyle end
 
 Holy trait used as a dispatch tag to distinguish between different
 geometries Concrete subtypes
-(`FiniteChainStyle`, `InfiniteChainStyle` and `WindowChainStyle`) indicate whether a system is
-finite, infinite or a finite window in an infinite chain. Use `GeometryStyle` in method signatures to
-select implementation-specific code paths for different types.
+(`FiniteChainStyle`, `InfiniteChainStyle`) indicate whether a system is
+a finite or infinite chain.
 
 To opt a custom type into this dispatch scheme implement:
 ```julia
-GeometryStyle(::T) where {T<:YourType}
+GeometryStyle(::T) where {T <: YourType}
 ```
 """
 abstract type GeometryStyle end
@@ -40,4 +38,3 @@ GeometryStyle(T::Type) = throw(MethodError(GeometryStyle, T)) # avoid stackoverf
 
 struct FiniteChainStyle <: GeometryStyle end
 struct InfiniteChainStyle <: GeometryStyle end
-struct WindowChainStyle <: GeometryStyle end

test/operators.jl

@@ -10,7 +10,7 @@ module TestOperators
     using MPSKit
     using MPSKit: _transpose_front, _transpose_tail, C_hamiltonian, AC_hamiltonian,
         AC2_hamiltonian
-    using MPSKit: GeometryStyle, FiniteChainStyle, InfiniteChainStyle, WindowChainStyle, OperatorStyle, MPOStyle,
+    using MPSKit: GeometryStyle, FiniteChainStyle, InfiniteChainStyle, OperatorStyle, MPOStyle,
         HamiltonianStyle
     using TensorKit
     using TensorKit: ℙ

test/states.jl

@@ -9,7 +9,7 @@ module TestStates
     using Test, TestExtras
     using MPSKit
     using MPSKit: _transpose_front, _transpose_tail
-    using MPSKit: GeometryStyle, FiniteChainStyle, InfiniteChainStyle, WindowChainStyle
+    using MPSKit: GeometryStyle, FiniteChainStyle, InfiniteChainStyle
     using MPSKit: TransferMatrix
     using TensorKit
     using TensorKit: ℙ
@@ -190,10 +190,6 @@ module TestStates
         # constructor 2 - used to take a "slice" from an infinite mps
         window_2 = WindowMPS(gs, 10)
 
-        @test GeometryStyle(typeof(window_1)) == WindowChainStyle()
-        @test GeometryStyle(window_1) == WindowChainStyle()
-        @test GeometryStyle(window_1) == GeometryStyle(window_2)
-
         @test eltype(window_1) == eltype(typeof(window_1))
 
         P = @constinferred physicalspace(window_2)