format utility

Author: lkdvos

src/utility/defaults.jl

@@ -18,56 +18,62 @@ const VERBOSE_ALL = 4
 
 const eltype = ComplexF64
 const maxiter = 200
-const tolgauge = 1e-13
-const tol = 1e-10
+const tolgauge = 1.0e-13
+const tol = 1.0e-10
 const verbosity = VERBOSE_ITER
 const dynamic_tols = true
-const tol_min = 1e-14
-const tol_max = 1e-4
-const eigs_tolfactor = 1e-3
-const gauge_tolfactor = 1e-6
-const envs_tolfactor = 1e-4
+const tol_min = 1.0e-14
+const tol_max = 1.0e-4
+const eigs_tolfactor = 1.0e-3
+const gauge_tolfactor = 1.0e-6
+const envs_tolfactor = 1.0e-4
 const krylovdim = 30
 
 _finalize(iter, state, opp, envs) = (state, envs)
 
 const linearsolver = GMRES(; tol, maxiter)
-const eigsolver = Arnoldi(; tol, maxiter, eager=true)
+const eigsolver = Arnoldi(; tol, maxiter, eager = true)
 
 # Default algorithms
 # ------------------
 
-function alg_gauge(; tol=tolgauge, maxiter=maxiter, verbosity=VERBOSE_WARN,
-                   dynamic_tols=dynamic_tols, tol_min=tol_min, tol_max=tol_max,
-                   tol_factor=gauge_tolfactor)
+function alg_gauge(;
+        tol = tolgauge, maxiter = maxiter, verbosity = VERBOSE_WARN,
+        dynamic_tols = dynamic_tols, tol_min = tol_min, tol_max = tol_max,
+        tol_factor = gauge_tolfactor
+    )
     alg = (; tol, maxiter, verbosity)
     return dynamic_tols ? DynamicTol(alg, tol_min, tol_max, tol_factor) : alg
 end
 
-function alg_eigsolve(; ishermitian=true, tol=tol, maxiter=maxiter, verbosity=0,
-                      eager=true,
-                      krylovdim=krylovdim,
-                      dynamic_tols=dynamic_tols, tol_min=tol_min, tol_max=tol_max,
-                      tol_factor=eigs_tolfactor)
+function alg_eigsolve(;
+        ishermitian = true, tol = tol, maxiter = maxiter, verbosity = 0,
+        eager = true, krylovdim = krylovdim, dynamic_tols = dynamic_tols, tol_min = tol_min,
+        tol_max = tol_max, tol_factor = eigs_tolfactor
+    )
     alg = ishermitian ? Lanczos(; tol, maxiter, eager, krylovdim, verbosity) :
-          Arnoldi(; tol, maxiter, eager, krylovdim, verbosity)
+        Arnoldi(; tol, maxiter, eager, krylovdim, verbosity)
     return dynamic_tols ? DynamicTol(alg, tol_min, tol_max, tol_factor) : alg
 end
 
 alg_svd() = TensorKit.SDD()
 
 # TODO: make verbosity and maxiter actually do something
-function alg_environments(; tol=tol, maxiter=maxiter, verbosity=0,
-                          dynamic_tols=dynamic_tols, tol_min=tol_min, tol_max=tol_max,
-                          tol_factor=envs_tolfactor)
+function alg_environments(;
+        tol = tol, maxiter = maxiter, verbosity = 0,
+        dynamic_tols = dynamic_tols, tol_min = tol_min, tol_max = tol_max,
+        tol_factor = envs_tolfactor
+    )
     alg = (; tol, maxiter, verbosity)
     return dynamic_tols ? DynamicTol(alg, tol_min, tol_max, tol_factor) : alg
 end
 
-function alg_expsolve(; tol=tol, maxiter=maxiter, verbosity=0,
-                      ishermitian=true, krylovdim=krylovdim)
+function alg_expsolve(;
+        tol = tol, maxiter = maxiter, verbosity = 0, ishermitian = true,
+        krylovdim = krylovdim
+    )
     return ishermitian ? Lanczos(; tol, maxiter, krylovdim, verbosity) :
-           Arnoldi(; tol, maxiter, krylovdim, verbosity)
+        Arnoldi(; tol, maxiter, krylovdim, verbosity)
 end
 
 """
@@ -86,7 +92,7 @@ Set the `OhMyThreads` multi-threading scheduler parameters.
 The function either accepts a `scheduler` as an `OhMyThreads.Scheduler` or as a symbol where the corresponding parameters are specificed as keyword arguments.
 For a detailed description of all schedulers and their keyword arguments consult the [`OhMyThreads` documentation](https://juliafolds2.github.io/OhMyThreads.jl/stable/refs/api/#Schedulers).
 """
-function set_scheduler!(sc=OhMyThreads.Implementation.NotGiven(); kwargs...)
+function set_scheduler!(sc = OhMyThreads.Implementation.NotGiven(); kwargs...)
     if isempty(kwargs) && sc isa OhMyThreads.Implementation.NotGiven
         # default value: Serial if single-threaded, Dynamic otherwise
         scheduler[] = Threads.nthreads() == 1 ? SerialScheduler() : DynamicScheduler()

src/utility/dynamictols.jl

@@ -31,20 +31,25 @@ See also [`updatetol`](@ref).
 struct DynamicTol{A} <: Algorithm
     "parent algorithm"
     alg::A
+
     "minimal value of the dynamic tolerance"
     tol_min::Float64
+
     "maximal value of the dynamic tolerance"
     tol_max::Float64
+
     "tolerance factor for updating relative to current algorithm error"
     tol_factor::Float64
-    function DynamicTol(alg::A, tol_min::Real, tol_max::Real,
-                        tol_factor::Real) where {A}
+
+    function DynamicTol(
+            alg::A, tol_min::Real, tol_max::Real, tol_factor::Real
+        ) where {A}
         0 <= tol_min <= tol_max ||
             throw(ArgumentError("tol_min must be between 0 and tol_max"))
         return new{A}(alg, tol_min, tol_max, tol_factor)
     end
 end
-function DynamicTol(alg; tol_min=1e-6, tol_max=1e-2, tol_factor=0.1)
+function DynamicTol(alg; tol_min = 1.0e-6, tol_max = 1.0e-2, tol_factor = 0.1)
     return DynamicTol(alg, tol_min, tol_max, tol_factor)
 end
 

src/utility/iterativesolvers.jl

@@ -1,12 +1,12 @@
 # This file contains the definition of the IterativeSolver type and the solve! function.
 # Attempts to remove as much of the boilerplate code as possible from the iterative solvers.
 
-mutable struct IterativeSolver{A,B}
+mutable struct IterativeSolver{A, B}
     alg::A
     state::B
 end
 
-function Base.getproperty(it::IterativeSolver{A,B}, name::Symbol) where {A,B}
+function Base.getproperty(it::IterativeSolver{A, B}, name::Symbol) where {A, B}
     name === :alg || name === :state && return getfield(it, name)
 
     alg = getfield(it, :alg)

src/utility/linearcombination.jl

@@ -1,4 +1,4 @@
-struct LinearCombination{O<:Tuple,C<:Tuple}
+struct LinearCombination{O <: Tuple, C <: Tuple}
     opps::O
     coeffs::C
 end

src/utility/logging.jl

@@ -13,27 +13,28 @@ mutable struct IterLog
     name::AbstractString
     iter::Int
     error::Float64
-    objective::Union{Nothing,Number}
+    objective::Union{Nothing, Number}
 
     t_init::Float64
     t_prev::Float64
     t_last::Float64
 
     state::LogState
 end
-function IterLog(name="")
+function IterLog(name = "")
     t = Base.time()
     return IterLog(name, 0, NaN, nothing, t, t, t, INIT)
 end
 
 # Input
 # -----
 
-isapproxreal(x::Number) = isreal(x) || isapprox(imag(x), 0; atol=eps(abs(x))^(3 / 4))
+isapproxreal(x::Number) = isreal(x) || isapprox(imag(x), 0; atol = eps(abs(x))^(3 / 4))
 warnapproxreal(x::Number) = isapproxreal(x) || @warn "Objective has imaginary part: $x"
 
-function loginit!(log::IterLog, error::Float64,
-                  objective::Union{Nothing,Number}=nothing)
+function loginit!(
+        log::IterLog, error::Float64, objective::Union{Nothing, Number} = nothing
+    )
     log.iter = 0
     log.error = error
     log.objective = objective
@@ -44,8 +45,9 @@ function loginit!(log::IterLog, error::Float64,
     return log
 end
 
-function logiter!(log::IterLog, iter::Int, error::Float64,
-                  objective::Union{Nothing,Number}=nothing)
+function logiter!(
+        log::IterLog, iter::Int, error::Float64, objective::Union{Nothing, Number} = nothing
+    )
     log.iter = iter
     log.error = error
     log.objective = objective
@@ -57,8 +59,9 @@ function logiter!(log::IterLog, iter::Int, error::Float64,
     return log
 end
 
-function logfinish!(log::IterLog, iter::Int, error::Float64,
-                    objective::Union{Nothing,Number}=nothing)
+function logfinish!(
+        log::IterLog, iter::Int, error::Float64, objective::Union{Nothing, Number} = nothing
+    )
     log.iter = iter
     log.error = error
     log.objective = objective
@@ -70,8 +73,9 @@ function logfinish!(log::IterLog, iter::Int, error::Float64,
     return log
 end
 
-function logcancel!(log::IterLog, iter::Int, error::Float64,
-                    objective::Union{Nothing,Number}=nothing)
+function logcancel!(
+        log::IterLog, iter::Int, error::Float64, objective::Union{Nothing, Number} = nothing
+    )
     log.iter = iter
     log.error = error
     log.objective = objective
@@ -88,8 +92,8 @@ end
 
 function format_time(t::Float64)
     return t < 60 ? @sprintf("%0.2f sec", t) :
-           t < 2600 ? @sprintf("%0.2f min", t / 60) :
-           @sprintf("%0.2f hr", t / 3600)
+        t < 2600 ? @sprintf("%0.2f min", t / 60) :
+        @sprintf("%0.2f hr", t / 3600)
 end
 
 function format_objective(t::Number)

src/utility/multiline.jl

@@ -10,7 +10,7 @@ multiple lines of `InfiniteMPS` (`MultilineMPS`) or MPO (`Multiline{<:AbstractMP
 See also: [`MultilineMPS`](@ref) and [`MultilineMPO`](@ref)
 """
 struct Multiline{T}
-    data::PeriodicArray{T,1}
+    data::PeriodicArray{T, 1}
     function Multiline{T}(data::AbstractVector{T}) where {T}
         @assert allequal(length.(data)) "All lines must have the same length"
         return new{T}(data)
@@ -26,7 +26,7 @@ Base.size(m::Multiline, i::Int) = getindex(size(m), i)
 Base.length(m::Multiline) = prod(size(m))
 function Base.axes(m::Multiline, i::Int)
     return i == 1 ? axes(parent(m), 1) :
-           i == 2 ? axes(parent(m)[1], 1) : throw(ArgumentError("Invalid index $i"))
+        i == 2 ? axes(parent(m)[1], 1) : throw(ArgumentError("Invalid index $i"))
 end
 Base.eachindex(m::Multiline) = CartesianIndices(size(m))
 
@@ -41,7 +41,7 @@ Base.iterate(m::Multiline, args...) = iterate(parent(m), args...)
 # Utility functions
 # -----------------
 Base.circshift(A::Multiline, n::Int) = Multiline(circshift(parent(A), n))
-function Base.circshift(A::Multiline, shifts::Tuple{Int,Int})
+function Base.circshift(A::Multiline, shifts::Tuple{Int, Int})
     data′ = circshift.(parent(A), shifts[2])
     return Multiline(circshift!(data′, shifts[1]))
 end
@@ -58,7 +58,7 @@ end
 # ---------------
 VectorInterface.scalartype(::Type{Multiline{T}}) where {T} = scalartype(T)
 
-function VectorInterface.zerovector(x::Multiline, ::Type{S}) where {S<:Number}
+function VectorInterface.zerovector(x::Multiline, ::Type{S}) where {S <: Number}
     return Multiline(zerovector.(parent(x), S))
 end
 VectorInterface.zerovector!(x::Multiline) = (zerovector!.(parent(x)); x)

src/utility/periodicarray.jl

@@ -26,16 +26,16 @@ A[-1, 1], A[1, 1], A[4, 5]
 
 See also [`PeriodicVector`](@ref), [`PeriodicMatrix`](@ref)
 """
-struct PeriodicArray{T,N} <: AbstractArray{T,N}
-    data::Array{T,N}
+struct PeriodicArray{T, N} <: AbstractArray{T, N}
+    data::Array{T, N}
 end
-PeriodicArray(data::AbstractArray{T,N}) where {T,N} = PeriodicArray{T,N}(data)
-PeriodicArray{T}(data::AbstractArray{T,N}) where {T,N} = PeriodicArray{T,N}(data)
+PeriodicArray(data::AbstractArray{T, N}) where {T, N} = PeriodicArray{T, N}(data)
+PeriodicArray{T}(data::AbstractArray{T, N}) where {T, N} = PeriodicArray{T, N}(data)
 function PeriodicArray{T}(initializer, args...) where {T}
     return PeriodicArray(Array{T}(initializer, args...))
 end
-function PeriodicArray{T,N}(initializer, args...) where {T,N}
-    return PeriodicArray(Array{T,N}(initializer, args...))
+function PeriodicArray{T, N}(initializer, args...) where {T, N}
+    return PeriodicArray(Array{T, N}(initializer, args...))
 end
 
 """
@@ -44,7 +44,7 @@ end
 One-dimensional dense array with elements of type `T` and periodic boundary conditions.
 Alias for [`PeriodicArray{T,1}`](@ref).
 """
-const PeriodicVector{T} = PeriodicArray{T,1}
+const PeriodicVector{T} = PeriodicArray{T, 1}
 PeriodicVector(data::AbstractVector{T}) where {T} = PeriodicVector{T}(data)
 
 """
@@ -53,7 +53,7 @@ PeriodicVector(data::AbstractVector{T}) where {T} = PeriodicVector{T}(data)
 Two-dimensional dense array with elements of type `T` and periodic boundary conditions.
 Alias for [`PeriodicArray{T,2}`](@ref).
 """
-const PeriodicMatrix{T} = PeriodicArray{T,2}
+const PeriodicMatrix{T} = PeriodicArray{T, 2}
 PeriodicMatrix(data::AbstractMatrix{T}) where {T} = PeriodicMatrix{T}(data)
 
 Base.parent(A::PeriodicArray) = A.data
@@ -62,11 +62,11 @@ Base.parent(A::PeriodicArray) = A.data
 # -----------------------
 Base.size(A::PeriodicArray) = size(parent(A))
 
-function Base.getindex(A::PeriodicArray{T,N}, I::Vararg{Int,N}) where {T,N}
-    @inbounds getindex(parent(A), map(mod1, I, size(A))...)
+function Base.getindex(A::PeriodicArray{T, N}, I::Vararg{Int, N}) where {T, N}
+    return @inbounds getindex(parent(A), map(mod1, I, size(A))...)
 end
-function Base.setindex!(A::PeriodicArray{T,N}, v, I::Vararg{Int,N}) where {T,N}
-    @inbounds setindex!(parent(A), v, map(mod1, I, size(A))...)
+function Base.setindex!(A::PeriodicArray{T, N}, v, I::Vararg{Int, N}) where {T, N}
+    return @inbounds setindex!(parent(A), v, map(mod1, I, size(A))...)
 end
 
 Base.checkbounds(A::PeriodicArray, I...) = true
@@ -85,17 +85,18 @@ end
 
 # Broadcasting
 # ------------
-Base.BroadcastStyle(::Type{T}) where {T<:PeriodicArray} = Broadcast.ArrayStyle{T}()
+Base.BroadcastStyle(::Type{T}) where {T <: PeriodicArray} = Broadcast.ArrayStyle{T}()
 
-function Base.similar(bc::Broadcast.Broadcasted{<:Broadcast.ArrayStyle{<:PeriodicArray}},
-                      ::Type{T}) where {T}
+function Base.similar(
+        bc::Broadcast.Broadcasted{<:Broadcast.ArrayStyle{<:PeriodicArray}}, ::Type{T}
+    ) where {T}
     return PeriodicArray(similar(Array{T}, axes(bc)))
 end
 
 # Conversion
 # ----------
-Base.convert(::Type{T}, A::AbstractArray) where {T<:PeriodicArray} = T(A)
-Base.convert(::Type{T}, A::PeriodicArray) where {T<:AbstractArray} = convert(T, parent(A))
+Base.convert(::Type{T}, A::AbstractArray) where {T <: PeriodicArray} = T(A)
+Base.convert(::Type{T}, A::PeriodicArray) where {T <: AbstractArray} = convert(T, parent(A))
 # fix ambiguities
-Base.convert(::Type{T}, A::PeriodicArray) where {T<:PeriodicArray} = A
-Base.convert(::Type{T}, A::PeriodicArray) where {T<:Array} = parent(A)
+Base.convert(::Type{T}, A::PeriodicArray) where {T <: PeriodicArray} = A
+Base.convert(::Type{T}, A::PeriodicArray) where {T <: Array} = parent(A)