Renaming MPSMultiline and MPOMultiline to MultilineMPS and MultilineMPO (#210)

* find and replace `MPSMultiline` with `MultilineMPS`

* rename the rest of the `MPSMultiline` occurences

* find and replace `MPOMultiline` with `MultilineMPO`

* more finding and replacing `MPOMultiline` with `MultilineMPO`

Author: VictorVanthilt

docs/src/lib/lib.md

@@ -5,7 +5,7 @@
 FiniteMPS
 InfiniteMPS
 WindowMPS
-MPSMultiline
+MultilineMPS
 ```
 
 ## Operators

docs/src/man/states.md

@@ -133,9 +133,9 @@ Such a set can be created by
 
 ```julia
 data = fill(TensorMap(rand,ComplexF64,ℂ^10*ℂ^2,ℂ^10),2,2);
-MPSMultiline(data);
+MultilineMPS(data);
 ```
-MPSMultiline is also used extensively in as of yet unreleased peps code.
+MultilineMPS is also used extensively in as of yet unreleased peps code.
 
 You can access properties by calling
 ```julia
@@ -153,7 +153,7 @@ struct Multiline{T}
 end
 ```
 
-MPSMultiline/MPOMultiline are then defined as
+MultilineMPS/MultilineMPO are then defined as
 ```julia
-const MPSMultiline = Multiline{<:InfiniteMPS}
-const MPOMultiline = Multiline{<:DenseMPO}
+const MultilineMPS = Multiline{<:InfiniteMPS}
+const MultilineMPO = Multiline{<:DenseMPO}

src/MPSKit.jl

@@ -18,7 +18,7 @@ using Base: @kwdef
 using LoggingExtras
 
 # bells and whistles for mpses
-export InfiniteMPS, FiniteMPS, WindowMPS, MPSMultiline
+export InfiniteMPS, FiniteMPS, WindowMPS, MultilineMPS
 export PeriodicArray, PeriodicVector, PeriodicMatrix, WindowArray
 export MPSTensor
 export QP, LeftGaugedQP, RightGaugedQP
@@ -34,7 +34,7 @@ export braille
 export AbstractMPO
 export MPO, FiniteMPO, InfiniteMPO
 export MPOHamiltonian, FiniteMPOHamiltonian, InfiniteMPOHamiltonian
-export SparseMPO, DenseMPO, MPOMultiline
+export SparseMPO, DenseMPO, MultilineMPO
 export UntimedOperator, TimedOperator, MultipliedOperator, LazySum
 
 export ∂C, ∂AC, ∂AC2, environments, expectation_value, effective_excitation_hamiltonian
@@ -83,7 +83,7 @@ include("utility/linearcombination.jl")
 # maybe we should introduce an abstract state type
 include("states/abstractmps.jl")
 include("states/infinitemps.jl")
-include("states/mpsmultiline.jl")
+include("states/multilinemps.jl")
 include("states/finitemps.jl")
 include("states/windowmps.jl")
 include("states/orthoview.jl")
@@ -93,7 +93,7 @@ include("states/ortho.jl")
 include("operators/abstractmpo.jl")
 include("operators/mpo.jl")
 include("operators/mpohamiltonian.jl") # the mpohamiltonian objects
-include("operators/mpomultiline.jl")
+include("operators/multilinempo.jl")
 include("operators/projection.jl")
 include("operators/timedependence.jl")
 include("operators/multipliedoperator.jl")

src/algorithms/approximate/idmrg.jl

@@ -1,4 +1,4 @@
-function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                      alg::IDMRG1, oenvs=environments(ost, toapprox))
     ψ = copy(ost)
     mpo, above = toapprox
@@ -52,12 +52,12 @@ function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMult
         end
     end
 
-    nst = MPSMultiline(map(x -> x, ψ.AR); tol=alg.tol_gauge)
+    nst = MultilineMPS(map(x -> x, ψ.AR); tol=alg.tol_gauge)
     nenvs = environments(nst, toapprox)
     return nst, nenvs, ϵ
 end
 
-function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                      alg::IDMRG2, oenvs=environments(ost, toapprox))
     length(ost) < 2 && throw(ArgumentError("unit cell should be >= 2"))
     mpo, above = toapprox
@@ -139,7 +139,7 @@ function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMult
         end
     end
 
-    nst = MPSMultiline(map(x -> x, ψ.AR); tol=alg.tol_gauge)
+    nst = MultilineMPS(map(x -> x, ψ.AR); tol=alg.tol_gauge)
     nenvs = environments(nst, toapprox)
     return nst, nenvs, ϵ
 end

src/algorithms/approximate/vomps.jl

@@ -1,22 +1,22 @@
 function approximate(ψ::InfiniteMPS,
                      toapprox::Tuple{<:InfiniteMPO,<:InfiniteMPS}, algorithm,
                      envs=environments(ψ, toapprox))
-    # PeriodicMPO's always act on MPSMultiline's. To avoid code duplication, define everything in terms of MPSMultiline's.
-    multi, envs = approximate(convert(MPSMultiline, ψ),
-                              (convert(MPOMultiline, toapprox[1]),
-                               convert(MPSMultiline, toapprox[2])), algorithm, envs)
+    # PeriodicMPO's always act on MultilineMPS's. To avoid code duplication, define everything in terms of MultilineMPS's.
+    multi, envs = approximate(convert(MultilineMPS, ψ),
+                              (convert(MultilineMPO, toapprox[1]),
+                               convert(MultilineMPS, toapprox[2])), algorithm, envs)
     ψ = convert(InfiniteMPS, multi)
     return ψ, envs
 end
 
-Base.@deprecate(approximate(ψ::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+Base.@deprecate(approximate(ψ::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                             alg::VUMPS, envs...; kwargs...),
                 approximate(ψ, toapprox,
                             VOMPS(; alg.tol, alg.maxiter, alg.finalize,
                                   alg.verbosity, alg.alg_gauge, alg.alg_environments),
                             envs...; kwargs...))
 
-function approximate(ψ::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+function approximate(ψ::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                      alg::VOMPS, envs=environments(ψ, toapprox))
     ϵ::Float64 = calc_galerkin(ψ, envs)
     temp_ACs = similar.(ψ.AC)
@@ -38,7 +38,7 @@ function approximate(ψ::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMulti
             end
 
             alg_gauge = updatetol(alg.alg_gauge, iter, ϵ)
-            ψ = MPSMultiline(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
+            ψ = MultilineMPS(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
 
             alg_environments = updatetol(alg.alg_environments, iter, ϵ)
             recalculate!(envs, ψ; alg_environments.tol)

src/algorithms/changebonds/changebonds.jl

@@ -36,7 +36,7 @@ function _expand!(ψ::InfiniteMPS, AL′::PeriodicVector, AR′::PeriodicVector)
     end
     return normalize!(ψ)
 end
-function _expand!(ψ::MPSMultiline, AL′::PeriodicMatrix, AR′::PeriodicMatrix)
+function _expand!(ψ::MultilineMPS, AL′::PeriodicMatrix, AR′::PeriodicMatrix)
     for i in 1:size(ψ, 1)
         _expand!(ψ[i], AL′[i, :], AR′[i, :])
     end

src/algorithms/changebonds/optimalexpand.jl

@@ -38,11 +38,11 @@ end
 
 function changebonds(ψ::InfiniteMPS, H::DenseMPO, alg::OptimalExpand,
                      envs=environments(ψ, H))
-    (nmψ, envs) = changebonds(convert(MPSMultiline, ψ), convert(MPOMultiline, H), alg, envs)
+    (nmψ, envs) = changebonds(convert(MultilineMPS, ψ), convert(MultilineMPO, H), alg, envs)
     return (convert(InfiniteMPS, nmψ), envs)
 end
 
-function changebonds(ψ::MPSMultiline, H, alg::OptimalExpand, envs=environments(ψ, H))
+function changebonds(ψ::MultilineMPS, H, alg::OptimalExpand, envs=environments(ψ, H))
     TL = eltype(ψ.AL)
     AL′ = PeriodicMatrix{TL}(undef, size(ψ.AL))
     TR = tensormaptype(spacetype(TL), 1, numind(TL) - 1, storagetype(TL))

src/algorithms/changebonds/randexpand.jl

@@ -33,7 +33,7 @@ function changebonds(ψ::InfiniteMPS, alg::RandExpand)
     return _expand(ψ, AL′, AR′)
 end
 
-function changebonds(ψ::MPSMultiline, alg::RandExpand)
+function changebonds(ψ::MultilineMPS, alg::RandExpand)
     return Multiline(map(x -> changebonds(x, alg), ψ.data))
 end
 

src/algorithms/changebonds/svdcut.jl

@@ -68,10 +68,10 @@ end
 function changebonds(ψ::InfiniteMPO, alg::SvdCut)
     return convert(InfiniteMPO, changebonds(convert(InfiniteMPS, ψ), alg))
 end
-function changebonds(ψ::MPOMultiline, alg::SvdCut)
-    return convert(MPOMultiline, changebonds(convert(MPSMultiline, ψ), alg))
+function changebonds(ψ::MultilineMPO, alg::SvdCut)
+    return convert(MultilineMPO, changebonds(convert(MultilineMPS, ψ), alg))
 end
-function changebonds(ψ::MPSMultiline, alg::SvdCut)
+function changebonds(ψ::MultilineMPS, alg::SvdCut)
     return Multiline(map(x -> changebonds(x, alg), ψ.data))
 end
 function changebonds(ψ::InfiniteMPS, alg::SvdCut)

src/algorithms/derivatives.jl

@@ -34,21 +34,21 @@ Base.:*(h::Union{MPO_∂∂C,MPO_∂∂AC,MPO_∂∂AC2}, v) = h(v);
 function ∂∂C(pos::Int, mps, operator::AbstractMPO, cache)
     return MPO_∂∂C(leftenv(cache, pos + 1, mps), rightenv(cache, pos, mps))
 end
-function ∂∂C(col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂C(col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂C(leftenv(envs, col + 1, mps), rightenv(envs, col, mps))
 end
-function ∂∂C(row::Int, col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂C(row::Int, col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂C(leftenv(envs, row, col + 1, mps), rightenv(envs, row, col, mps))
 end
 
 function ∂∂AC(pos::Int, mps, operator::AbstractMPO, cache)
     return MPO_∂∂AC(operator[pos], leftenv(cache, pos, mps), rightenv(cache, pos, mps))
 end
-function ∂∂AC(row::Int, col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC(row::Int, col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC(operator[row, col], leftenv(envs, row, col, mps),
                     rightenv(envs, row, col, mps))
 end
-function ∂∂AC(col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC(col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC(envs.operator[:, col], leftenv(envs, col, mps),
                     rightenv(envs, col, mps))
 end;
@@ -57,11 +57,11 @@ function ∂∂AC2(pos::Int, mps, operator::AbstractMPO, cache)
     return MPO_∂∂AC2(operator[pos], operator[pos + 1], leftenv(cache, pos, mps),
                      rightenv(cache, pos + 1, mps))
 end;
-function ∂∂AC2(col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC2(col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC2(operator[:, col], operator[:, col + 1], leftenv(envs, col, mps),
                      rightenv(envs, col + 1, mps))
 end
-function ∂∂AC2(row::Int, col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC2(row::Int, col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC2(operator[row, col], operator[row, col + 1],
                      leftenv(envs, row, col, mps), rightenv(envs, row, col + 1, mps))
 end