format operators

Author: lkdvos

src/operators/abstractmpo.jl

@@ -8,7 +8,7 @@ Abstract supertype for Matrix Product Operators (MPOs).
 abstract type AbstractMPO{O} <: AbstractVector{O} end
 
 # useful union types
-const SparseMPO{O<:SparseBlockTensorMap} = AbstractMPO{O}
+const SparseMPO{O <: SparseBlockTensorMap} = AbstractMPO{O}
 Base.isfinite(O::AbstractMPO) = isfinite(typeof(O))
 
 # By default, define things in terms of parent
@@ -32,13 +32,13 @@ physicalspace(mpo::AbstractMPO) = map(physicalspace, mpo)
 
 for ftype in (:spacetype, :sectortype, :storagetype)
     @eval TensorKit.$ftype(mpo::AbstractMPO) = $ftype(typeof(mpo))
-    @eval TensorKit.$ftype(::Type{MPO}) where {MPO<:AbstractMPO} = $ftype(eltype(MPO))
+    @eval TensorKit.$ftype(::Type{MPO}) where {MPO <: AbstractMPO} = $ftype(eltype(MPO))
 end
 
 # Utility functions
 # -----------------
-remove_orphans!(mpo::AbstractMPO; tol=eps(real(scalartype(mpo)))^(3 / 4)) = mpo
-function remove_orphans!(mpo::SparseMPO; tol=eps(real(scalartype(mpo)))^(3 / 4))
+remove_orphans!(mpo::AbstractMPO; tol = eps(real(scalartype(mpo)))^(3 / 4)) = mpo
+function remove_orphans!(mpo::SparseMPO; tol = eps(real(scalartype(mpo)))^(3 / 4))
     droptol!.(mpo, tol)
 
     if isfinite(mpo)
@@ -70,7 +70,7 @@ function remove_orphans!(mpo::SparseMPO; tol=eps(real(scalartype(mpo)))^(3 / 4))
                 # slice empty columns on right or empty rows on left
                 mask = filter(1:size(mpo[i], 4)) do j
                     return j ∈ getindex.(nonzero_keys(mpo[i]), 4) &&
-                           j ∈ getindex.(nonzero_keys(mpo[i + 1]), 1)
+                        j ∈ getindex.(nonzero_keys(mpo[i + 1]), 1)
                 end
                 changed |= length(mask) == size(mpo[i], 4)
                 mpo[i] = mpo[i][:, :, :, mask]
@@ -130,20 +130,14 @@ function _fuse_mpo_mpo(O1::MPOTensor, O2::MPOTensor, Fₗ, Fᵣ)
             physicalspace(O2) ⊗ fuse(right_virtualspace(O2) ⊗ right_virtualspace(O1))
         return BraidingTensor{T}(V)
     elseif O1 isa BraidingTensor
-        @plansor O′[-1 -2; -3 -4] := Fₗ[-1; 1 2] *
-                                     O2[1 3; -3 5] *
-                                     τ[2 -2; 3 4] *
-                                     conj(Fᵣ[-4; 5 4])
+        @plansor O′[-1 -2; -3 -4] := Fₗ[-1; 1 2] * O2[1 3; -3 5] *
+            τ[2 -2; 3 4] * conj(Fᵣ[-4; 5 4])
     elseif O2 isa BraidingTensor
-        @plansor O′[-1 -2; -3 -4] := Fₗ[-1; 1 2] *
-                                     τ[1 3; -3 5] *
-                                     O1[2 -2; 3 4] *
-                                     conj(Fᵣ[-4; 5 4])
+        @plansor O′[-1 -2; -3 -4] := Fₗ[-1; 1 2] * τ[1 3; -3 5] *
+            O1[2 -2; 3 4] * conj(Fᵣ[-4; 5 4])
     else
-        @plansor O′[-1 -2; -3 -4] := Fₗ[-1; 1 2] *
-                                     O2[1 3; -3 5] *
-                                     O1[2 -2; 3 4] *
-                                     conj(Fᵣ[-4; 5 4])
+        @plansor O′[-1 -2; -3 -4] := Fₗ[-1; 1 2] * O2[1 3; -3 5] *
+            O1[2 -2; 3 4] * conj(Fᵣ[-4; 5 4])
     end
 end
 
@@ -164,8 +158,9 @@ function fuse_mul_mpo(O1::BraidingTensor, O2::BraidingTensor)
         physicalspace(O2) ⊗ fuse(right_virtualspace(O2) ⊗ right_virtualspace(O1))
     return BraidingTensor{T}(V)
 end
-function fuse_mul_mpo(O1::AbstractBlockTensorMap{T₁,S,2,2},
-                      O2::AbstractBlockTensorMap{T₂,S,2,2}) where {T₁,T₂,S}
+function fuse_mul_mpo(
+        O1::AbstractBlockTensorMap{T₁, S, 2, 2}, O2::AbstractBlockTensorMap{T₂, S, 2, 2}
+    ) where {T₁, T₂, S}
     TT = promote_type((eltype(O1)), eltype((O2)))
     V = fuse(left_virtualspace(O2) ⊗ left_virtualspace(O1)) ⊗ physicalspace(O1) ←
         physicalspace(O2) ⊗ fuse(right_virtualspace(O2) ⊗ right_virtualspace(O1))
@@ -174,10 +169,10 @@ function fuse_mul_mpo(O1::AbstractBlockTensorMap{T₁,S,2,2},
     else
         O = BlockTensorMap{TT}(undef, V)
     end
-    cartesian_inds = reshape(CartesianIndices(O),
-                             size(O2, 1), size(O1, 1),
-                             size(O, 2), size(O, 3),
-                             size(O2, 4), size(O1, 4))
+    cartesian_inds = reshape(
+        CartesianIndices(O),
+        size(O2, 1), size(O1, 1), size(O, 2), size(O, 3), size(O2, 4), size(O1, 4)
+    )
     for (I, o2) in nonzero_pairs(O2), (J, o1) in nonzero_pairs(O1)
         K = cartesian_inds[I[1], J[1], I[2], I[3], I[4], J[4]]
         O[K] = fuse_mul_mpo(o1, o2)
@@ -190,8 +185,7 @@ function add_physical_charge(O::MPOTensor, charge::Sector)
     auxspace = Vect[typeof(charge)](charge => 1)'
     F = fuser(scalartype(O), physicalspace(O), auxspace)
     @plansor O_charged[-1 -2; -3 -4] := F[-2; 1 2] *
-                                        O[-1 1; 4 3] *
-                                        τ[3 2; 5 -4] * conj(F[-3; 4 5])
+        O[-1 1; 4 3] * τ[3 2; 5 -4] * conj(F[-3; 4 5])
     return O_charged
 end
 function add_physical_charge(O::BraidingTensor, charge::Sector)
@@ -201,12 +195,14 @@ function add_physical_charge(O::BraidingTensor, charge::Sector)
         fuse(physicalspace(O), auxspace) ⊗ right_virtualspace(O)
     return BraidingTensor{scalartype(O)}(V)
 end
-function add_physical_charge(O::AbstractBlockTensorMap{<:Any,<:Any,2,2}, charge::Sector)
+function add_physical_charge(O::AbstractBlockTensorMap{<:Any, <:Any, 2, 2}, charge::Sector)
     sectortype(O) == typeof(charge) || throw(SectorMismatch())
     auxspace = Vect[typeof(charge)](charge => 1)'
-    Odst = similar(O,
-                   left_virtualspace(O) ⊗ fuse(physicalspace(O), auxspace) ←
-                   fuse(physicalspace(O), auxspace) ⊗ right_virtualspace(O))
+    Odst = similar(
+        O,
+        left_virtualspace(O) ⊗ fuse(physicalspace(O), auxspace) ←
+            fuse(physicalspace(O), auxspace) ⊗ right_virtualspace(O)
+    )
     for (I, v) in nonzero_pairs(O)
         Odst[I] = add_physical_charge(v, charge)
     end
@@ -216,9 +212,11 @@ end
 # Contractions
 # ------------
 # This function usually does not require to be specified for many N, so @generated function is fine?
-@generated function _instantiate_finitempo(L::AbstractTensorMap{<:Any,S,1,2},
-                                           O::NTuple{N,MPOTensor{S}},
-                                           R::AbstractTensorMap{<:Any,S,2,1}) where {N,S}
+@generated function _instantiate_finitempo(
+        L::AbstractTensorMap{<:Any, S, 1, 2},
+        O::NTuple{N, MPOTensor{S}},
+        R::AbstractTensorMap{<:Any, S, 2, 1}
+    ) where {N, S}
     sites = N + 2
     t_out = tensorexpr(:T, -(1:sites), -(1:sites) .- sites)
     t_left = tensorexpr(:L, -1, (-1 - sites, 1))
@@ -230,10 +228,12 @@ end
     return macroexpand(@__MODULE__, ex)
 end
 
-@generated function _apply_finitempo(x::AbstractTensorMap{<:Any,S,M,A},
-                                     L::AbstractTensorMap{<:Any,S,1,2},
-                                     O::NTuple{N,MPOTensor{S}},
-                                     R::AbstractTensorMap{<:Any,S,2,1}) where {N,M,S,A}
+@generated function _apply_finitempo(
+        x::AbstractTensorMap{<:Any, S, M, A},
+        L::AbstractTensorMap{<:Any, S, 1, 2},
+        O::NTuple{N, MPOTensor{S}},
+        R::AbstractTensorMap{<:Any, S, 2, 1}
+    ) where {N, M, S, A}
     M == N + 2 || throw(ArgumentError("Incompatible number of spaces"))
     t_out = tensorexpr(:y, -(1:M), -(1:A) .- M)
     t_in = tensorexpr(:x, 1:2:(2M - 1), -(1:A) .- M)