From 46481734564803742ca81a812a696b74ea5c81ac Mon Sep 17 00:00:00 2001 From: Lukas Devos Date: Thu, 24 Jul 2025 09:50:46 -0400 Subject: [PATCH 1/2] runic formatter --- docs/make.jl | 24 +-- src/auxiliary/sparsetensorarray.jl | 83 ++++---- src/linalg/factorizations.jl | 95 +++++---- src/linalg/linalg.jl | 38 ++-- .../abstractblocktensor/abstractarray.jl | 76 ++++--- .../abstractblocktensor.jl | 2 +- .../abstractblocktensor/abstracttensormap.jl | 19 +- src/tensors/abstractblocktensor/conversion.jl | 16 +- src/tensors/abstractblocktensor/show.jl | 3 +- src/tensors/abstractblocktensor/sparsity.jl | 2 +- src/tensors/adjointblocktensor.jl | 11 +- src/tensors/blocktensor.jl | 104 +++++----- src/tensors/indexmanipulations.jl | 186 ++++++++---------- src/tensors/sparseblocktensor.jl | 79 ++++---- src/tensors/tensoroperations.jl | 123 +++++------- src/tensors/vectorinterface.jl | 2 +- src/vectorspaces/sumspace.jl | 74 +++---- src/vectorspaces/sumspaceindices.jl | 62 +++--- test/abstracttensor/blocktensor.jl | 4 +- test/abstracttensor/sparseblocktensor.jl | 5 +- test/aqua.jl | 2 +- test/linalg/factorizations.jl | 12 +- test/linalg/vectorinterface.jl | 6 +- 23 files changed, 479 insertions(+), 549 deletions(-) diff --git a/docs/make.jl b/docs/make.jl index f9f41b7..c45741f 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -8,18 +8,18 @@ pages = [ ] makedocs(; - modules=[BlockTensorKit], - sitename="BlockTensorKit.jl", - authors="Lukas Devos", - warnonly=[:missing_docs, :cross_references], - format=Documenter.HTML(; - prettyurls=get(ENV, "CI", nothing) == "true", - mathengine=MathJax(), - repolink="https://github.com/lkdvos/BlockTensorKit.jl.git", + modules = [BlockTensorKit], + sitename = "BlockTensorKit.jl", + authors = "Lukas Devos", + warnonly = [:missing_docs, :cross_references], + format = Documenter.HTML(; + prettyurls = get(ENV, "CI", nothing) == "true", + mathengine = MathJax(), + repolink = "https://github.com/lkdvos/BlockTensorKit.jl.git", ), - pages=pages, - pagesonly=true, - repo="github.com/lkdvos/BlockTensorKit.jl.git", + pages = pages, + pagesonly = true, + repo = "github.com/lkdvos/BlockTensorKit.jl.git", ) -deploydocs(; repo="github.com/lkdvos/BlockTensorKit.jl.git", push_preview=true) +deploydocs(; repo = "github.com/lkdvos/BlockTensorKit.jl.git", push_preview = true) diff --git a/src/auxiliary/sparsetensorarray.jl b/src/auxiliary/sparsetensorarray.jl index 7df01c3..138ac21 100644 --- a/src/auxiliary/sparsetensorarray.jl +++ b/src/auxiliary/sparsetensorarray.jl @@ -1,33 +1,33 @@ # SparseBlockTensorMap parent array # --------------------------------- -struct SparseTensorArray{S,N₁,N₂,T<:AbstractTensorMap{<:Any,S,N₁,N₂},N} <: - AbstractArray{T,N} - data::Dict{CartesianIndex{N},T} - space::TensorMapSumSpace{S,N₁,N₂} - function SparseTensorArray{S,N₁,N₂,T,N}( - data::Dict{CartesianIndex{N},T}, space::TensorMapSumSpace{S,N₁,N₂} - ) where {S,N₁,N₂,T,N} +struct SparseTensorArray{S, N₁, N₂, T <: AbstractTensorMap{<:Any, S, N₁, N₂}, N} <: + AbstractArray{T, N} + data::Dict{CartesianIndex{N}, T} + space::TensorMapSumSpace{S, N₁, N₂} + function SparseTensorArray{S, N₁, N₂, T, N}( + data::Dict{CartesianIndex{N}, T}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {S, N₁, N₂, T, N} N₁ + N₂ == N || throw( TypeError( :SparseTensorArray, - SparseTensorArray{S,N₁,N₂,T,N₁ + N₂}, - SparseTensorArray{S,N₁,N₂,T,N}, + SparseTensorArray{S, N₁, N₂, T, N₁ + N₂}, + SparseTensorArray{S, N₁, N₂, T, N}, ), ) - return new{S,N₁,N₂,T,N}(data, space) + return new{S, N₁, N₂, T, N}(data, space) end end -function SparseTensorArray{S,N₁,N₂,T,N}( - ::UndefInitializer, space::TensorMapSumSpace{S,N₁,N₂} -) where {S,N₁,N₂,T<:AbstractTensorMap{<:Any,S,N₁,N₂},N} - return SparseTensorArray{S,N₁,N₂,T,N}(Dict{CartesianIndex{N},T}(), space) +function SparseTensorArray{S, N₁, N₂, T, N}( + ::UndefInitializer, space::TensorMapSumSpace{S, N₁, N₂} + ) where {S, N₁, N₂, T <: AbstractTensorMap{<:Any, S, N₁, N₂}, N} + return SparseTensorArray{S, N₁, N₂, T, N}(Dict{CartesianIndex{N}, T}(), space) end function SparseTensorArray( - data::Dict{CartesianIndex{N},T}, space::TensorMapSumSpace{S,N₁,N₂} -) where {S,N₁,N₂,T,N} - return SparseTensorArray{S,N₁,N₂,T,N}(data, space) + data::Dict{CartesianIndex{N}, T}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {S, N₁, N₂, T, N} + return SparseTensorArray{S, N₁, N₂, T, N}(data, space) end Base.pairs(A::SparseTensorArray) = pairs(A.data) @@ -41,29 +41,29 @@ TensorKit.space(A::SparseTensorArray) = A.space Base.size(A::SparseTensorArray) = ntuple(i -> length(space(A)[i]), ndims(A)) @inline function Base.getindex( - A::SparseTensorArray{S,N₁,N₂,T,N}, I::Vararg{Int,N} -) where {S,N₁,N₂,T,N} + A::SparseTensorArray{S, N₁, N₂, T, N}, I::Vararg{Int, N} + ) where {S, N₁, N₂, T, N} @boundscheck checkbounds(A, I...) return @inbounds get(A.data, CartesianIndex(I)) do return fill!(similar(T, eachspace(A)[I...]), zero(scalartype(T))) end end @inline function getindex!( - A::SparseTensorArray{S,N₁,N₂,T,N}, I::CartesianIndex{N} -) where {S,N₁,N₂,T,N} + A::SparseTensorArray{S, N₁, N₂, T, N}, I::CartesianIndex{N} + ) where {S, N₁, N₂, T, N} @boundscheck checkbounds(A, I) return @inbounds get!(A.data, I) do return fill!(similar(T, eachspace(A)[I]), zero(scalartype(T))) end end @inline function getindex!( - A::SparseTensorArray{S,N₁,N₂,T,N}, I::Vararg{Int,N} -) where {S,N₁,N₂,T,N} + A::SparseTensorArray{S, N₁, N₂, T, N}, I::Vararg{Int, N} + ) where {S, N₁, N₂, T, N} return getindex!(A, CartesianIndex(I)) end @inline function Base.setindex!( - A::SparseTensorArray{S,N₁,N₂,T,N}, v, I::Vararg{Int,N} -) where {S,N₁,N₂,T,N} + A::SparseTensorArray{S, N₁, N₂, T, N}, v, I::Vararg{Int, N} + ) where {S, N₁, N₂, T, N} @boundscheck begin checkbounds(A, I...) checkspaces(A, v, I...) @@ -72,26 +72,26 @@ end return A end -function Base.delete!(A::SparseTensorArray, I::Vararg{Int,N}) where {N} +function Base.delete!(A::SparseTensorArray, I::Vararg{Int, N}) where {N} return delete!(A.data, CartesianIndex(I)) end Base.delete!(A::SparseTensorArray, I::CartesianIndex) = delete!(A.data, I) Base.empty!(A::SparseTensorArray) = empty!(A.data) -function Base.haskey(A::SparseTensorArray, I::Vararg{Int,N}) where {N} +function Base.haskey(A::SparseTensorArray, I::Vararg{Int, N}) where {N} return haskey(A.data, CartesianIndex(I)) end Base.haskey(A::SparseTensorArray, I::CartesianIndex) = haskey(A.data, I) function Base.similar( - ::SparseTensorArray, ::Type{T}, spaces::TensorMapSumSpace{S,N₁,N₂} -) where {S,N₁,N₂,T<:AbstractTensorMap{<:Any,S,N₁,N₂}} + ::SparseTensorArray, ::Type{T}, spaces::TensorMapSumSpace{S, N₁, N₂} + ) where {S, N₁, N₂, T <: AbstractTensorMap{<:Any, S, N₁, N₂}} N = N₁ + N₂ - return SparseTensorArray{S,N₁,N₂,T,N}(Dict{CartesianIndex{N},T}(), spaces) + return SparseTensorArray{S, N₁, N₂, T, N}(Dict{CartesianIndex{N}, T}(), spaces) end Base.@propagate_inbounds function Base.copyto!( - t::SparseTensorArray, v::SubArray{T,N,A} -) where {T,N,A<:SparseTensorArray} + t::SparseTensorArray, v::SubArray{T, N, A} + ) where {T, N, A <: SparseTensorArray} undropped_parentindices = map(Base.parentindices(v)) do I I isa Base.ScalarIndex ? (I:I) : I end @@ -108,8 +108,8 @@ Base.@propagate_inbounds function Base.copyto!( end Base.@propagate_inbounds function Base.copyto!( - t::SubArray{T,N,A}, v::SparseTensorArray -) where {T,N,A<:SparseTensorArray} + t::SubArray{T, N, A}, v::SparseTensorArray + ) where {T, N, A <: SparseTensorArray} undropped_parentindices = map(Base.parentindices(t)) do I I isa Base.ScalarIndex ? (I:I) : I end @@ -126,11 +126,9 @@ Base.@propagate_inbounds function Base.copyto!( end Base.@propagate_inbounds function Base.copyto!( - dest::SparseTensorArray, - Rdest::CartesianIndices, - src::SparseTensorArray, - Rsrc::CartesianIndices, -) + dest::SparseTensorArray, Rdest::CartesianIndices, + src::SparseTensorArray, Rsrc::CartesianIndices, + ) isempty(Rdest) && return dest if size(Rdest) != size(Rsrc) throw( @@ -174,10 +172,9 @@ function _newindices(I::Tuple, indices::Tuple) end function Base._unsafe_getindex( - ::IndexCartesian, - t::SparseTensorArray{S,N₁,N₂,T,N}, - I::Vararg{Union{Real,AbstractArray},N}, -) where {S,N₁,N₂,T,N} + ::IndexCartesian, + t::SparseTensorArray{S, N₁, N₂, T, N}, I::Vararg{Union{Real, AbstractArray}, N}, + ) where {S, N₁, N₂, T, N} dest = similar(t, eltype(t), space(eachspace(t)[I...])) indices = Base.to_indices(t, I) for (k, v) in t.data diff --git a/src/linalg/factorizations.jl b/src/linalg/factorizations.jl index 8281e5a..e57a0ad 100644 --- a/src/linalg/factorizations.jl +++ b/src/linalg/factorizations.jl @@ -1,22 +1,21 @@ using TensorKit: QR, QRpos, QL, QLpos, SVD, SDD, Polar, LQ, LQpos, RQ, RQpos function TK.leftorth!( - t::AbstractBlockTensorMap; - alg::Union{QR,QRpos,QL,QLpos,SVD,SDD,Polar}=QRpos(), - atol::Real=zero(float(real(scalartype(t)))), - rtol::Real=if (alg ∉ (SVD(), SDD())) - zero(float(real(scalartype(t)))) - else - eps(real(float(one(scalartype(t))))) * iszero(atol) - end, -) - InnerProductStyle(t) === EuclideanInnerProduct() || - throw_invalid_innerproduct(:leftorth!) + t::AbstractBlockTensorMap; + alg::Union{QR, QRpos, QL, QLpos, SVD, SDD, Polar} = QRpos(), + atol::Real = zero(float(real(scalartype(t)))), + rtol::Real = if (alg ∉ (SVD(), SDD())) + zero(float(real(scalartype(t)))) + else + eps(real(float(one(scalartype(t))))) * iszero(atol) + end, + ) + InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:leftorth!) if !iszero(rtol) atol = max(atol, rtol * norm(t)) end I = sectortype(t) - dims = TK.SectorDict{I,Int}() + dims = TK.SectorDict{I, Int}() # compute QR factorization for each block if !isempty(TK.blocks(t)) @@ -59,22 +58,22 @@ function TK.leftorth!(t::SparseBlockTensorMap; kwargs...) end function TK.leftnull!( - t::BlockTensorMap; - alg::Union{QR,QRpos,SVD,SDD}=QRpos(), - atol::Real=zero(float(real(scalartype(t)))), - rtol::Real=if (alg ∉ (SVD(), SDD())) - zero(float(real(scalartype(t)))) - else - eps(real(float(one(scalartype(t))))) * iszero(atol) - end, -) + t::BlockTensorMap; + alg::Union{QR, QRpos, SVD, SDD} = QRpos(), + atol::Real = zero(float(real(scalartype(t)))), + rtol::Real = if (alg ∉ (SVD(), SDD())) + zero(float(real(scalartype(t)))) + else + eps(real(float(one(scalartype(t))))) * iszero(atol) + end, + ) InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:leftnull!) if !iszero(rtol) atol = max(atol, rtol * norm(t)) end I = sectortype(t) - dims = SectorDict{I,Int}() + dims = SectorDict{I, Int}() # compute QR factorization for each block V = codomain(t) @@ -104,22 +103,22 @@ end TK.leftnull!(t::SparseBlockTensorMap; kwargs...) = leftnull!(BlockTensorMap(t); kwargs...) function TK.rightorth!( - t::AbstractBlockTensorMap; - alg::Union{LQ,LQpos,RQ,RQpos,SVD,SDD,Polar}=LQpos(), - atol::Real=zero(float(real(scalartype(t)))), - rtol::Real=if (alg ∉ (SVD(), SDD())) - zero(float(real(scalartype(t)))) - else - eps(real(float(one(scalartype(t))))) * iszero(atol) - end, -) + t::AbstractBlockTensorMap; + alg::Union{LQ, LQpos, RQ, RQpos, SVD, SDD, Polar} = LQpos(), + atol::Real = zero(float(real(scalartype(t)))), + rtol::Real = if (alg ∉ (SVD(), SDD())) + zero(float(real(scalartype(t)))) + else + eps(real(float(one(scalartype(t))))) * iszero(atol) + end, + ) InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:rightorth!) if !iszero(rtol) atol = max(atol, rtol * norm(t)) end I = sectortype(t) - dims = TK.SectorDict{I,Int}() + dims = TK.SectorDict{I, Int}() # compute LQ factorization for each block if !isempty(TK.blocks(t)) @@ -162,22 +161,22 @@ function TK.rightorth!(t::SparseBlockTensorMap; kwargs...) end function TK.rightnull!( - t::BlockTensorMap; - alg::Union{LQ,LQpos,SVD,SDD}=LQpos(), - atol::Real=zero(float(real(scalartype(t)))), - rtol::Real=if (alg ∉ (SVD(), SDD())) - zero(float(real(scalartype(t)))) - else - eps(real(float(one(scalartype(t))))) * iszero(atol) - end, -) + t::BlockTensorMap; + alg::Union{LQ, LQpos, SVD, SDD} = LQpos(), + atol::Real = zero(float(real(scalartype(t)))), + rtol::Real = if (alg ∉ (SVD(), SDD())) + zero(float(real(scalartype(t)))) + else + eps(real(float(one(scalartype(t))))) * iszero(atol) + end, + ) InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:rightnull!) if !iszero(rtol) atol = max(atol, rtol * norm(t)) end I = sectortype(t) - dims = SectorDict{I,Int}() + dims = SectorDict{I, Int}() # compute LQ factorization for each block V = domain(t) @@ -206,7 +205,7 @@ function TK.rightnull!( end TK.rightnull!(t::SparseBlockTensorMap; kwargs...) = rightnull!(BlockTensorMap(t); kwargs...) -function TK.tsvd!(t::AbstractBlockTensorMap; trunc=TK.NoTruncation(), p::Real=2, alg=SDD()) +function TK.tsvd!(t::AbstractBlockTensorMap; trunc = TK.NoTruncation(), p::Real = 2, alg = SDD()) return TK._tsvd!(t, alg, trunc, p) end function TK.tsvd!(t::SparseBlockTensorMap; kwargs...) @@ -214,8 +213,8 @@ function TK.tsvd!(t::SparseBlockTensorMap; kwargs...) end function TK._tsvd!( - t::BlockTensorMap, alg::Union{SVD,SDD}, trunc::TruncationScheme, p::Real=2 -) + t::BlockTensorMap, alg::Union{SVD, SDD}, trunc::TruncationScheme, p::Real = 2 + ) # early return if isempty(blocksectors(t)) truncerr = zero(real(scalartype(t))) @@ -234,10 +233,10 @@ function TK._tsvd!( return U, Σ, V⁺, truncerr end -function TK._compute_svddata!(t::AbstractBlockTensorMap, alg::Union{SVD,SDD}) +function TK._compute_svddata!(t::AbstractBlockTensorMap, alg::Union{SVD, SDD}) InnerProductStyle(t) === EuclideanInnerProduct() || throw_invalid_innerproduct(:tsvd!) I = sectortype(t) - dims = SectorDict{I,Int}() + dims = SectorDict{I, Int}() generator = Base.Iterators.map(TK.blocks(t)) do (c, b) U, Σ, V = TK.MatrixAlgebra.svd!(b, alg) dims[c] = length(Σ) @@ -266,7 +265,7 @@ function TK._empty_svdtensors(t::AbstractBlockTensorMap) T = scalartype(t) S = spacetype(t) I = sectortype(t) - dims = SectorDict{I,Int}() + dims = SectorDict{I, Int}() W = S(dims) U = similar(t, codomain(t) ← W) diff --git a/src/linalg/linalg.jl b/src/linalg/linalg.jl index 6763af3..5915da5 100644 --- a/src/linalg/linalg.jl +++ b/src/linalg/linalg.jl @@ -57,21 +57,18 @@ end # are in the limit where multiplying the individual elements is the bottleneck. # With that in mind, we simply write the multiplication in terms of sparse tensors. function LinearAlgebra.mul!( - C::AbstractBlockTensorMap, - A::AbstractBlockTensorMap, - B::AbstractBlockTensorMap, - α::Number, - β::Number, -) + C::AbstractBlockTensorMap, A::AbstractBlockTensorMap, B::AbstractBlockTensorMap, + α::Number, β::Number, + ) compose(space(A), space(B)) == space(C) || throw(SpaceMismatch(lazy"$(space(C)) ≠ $(space(A)) * $(space(B))")) scale!(C, β) sortIA(IA) = CartesianIndex(TT.getindices(IA.I, domainind(A))) - keysA = sort!(vec(collect(nonzero_keys(A))); by=sortIA) + keysA = sort!(vec(collect(nonzero_keys(A))); by = sortIA) sortIB(IB) = CartesianIndex(TT.getindices(IB.I, codomainind(B))) - keysB = sort!(vec(collect(nonzero_keys(B))); by=sortIB) + keysB = sort!(vec(collect(nonzero_keys(B))); by = sortIB) iA = iB = 1 @inbounds while iA <= length(keysA) && iB <= length(keysB) @@ -141,14 +138,10 @@ function LinearAlgebra.mul!( end @inline function increasemulindex!( - C::AbstractBlockTensorMap, - A::AbstractTensorMap, - B::AbstractTensorMap, - α::Number, - β::Number, - I, -) - if haskey(C, I) + C::AbstractBlockTensorMap, A::AbstractTensorMap, B::AbstractTensorMap, + α::Number, β::Number, I, + ) + return if haskey(C, I) C[I] = _mul!!(C[I], A, B, α, β) else C[I] = _mul!!(nothing, A, B, α, β) @@ -158,7 +151,7 @@ end _mul!!(::Nothing, A, B, α::Number, β::Number) = scale!!(A * B, α) _mul!!(C, A, B, α::Number, β::Number) = add!!(C, A * B, α, β) const _TM_CAN_MUL = Union{ - TensorMap,AdjointTensorMap{<:Any,<:Any,<:Any,<:Any,<:TensorMap},BraidingTensor + TensorMap, AdjointTensorMap{<:Any, <:Any, <:Any, <:Any, <:TensorMap}, BraidingTensor, } function _mul!!(C::_TM_CAN_MUL, A::_TM_CAN_MUL, B::_TM_CAN_MUL, α::Number, β::Number) return mul!(C, A, B, α, β) @@ -167,12 +160,9 @@ end # ensure that mixes with AbstractBlockTensorMap and AbstractTensorMap behave as expected: for (TC, TA, TB) in Iterators.product( - Iterators.repeated((:AbstractTensorMap, :AbstractBlockTensorMap), 3)... -) - ( - :AbstractBlockTensorMap ∉ (TC, TA, TB) || - all(==(:AbstractBlockTensorMap), (TC, TA, TB)) - ) && continue + Iterators.repeated((:AbstractTensorMap, :AbstractBlockTensorMap), 3)... + ) + (:AbstractBlockTensorMap ∉ (TC, TA, TB) || all(==(:AbstractBlockTensorMap), (TC, TA, TB))) && continue @eval function LinearAlgebra.mul!(C::$TC, A::$TA, B::$TB, α::Number, β::Number) A′ = A isa AbstractBlockTensorMap ? A : convert(BlockTensorMap, A) B′ = B isa AbstractBlockTensorMap ? B : convert(BlockTensorMap, B) @@ -186,7 +176,7 @@ for (TC, TA, TB) in Iterators.product( end end -function LinearAlgebra.norm(tA::BlockTensorMap, p::Real=2) +function LinearAlgebra.norm(tA::BlockTensorMap, p::Real = 2) vals = nonzero_values(tA) isempty(vals) && return norm(zero(scalartype(tA)), p) return LinearAlgebra.norm(norm.(vals), p) diff --git a/src/tensors/abstractblocktensor/abstractarray.jl b/src/tensors/abstractblocktensor/abstractarray.jl index 69dba07..20fab18 100644 --- a/src/tensors/abstractblocktensor/abstractarray.jl +++ b/src/tensors/abstractblocktensor/abstractarray.jl @@ -53,7 +53,7 @@ function checkspaces(t::AbstractBlockTensorMap, v::AbstractTensorMap, I...) end function checkspaces(t::AbstractBlockTensorMap, v::AbstractBlockTensorMap, I...) V_slice = eachspace(t)[I...] - if V_slice isa SumSpaceIndices + return if V_slice isa SumSpaceIndices space(v) == space(V_slice) || throw( SpaceMismatch( "inserting a tensor of space $(space(v)) at index $I into a tensor of space $(space(V_slice))", @@ -80,21 +80,21 @@ function checkspaces(t::AbstractBlockTensorMap) end # scalar indexing is dispatched through: -@inline Base.getindex(t::AbstractBlockTensorMap, I::Vararg{Int,N}) where {N} = +@inline Base.getindex(t::AbstractBlockTensorMap, I::Vararg{Int, N}) where {N} = getindex(parent(t), I...) @inline Base.getindex(t::AbstractBlockTensorMap, I::CartesianIndex{N}) where {N} = getindex(parent(t), I) -@inline getindex!(t::AbstractBlockTensorMap, I::Vararg{Int,N}) where {N} = +@inline getindex!(t::AbstractBlockTensorMap, I::Vararg{Int, N}) where {N} = getindex!(parent(t), I...) @inline getindex!(t::AbstractBlockTensorMap, I::CartesianIndex{N}) where {N} = getindex!(parent(t), I) # slicing getindex needs to correctly allocate output blocktensor: -const SliceIndex = Union{Strided.SliceIndex,AbstractVector{<:Union{Integer,Bool}}} +const SliceIndex = Union{Strided.SliceIndex, AbstractVector{<:Union{Integer, Bool}}} Base.@propagate_inbounds function Base.getindex( - t::AbstractBlockTensorMap, indices::Vararg{SliceIndex} -) + t::AbstractBlockTensorMap, indices::Vararg{SliceIndex} + ) V = space(eachspace(t)[indices...]) tdst = similar(t, V) length(tdst) == 0 && return tdst @@ -116,8 +116,8 @@ end # disambiguate: Base.@propagate_inbounds function Base.getindex( - t::AbstractBlockTensorMap, indices::Vararg{Strided.SliceIndex} -) + t::AbstractBlockTensorMap, indices::Vararg{Strided.SliceIndex} + ) V = space(eachspace(t)[indices...]) tdst = similar(t, V) length(tdst) == 0 && return tdst @@ -144,8 +144,8 @@ end # setindex verifies structure is correct @inline function Base.setindex!( - t::AbstractBlockTensorMap, v::AbstractTensorMap, indices::Vararg{SliceIndex} -) + t::AbstractBlockTensorMap, v::AbstractTensorMap, indices::Vararg{SliceIndex} + ) @boundscheck begin checkbounds(t, indices...) checkspaces(t, v, indices...) @@ -155,8 +155,8 @@ end end # setindex with blocktensor needs to correctly slice-assign @inline function Base.setindex!( - t::AbstractBlockTensorMap, v::AbstractBlockTensorMap, indices::Vararg{SliceIndex} -) + t::AbstractBlockTensorMap, v::AbstractBlockTensorMap, indices::Vararg{SliceIndex} + ) @boundscheck begin checkbounds(t, indices...) checkspaces(t, v, indices...) @@ -168,8 +168,8 @@ end # disambiguate @inline function Base.setindex!( - t::AbstractBlockTensorMap, v::AbstractTensorMap, indices::Vararg{Strided.SliceIndex} -) + t::AbstractBlockTensorMap, v::AbstractTensorMap, indices::Vararg{Strided.SliceIndex} + ) @boundscheck begin checkbounds(t, indices...) checkspaces(t, v, indices...) @@ -179,10 +179,8 @@ end end # disambiguate @inline function Base.setindex!( - t::AbstractBlockTensorMap, - v::AbstractBlockTensorMap, - indices::Vararg{Strided.SliceIndex}, -) + t::AbstractBlockTensorMap, v::AbstractBlockTensorMap, indices::Vararg{Strided.SliceIndex}, + ) @boundscheck begin checkbounds(t, indices...) checkspaces(t, v, indices...) @@ -213,11 +211,9 @@ function Base.copy!(tdst::AbstractBlockTensorMap, tsrc::AbstractBlockTensorMap) return tdst end function Base.copyto!( - tdst::AbstractBlockTensorMap, - Rdest::CartesianIndices, - tsrc::AbstractBlockTensorMap, - Rsrc::CartesianIndices, -) + tdst::AbstractBlockTensorMap, Rdest::CartesianIndices, + tsrc::AbstractBlockTensorMap, Rsrc::CartesianIndices, + ) copyto!(parent(tdst), Rdest, parent(tsrc), Rsrc) return tdst end @@ -243,54 +239,54 @@ Base.similar(t::AbstractBlockTensorMap, P::TensorMapSumSpace) = similar(t, eltyp # make sure tensormap specializations are not used for sumspaces: function Base.similar( - t::AbstractTensorMap, ::Type{TorA}, P::TensorMapSumSpace{S} -) where {S,TorA} + t::AbstractTensorMap, ::Type{TorA}, P::TensorMapSumSpace{S} + ) where {S, TorA} TT = similar_tensormaptype(t, TorA, P) return issparse(t) ? SparseBlockTensorMap{TT}(undef, P) : BlockTensorMap{TT}(undef, P) end function similar_tensormaptype( - ::AbstractTensorMap, T::Type{<:AbstractTensorMap}, P::TensorMapSumSpace{S} -) where {S} + ::AbstractTensorMap, T::Type{<:AbstractTensorMap}, P::TensorMapSumSpace{S} + ) where {S} if isconcretetype(T) return tensormaptype(S, numout(P), numin(P), storagetype(T)) else - return AbstractTensorMap{scalartype(T),S,numout(P),numin(P)} + return AbstractTensorMap{scalartype(T), S, numout(P), numin(P)} end end function similar_tensormaptype( - t::AbstractBlockTensorMap, T::Type{<:AbstractTensorMap}, P::TensorMapSumSpace{S} -) where {S} + t::AbstractBlockTensorMap, T::Type{<:AbstractTensorMap}, P::TensorMapSumSpace{S} + ) where {S} if eltype(t) === T && typeof(space(t)) === typeof(P) return T elseif isconcretetype(T) return tensormaptype(S, numout(P), numin(P), storagetype(T)) else - return AbstractTensorMap{scalartype(T),S,numout(P),numin(P)} + return AbstractTensorMap{scalartype(T), S, numout(P), numin(P)} end end function similar_tensormaptype( - t::AbstractBlockTensorMap, M::Type{<:AbstractVector}, P::TensorMapSumSpace{S} -) where {S} + t::AbstractBlockTensorMap, M::Type{<:AbstractVector}, P::TensorMapSumSpace{S} + ) where {S} if isconcretetype(eltype(t)) return tensormaptype(S, numout(P), numin(P), M) else - return AbstractTensorMap{scalartype(M),S,numout(P),numin(P)} + return AbstractTensorMap{scalartype(M), S, numout(P), numin(P)} end end function similar_tensormaptype( - t::AbstractBlockTensorMap, T::Type{<:Number}, P::TensorMapSumSpace{S} -) where {S} + t::AbstractBlockTensorMap, T::Type{<:Number}, P::TensorMapSumSpace{S} + ) where {S} if isconcretetype(eltype(t)) M = TensorKit.similarstoragetype(t, T) return tensormaptype(S, numout(P), numin(P), M) else - return AbstractTensorMap{T,S,numout(P),numin(P)} + return AbstractTensorMap{T, S, numout(P), numin(P)} end end # implementation in type domain -function Base.similar(::Type{T}, P::TensorMapSumSpace) where {T<:AbstractBlockTensorMap} +function Base.similar(::Type{T}, P::TensorMapSumSpace) where {T <: AbstractBlockTensorMap} return T(undef, P) end @@ -299,8 +295,8 @@ end Base.eltypeof(t::AbstractBlockTensorMap) = eltype(t) @inline function Base._cat_t( - dims, ::Type{T}, ts::AbstractBlockTensorMap... -) where {T<:AbstractTensorMap} + dims, ::Type{T}, ts::AbstractBlockTensorMap... + ) where {T <: AbstractTensorMap} catdims = Base.dims2cat(dims) V = space(Base._cat(dims, eachspace.(ts)...)) A = similar(ts[1], T, V) diff --git a/src/tensors/abstractblocktensor/abstractblocktensor.jl b/src/tensors/abstractblocktensor/abstractblocktensor.jl index fff7e76..1e2ac63 100644 --- a/src/tensors/abstractblocktensor/abstractblocktensor.jl +++ b/src/tensors/abstractblocktensor/abstractblocktensor.jl @@ -5,7 +5,7 @@ Abstract supertype for tensor maps that have additional block structure, i.e. th that have a direct sum structure. These behave like `AbstractTensorMap` but have additional methods to facilitate indexing and manipulation of the block structure. """ -abstract type AbstractBlockTensorMap{E,S,N₁,N₂} <: AbstractTensorMap{E,S,N₁,N₂} end +abstract type AbstractBlockTensorMap{E, S, N₁, N₂} <: AbstractTensorMap{E, S, N₁, N₂} end include("abstractarray.jl") include("abstracttensormap.jl") diff --git a/src/tensors/abstractblocktensor/abstracttensormap.jl b/src/tensors/abstractblocktensor/abstracttensormap.jl index 4f94959..bac400b 100644 --- a/src/tensors/abstractblocktensor/abstracttensormap.jl +++ b/src/tensors/abstractblocktensor/abstracttensormap.jl @@ -1,11 +1,10 @@ - # AbstractTensorMap Interface # --------------------------- # TODO: do we really want this: # note: this goes along with the specializations of Base.similar above... function TensorKit.tensormaptype( - ::Type{SumSpace{S}}, N₁::Int, N₂::Int, TorA::Type -) where {S} + ::Type{SumSpace{S}}, N₁::Int, N₂::Int, TorA::Type + ) where {S} return blocktensormaptype(S, N₁, N₂, TorA) end @@ -17,8 +16,8 @@ eachspace(t::AbstractBlockTensorMap) = SumSpaceIndices(space(t)) return mortar(map(x -> x[nothing, nothing], parent(t))) end @inline function Base.getindex( - t::AbstractBlockTensorMap{E,S,N₁,N₂}, f₁::FusionTree{I,N₁}, f₂::FusionTree{I,N₂} -) where {E,S,I,N₁,N₂} + t::AbstractBlockTensorMap{E, S, N₁, N₂}, f₁::FusionTree{I, N₁}, f₂::FusionTree{I, N₂} + ) where {E, S, I, N₁, N₂} sectortype(S) === I || throw(SectorMismatch()) subblocks = map(eachspace(t), parent(t)) do V, x sz = (dims(codomain(V), f₁.uncoupled)..., dims(domain(V), f₂.uncoupled)...) @@ -32,16 +31,16 @@ end return mortar(subblocks) end @inline function Base.setindex!( - t::AbstractBlockTensorMap, v::AbstractBlockArray, f₁::FusionTree, f₂::FusionTree -) + t::AbstractBlockTensorMap, v::AbstractBlockArray, f₁::FusionTree, f₂::FusionTree + ) for I in eachindex(t) getindex!(t, I)[f₁, f₂] = v[Block(I.I)] end return t end @inline function Base.setindex!( - t::AbstractBlockTensorMap, v::AbstractArray, f₁::FusionTree, f₂::FusionTree -) + t::AbstractBlockTensorMap, v::AbstractArray, f₁::FusionTree, f₂::FusionTree + ) spaces = (codomain(t)..., domain(t)...) uncoupleds = (f₁.uncoupled..., f₂.uncoupled...) bsz = map(spaces, uncoupleds) do V, uncoupled @@ -67,7 +66,7 @@ TensorKit.blocks(t::AbstractBlockTensorMap) = ((c => block(t, c)) for c in block TensorKit.blocksectors(t::AbstractBlockTensorMap) = blocksectors(space(t)) TensorKit.hasblock(t::AbstractBlockTensorMap, c::Sector) = c in blocksectors(t) -function TensorKit.storagetype(::Type{TT}) where {TT<:AbstractBlockTensorMap} +function TensorKit.storagetype(::Type{TT}) where {TT <: AbstractBlockTensorMap} return if isconcretetype(eltype(TT)) storagetype(eltype(TT)) else diff --git a/src/tensors/abstractblocktensor/conversion.jl b/src/tensors/abstractblocktensor/conversion.jl index 7a14990..bbc8e8a 100644 --- a/src/tensors/abstractblocktensor/conversion.jl +++ b/src/tensors/abstractblocktensor/conversion.jl @@ -1,8 +1,8 @@ # Conversion # ---------- -function Base.convert(::Type{T}, t::AbstractBlockTensorMap) where {T<:TensorMap} - cod = ProductSpace{spacetype(t),numout(t)}(oplus.(codomain(t).spaces)) - dom = ProductSpace{spacetype(t),numin(t)}(oplus.(domain(t).spaces)) +function Base.convert(::Type{T}, t::AbstractBlockTensorMap) where {T <: TensorMap} + cod = ProductSpace{spacetype(t), numout(t)}(oplus.(codomain(t).spaces)) + dom = ProductSpace{spacetype(t), numin(t)}(oplus.(domain(t).spaces)) tdst = similar(t, cod ← dom) for (f₁, f₂) in fusiontrees(tdst) @@ -13,8 +13,8 @@ function Base.convert(::Type{T}, t::AbstractBlockTensorMap) where {T<:TensorMap} end # disambiguate function Base.convert(::Type{TensorMap}, t::AbstractBlockTensorMap) - cod = ProductSpace{spacetype(t),numout(t)}(oplus.(codomain(t).spaces)) - dom = ProductSpace{spacetype(t),numin(t)}(oplus.(domain(t).spaces)) + cod = ProductSpace{spacetype(t), numout(t)}(oplus.(codomain(t).spaces)) + dom = ProductSpace{spacetype(t), numin(t)}(oplus.(domain(t).spaces)) tdst = similar(t, cod ← dom) for (f₁, f₂) in fusiontrees(tdst) @@ -24,7 +24,7 @@ function Base.convert(::Type{TensorMap}, t::AbstractBlockTensorMap) return tdst end -function Base.convert(::Type{TT}, t::AbstractTensorMap) where {TT<:AbstractBlockTensorMap} +function Base.convert(::Type{TT}, t::AbstractTensorMap) where {TT <: AbstractBlockTensorMap} t isa TT && return t if t isa AbstractBlockTensorMap tdst = similar(TT, space(t)) @@ -35,8 +35,8 @@ function Base.convert(::Type{TT}, t::AbstractTensorMap) where {TT<:AbstractBlock S = spacetype(t) tdst = TT( undef, - convert(ProductSumSpace{S,numout(t)}, codomain(t)), - convert(ProductSumSpace{S,numin(t)}, domain(t)), + convert(ProductSumSpace{S, numout(t)}, codomain(t)), + convert(ProductSumSpace{S, numin(t)}, domain(t)), ) tdst[1] = t end diff --git a/src/tensors/abstractblocktensor/show.jl b/src/tensors/abstractblocktensor/show.jl index b02ff18..919547f 100644 --- a/src/tensors/abstractblocktensor/show.jl +++ b/src/tensors/abstractblocktensor/show.jl @@ -41,7 +41,7 @@ function show_elements(io::IO, x::AbstractBlockTensorMap) return ndigits(maximum(getindex.(nzind, i))) end io = IOContext(io, :compact => compact) - nz_pairs = sort(vec(collect(nonzero_pairs(x))); by=first) + nz_pairs = sort(vec(collect(nonzero_pairs(x))); by = first) for (k, (ind, val)) in enumerate(nz_pairs) if k < half_screen_rows || k > length(nzind) - half_screen_rows println(io, " ", '[', Base.join(lpad.(Tuple(ind), pads), ","), "] = ", val) @@ -49,6 +49,7 @@ function show_elements(io::IO, x::AbstractBlockTensorMap) println(io, " ", Base.join(" " .^ pads, " "), " \u22ee") end end + return nothing end # adapted from SparseArrays.jl diff --git a/src/tensors/abstractblocktensor/sparsity.jl b/src/tensors/abstractblocktensor/sparsity.jl index 2d5ca83..6c059c7 100644 --- a/src/tensors/abstractblocktensor/sparsity.jl +++ b/src/tensors/abstractblocktensor/sparsity.jl @@ -36,7 +36,7 @@ end Remove the tensor entries of a blocktensor that have norm `≤(tol)`. """ -function droptol!(t::AbstractBlockTensorMap, tol=eps(real(scalartype(t)))^(3 / 4)) +function droptol!(t::AbstractBlockTensorMap, tol = eps(real(scalartype(t)))^(3 / 4)) for (k, v) in nonzero_pairs(t) norm(v) ≤ tol && delete!(t, k) end diff --git a/src/tensors/adjointblocktensor.jl b/src/tensors/adjointblocktensor.jl index 40925df..7e17dec 100644 --- a/src/tensors/adjointblocktensor.jl +++ b/src/tensors/adjointblocktensor.jl @@ -1,6 +1,5 @@ -const AdjointBlockTensorMap{T,S,N₁,N₂,TT<:AbstractBlockTensorMap} = AdjointTensorMap{ - T,S,N₁,N₂,TT -} +const AdjointBlockTensorMap{T, S, N₁, N₂, TT <: AbstractBlockTensorMap} = + AdjointTensorMap{T, S, N₁, N₂, TT} function permute_adjointindices(t::AbstractTensorMap, I::CartesianIndex) return CartesianIndex( @@ -30,10 +29,10 @@ end # help out inference function Base.promote_op( - ::typeof(Base.adjoint), ::Type{AbstractTensorMap{T,S,N₁,N₂}} -) where {T,S,N₁,N₂} + ::typeof(Base.adjoint), ::Type{AbstractTensorMap{T, S, N₁, N₂}} + ) where {T, S, N₁, N₂} AT = Base.promote_op(adjoint, T) - return AbstractTensorMap{AT,S,N₂,N₁} + return AbstractTensorMap{AT, S, N₂, N₁} end function nonzero_pairs(t::AdjointBlockTensorMap) diff --git a/src/tensors/blocktensor.jl b/src/tensors/blocktensor.jl index 13f4ed5..9a0d374 100644 --- a/src/tensors/blocktensor.jl +++ b/src/tensors/blocktensor.jl @@ -3,65 +3,65 @@ Dense `BlockTensorMap` type that stores tensors of type `TT` in a dense array. """ -struct BlockTensorMap{TT<:AbstractTensorMap,E,S,N₁,N₂,N} <: - AbstractBlockTensorMap{E,S,N₁,N₂} - data::Array{TT,N} - space::TensorMapSumSpace{S,N₁,N₂} +struct BlockTensorMap{TT <: AbstractTensorMap, E, S, N₁, N₂, N} <: + AbstractBlockTensorMap{E, S, N₁, N₂} + data::Array{TT, N} + space::TensorMapSumSpace{S, N₁, N₂} # uninitialized constructor - function BlockTensorMap{TT,E,S,N₁,N₂,N}( - ::UndefBlocksInitializer, space::TensorMapSumSpace{S,N₁,N₂} - ) where {E,S,N₁,N₂,N,TT<:AbstractTensorMap{E,S,N₁,N₂}} + function BlockTensorMap{TT, E, S, N₁, N₂, N}( + ::UndefBlocksInitializer, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, N, TT <: AbstractTensorMap{E, S, N₁, N₂}} @assert N₁ + N₂ == N "BlockTensorMap: data has wrong number of dimensions" - data = Array{TT,N}(undef, size(SumSpaceIndices(space))) - return new{TT,E,S,N₁,N₂,N}(data, space) + data = Array{TT, N}(undef, size(SumSpaceIndices(space))) + return new{TT, E, S, N₁, N₂, N}(data, space) end # constructor from data - function BlockTensorMap{TT,E,S,N₁,N₂,N}( - data::Array{TT,N}, space::TensorMapSumSpace{S,N₁,N₂} - ) where {E,S,N₁,N₂,N,TT<:AbstractTensorMap{E,S,N₁,N₂}} + function BlockTensorMap{TT, E, S, N₁, N₂, N}( + data::Array{TT, N}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, N, TT <: AbstractTensorMap{E, S, N₁, N₂}} @assert N₁ + N₂ == N "BlockTensorMap: data has wrong number of dimensions" - return new{TT,E,S,N₁,N₂,N}(data, space) + return new{TT, E, S, N₁, N₂, N}(data, space) end end -function BlockTensorMap{TT,E,S,N₁,N₂,N}( - ::UndefInitializer, space::TensorMapSumSpace{S,N₁,N₂} -) where {TT,E,S,N₁,N₂,N} - tdst = BlockTensorMap{TT,E,S,N₁,N₂,N}(undef_blocks, space) +function BlockTensorMap{TT, E, S, N₁, N₂, N}( + ::UndefInitializer, space::TensorMapSumSpace{S, N₁, N₂} + ) where {TT, E, S, N₁, N₂, N} + tdst = BlockTensorMap{TT, E, S, N₁, N₂, N}(undef_blocks, space) tdst.data .= similar.(TT, SumSpaceIndices(space)) return tdst end -function BlockTensorMap{TT,E,S,N₁,N₂,N}( - ::UndefInitializer, space::TensorMapSumSpace{S,N₁,N₂} -) where {TT′,TT<:AdjointTensorMap{<:Any,<:Any,<:Any,<:Any,TT′},E,S,N₁,N₂,N} - tdst = BlockTensorMap{TT,E,S,N₁,N₂,N}(undef_blocks, space) +function BlockTensorMap{TT, E, S, N₁, N₂, N}( + ::UndefInitializer, space::TensorMapSumSpace{S, N₁, N₂} + ) where {TT′, TT <: AdjointTensorMap{<:Any, <:Any, <:Any, <:Any, TT′}, E, S, N₁, N₂, N} + tdst = BlockTensorMap{TT, E, S, N₁, N₂, N}(undef_blocks, space) tdst.data .= adjoint.(similar.(TT′, adjoint.(SumSpaceIndices(space)))) return tdst end # uninitialized constructor function BlockTensorMap{TT}( - u::Union{UndefBlocksInitializer,UndefInitializer}, space::TensorMapSumSpace{S,N₁,N₂} -) where {E,S,N₁,N₂,TT<:AbstractTensorMap{E,S,N₁,N₂}} + u::Union{UndefBlocksInitializer, UndefInitializer}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, TT <: AbstractTensorMap{E, S, N₁, N₂}} N = N₁ + N₂ - return BlockTensorMap{TT,E,S,N₁,N₂,N}(u, space) + return BlockTensorMap{TT, E, S, N₁, N₂, N}(u, space) end # constructor from data function BlockTensorMap{TT}( - data::Array{TT,N}, space::TensorMapSumSpace{S,N₁,N₂} -) where {E,S,N₁,N₂,N,TT<:AbstractTensorMap{E,S,N₁,N₂}} + data::Array{TT, N}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, N, TT <: AbstractTensorMap{E, S, N₁, N₂}} @assert N₁ + N₂ == N "BlockTensorMap: data has wrong number of dimensions" - return BlockTensorMap{TT,E,S,N₁,N₂,N}(data, space) + return BlockTensorMap{TT, E, S, N₁, N₂, N}(data, space) end -function blocktensormaptype(::Type{S}, N₁::Int, N₂::Int, ::Type{T}) where {S,T} +function blocktensormaptype(::Type{S}, N₁::Int, N₂::Int, ::Type{T}) where {S, T} TT = tensormaptype(S, N₁, N₂, T) return BlockTensorMap{TT} end -function blocktensormaptype(::Type{SumSpace{S}}, N₁::Int, N₂::Int, ::Type{T}) where {S,T} +function blocktensormaptype(::Type{SumSpace{S}}, N₁::Int, N₂::Int, ::Type{T}) where {S, T} TT = tensormaptype(S, N₁, N₂, T) return BlockTensorMap{TT} end @@ -69,35 +69,33 @@ end # Constructors # ------------ function BlockTensorMap{TT}( - data::Union{Array{TT},UndefInitializer,UndefBlocksInitializer}, - codom::ProductSumSpace{S,N₁}, - dom::ProductSumSpace{S,N₂}, -) where {TT,S,N₁,N₂} + data::Union{Array{TT}, UndefInitializer, UndefBlocksInitializer}, + codom::ProductSumSpace{S, N₁}, dom::ProductSumSpace{S, N₂}, + ) where {TT, S, N₁, N₂} return BlockTensorMap{TT}(data, codom ← dom) end function BlockTensorMap( - f::Union{UndefInitializer,UndefBlocksInitializer}, space::TensorMapSumSpace{S,N₁,N₂} -) where {S,N₁,N₂} + f::Union{UndefInitializer, UndefBlocksInitializer}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {S, N₁, N₂} TT = tensormaptype(S, N₁, N₂, Float64) return BlockTensorMap{TT}(f, space) end function BlockTensorMap( - f::Union{UndefInitializer,UndefBlocksInitializer}, - codom::ProductSumSpace, - dom::ProductSumSpace, -) + f::Union{UndefInitializer, UndefBlocksInitializer}, + codom::ProductSumSpace, dom::ProductSumSpace, + ) return BlockTensorMap(f, codom ← dom) end function BlockTensorMap( - data::Array{TT}, space::TensorMapSumSpace{S,N₁,N₂} -) where {S,N₁,N₂,TT<:AbstractTensorMap{<:Any,S,N₁,N₂}} + data::Array{TT}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {S, N₁, N₂, TT <: AbstractTensorMap{<:Any, S, N₁, N₂}} return BlockTensorMap{TT}(data, space) end function BlockTensorMap( - data::Array{<:AbstractTensorMap}, codom::ProductSumSpace, dom::ProductSumSpace -) + data::Array{<:AbstractTensorMap}, codom::ProductSumSpace, dom::ProductSumSpace + ) return BlockTensorMap(data, codom ← dom) end @@ -138,8 +136,8 @@ for randfun in (:rand, :randn, :randexp) randfun! = Symbol(randfun, :!) @eval begin function Random.$randfun( - rng::Random.AbstractRNG, ::Type{T}, V::TensorMapSumSpace - ) where {T} + rng::Random.AbstractRNG, ::Type{T}, V::TensorMapSumSpace + ) where {T} TT = blocktensormaptype(spacetype(V), numout(V), numin(V), T) t = TT(undef, V) Random.$randfun!(rng, t) @@ -159,11 +157,9 @@ Base.eltype(::Type{<:BlockTensorMap{TT}}) where {TT} = TT Base.parent(t::BlockTensorMap) = t.data function Base.copyto!( - dest::BlockTensorMap, - Rdest::CartesianIndices, - src::BlockTensorMap, - Rsrc::CartesianIndices, -) + dest::BlockTensorMap, Rdest::CartesianIndices, + src::BlockTensorMap, Rsrc::CartesianIndices, + ) copyto!(parent(dest), Rdest, parent(src), Rsrc) return dest end @@ -196,8 +192,8 @@ end # ---------- function Base.promote_rule( - ::Type{<:BlockTensorMap{TT₁}}, ::Type{<:BlockTensorMap{TT₂}} -) where {TT₁,TT₂} + ::Type{<:BlockTensorMap{TT₁}}, ::Type{<:BlockTensorMap{TT₂}} + ) where {TT₁, TT₂} TT = promote_type(TT₁, TT₂) return BlockTensorMap{TT} end @@ -207,8 +203,8 @@ function Base.convert(::Type{BlockTensorMap}, t::AbstractTensorMap) data = fill(t, ntuple(Returns(1), numind(t))) tdst = BlockTensorMap( data, - convert(ProductSumSpace{S,numout(t)}, codomain(t)), - convert(ProductSumSpace{S,numin(t)}, domain(t)), + convert(ProductSumSpace{S, numout(t)}, codomain(t)), + convert(ProductSumSpace{S, numin(t)}, domain(t)), ) return tdst end diff --git a/src/tensors/indexmanipulations.jl b/src/tensors/indexmanipulations.jl index fa18a4d..a82ef04 100644 --- a/src/tensors/indexmanipulations.jl +++ b/src/tensors/indexmanipulations.jl @@ -1,12 +1,9 @@ function TK.add_transform!( - tdst::BlockTensorMap, - tsrc::BlockTensorMap, - (p₁, p₂)::Index2Tuple{N₁,N₂}, - fusiontreetransform, - α::Number, - β::Number, - backend::AbstractBackend..., -) where {N₁,N₂} + tdst::BlockTensorMap, tsrc::BlockTensorMap, (p₁, p₂)::Index2Tuple{N₁, N₂}, + fusiontreetransform, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {N₁, N₂} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -23,14 +20,12 @@ function TK.add_transform!( return tdst end function TK.add_transform!( - tdst::AbstractBlockTensorMap, - tsrc::AbstractBlockTensorMap, - (p₁, p₂)::Index2Tuple{N₁,N₂}, - fusiontreetransform, - α::Number, - β::Number, - backend::AbstractBackend..., -) where {N₁,N₂} + tdst::AbstractBlockTensorMap, tsrc::AbstractBlockTensorMap, + (p₁, p₂)::Index2Tuple{N₁, N₂}, + fusiontreetransform, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {N₁, N₂} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -47,14 +42,12 @@ function TK.add_transform!( return tdst end function TK.add_transform!( - tdst::AbstractBlockTensorMap, - tsrc::AdjointTensorMap{T,S,N₁,N₂,TT}, - (p₁, p₂)::Index2Tuple, - fusiontreetransform, - α::Number, - β::Number, - backend::AbstractBackend..., -) where {T,S,N₁,N₂,TT<:AbstractBlockTensorMap} + tdst::AbstractBlockTensorMap, tsrc::AdjointTensorMap{T, S, N₁, N₂, TT}, + (p₁, p₂)::Index2Tuple, + fusiontreetransform, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {T, S, N₁, N₂, TT <: AbstractBlockTensorMap} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -71,28 +64,23 @@ function TK.add_transform!( return tdst end function TK.add_transform!( - tdst::TensorMap, - tsrc::BlockTensorMap, - (p₁, p₂)::Index2Tuple, - fusiontreetransform, - α::Number, - β::Number, - backend::AbstractBackend..., -) + tdst::TensorMap, tsrc::BlockTensorMap, (p₁, p₂)::Index2Tuple, + fusiontreetransform, + α::Number, β::Number, + backend::AbstractBackend..., + ) @assert length(tsrc) == 1 "source tensor must be a single tensor" return TK.add_transform!( tdst, only(tsrc), (p₁, p₂), fusiontreetransform, α, β, backend... ) end function TK.add_transform!( - tdst::BlockTensorMap, - tsrc::TensorMap, - (p₁, p₂)::Index2Tuple, - fusiontreetransform, - α::Number, - β::Number, - backend::AbstractBackend..., -) + tdst::BlockTensorMap, tsrc::TensorMap, + (p₁, p₂)::Index2Tuple, + fusiontreetransform, + α::Number, β::Number, + backend::AbstractBackend..., + ) # @assert length(tsrc) == 1 "source tensor must be a single tensor" return TK.add_transform!( only(tdst), tsrc, (p₁, p₂), fusiontreetransform, α, β, backend... @@ -102,13 +90,11 @@ end # we need to capture the other functions earlier to enjoy the fast transformers... for f! in (:add_permute!, :add_transpose!) @eval function TK.$f!( - tdst::BlockTensorMap, - tsrc::BlockTensorMap, - (p₁, p₂)::Index2Tuple{N₁,N₂}, - α::Number, - β::Number, - backend::AbstractBackend..., - ) where {N₁,N₂} + tdst::BlockTensorMap, tsrc::BlockTensorMap, + (p₁, p₂)::Index2Tuple{N₁, N₂}, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {N₁, N₂} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -123,13 +109,11 @@ for f! in (:add_permute!, :add_transpose!) return tdst end @eval function TK.$f!( - tdst::AbstractBlockTensorMap, - tsrc::AbstractBlockTensorMap, - (p₁, p₂)::Index2Tuple{N₁,N₂}, - α::Number, - β::Number, - backend::AbstractBackend..., - ) where {N₁,N₂} + tdst::AbstractBlockTensorMap, tsrc::AbstractBlockTensorMap, + (p₁, p₂)::Index2Tuple{N₁, N₂}, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {N₁, N₂} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -144,13 +128,11 @@ for f! in (:add_permute!, :add_transpose!) return tdst end @eval function TK.$f!( - tdst::AbstractBlockTensorMap, - tsrc::AdjointTensorMap{T,S,N₁,N₂,TT}, - (p₁, p₂)::Index2Tuple, - α::Number, - β::Number, - backend::AbstractBackend..., - ) where {T,S,N₁,N₂,TT<:AbstractBlockTensorMap} + tdst::AbstractBlockTensorMap, tsrc::AdjointTensorMap{T, S, N₁, N₂, TT}, + (p₁, p₂)::Index2Tuple, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {T, S, N₁, N₂, TT <: AbstractBlockTensorMap} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -165,27 +147,23 @@ for f! in (:add_permute!, :add_transpose!) return tdst end @eval function TK.$f!( - tdst::TensorMap, - tsrc::BlockTensorMap, - (p₁, p₂)::Index2Tuple, - α::Number, - β::Number, - backend::AbstractBackend..., - ) + tdst::TensorMap, tsrc::BlockTensorMap, + (p₁, p₂)::Index2Tuple, + α::Number, β::Number, + backend::AbstractBackend..., + ) @assert length(tsrc) == 1 "source tensor must be a single tensor" return TK.$f!(tdst, only(tsrc), (p₁, p₂), α, β, backend...) end end function TK.add_braid!( - tdst::BlockTensorMap, - tsrc::BlockTensorMap, - (p₁, p₂)::Index2Tuple{N₁,N₂}, - levels::IndexTuple, - α::Number, - β::Number, - backend::AbstractBackend..., -) where {N₁,N₂} + tdst::BlockTensorMap, tsrc::BlockTensorMap, + (p₁, p₂)::Index2Tuple{N₁, N₂}, + levels::IndexTuple, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {N₁, N₂} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -202,14 +180,12 @@ function TK.add_braid!( return tdst end function TK.add_braid!( - tdst::AbstractBlockTensorMap, - tsrc::AbstractBlockTensorMap, - (p₁, p₂)::Index2Tuple{N₁,N₂}, - levels::IndexTuple, - α::Number, - β::Number, - backend::AbstractBackend..., -) where {N₁,N₂} + tdst::AbstractBlockTensorMap, tsrc::AbstractBlockTensorMap, + (p₁, p₂)::Index2Tuple{N₁, N₂}, + levels::IndexTuple, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {N₁, N₂} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -224,14 +200,12 @@ function TK.add_braid!( return tdst end function TK.add_braid!( - tdst::AbstractBlockTensorMap, - tsrc::AdjointTensorMap{T,S,N₁,N₂,TT}, - (p₁, p₂)::Index2Tuple, - levels::IndexTuple, - α::Number, - β::Number, - backend::AbstractBackend..., -) where {T,S,N₁,N₂,TT<:AbstractBlockTensorMap} + tdst::AbstractBlockTensorMap, tsrc::AdjointTensorMap{T, S, N₁, N₂, TT}, + (p₁, p₂)::Index2Tuple, + levels::IndexTuple, + α::Number, β::Number, + backend::AbstractBackend..., + ) where {T, S, N₁, N₂, TT <: AbstractBlockTensorMap} @boundscheck begin permute(space(tsrc), (p₁, p₂)) == space(tdst) || throw(SpaceMismatch("source = $(codomain(tsrc))←$(domain(tsrc)), @@ -246,21 +220,19 @@ function TK.add_braid!( return tdst end function TK.add_braid!( - tdst::TensorMap, - tsrc::BlockTensorMap, - (p₁, p₂)::Index2Tuple, - levels::IndexTuple, - α::Number, - β::Number, - backend::AbstractBackend..., -) + tdst::TensorMap, tsrc::BlockTensorMap, + (p₁, p₂)::Index2Tuple, + levels::IndexTuple, + α::Number, β::Number, + backend::AbstractBackend..., + ) @assert length(tsrc) == 1 "source tensor must be a single tensor" return TK.add_braid!(tdst, only(tsrc), (p₁, p₂), levels, α, β, backend...) end Base.@constprop :aggressive function TK.insertleftunit( - t::AbstractBlockTensorMap, i::Int=numind(t) + 1; kwargs... -) + t::AbstractBlockTensorMap, i::Int = numind(t) + 1; kwargs... + ) W = TK.insertleftunit(space(t), i; kwargs...) tdst = similar(t, W) for (I, v) in nonzero_pairs(t) @@ -271,8 +243,8 @@ Base.@constprop :aggressive function TK.insertleftunit( end Base.@constprop :aggressive function TK.insertrightunit( - t::AbstractBlockTensorMap, i::Int=numind(t) + 1; kwargs... -) + t::AbstractBlockTensorMap, i::Int = numind(t) + 1; kwargs... + ) W = TK.insertrightunit(space(t), i; kwargs...) tdst = similar(t, W) for (I, v) in nonzero_pairs(t) @@ -283,8 +255,8 @@ Base.@constprop :aggressive function TK.insertrightunit( end Base.@constprop :aggressive function TK.removeunit( - t::AbstractBlockTensorMap, i::Int; kwargs... -) + t::AbstractBlockTensorMap, i::Int; kwargs... + ) W = TK.removeunit(space(t), i) tdst = similar(t, W) for (I, v) in nonzero_pairs(t) @@ -294,7 +266,7 @@ Base.@constprop :aggressive function TK.removeunit( return tdst end -function TK.twist!(t::AbstractBlockTensorMap, is; inv::Bool=false) +function TK.twist!(t::AbstractBlockTensorMap, is; inv::Bool = false) foreach(x -> twist!(x, is; inv), nonzero_values(t)) return t end diff --git a/src/tensors/sparseblocktensor.jl b/src/tensors/sparseblocktensor.jl index 50629e9..a8b7682 100644 --- a/src/tensors/sparseblocktensor.jl +++ b/src/tensors/sparseblocktensor.jl @@ -3,57 +3,57 @@ Sparse `SparseBlockTensorMap` type that stores tensors of type `TT` in a sparse dictionary. """ -struct SparseBlockTensorMap{TT<:AbstractTensorMap,E,S,N₁,N₂,N} <: - AbstractBlockTensorMap{E,S,N₁,N₂} - data::Dict{CartesianIndex{N},TT} - space::TensorMapSumSpace{S,N₁,N₂} +struct SparseBlockTensorMap{TT <: AbstractTensorMap, E, S, N₁, N₂, N} <: + AbstractBlockTensorMap{E, S, N₁, N₂} + data::Dict{CartesianIndex{N}, TT} + space::TensorMapSumSpace{S, N₁, N₂} # uninitialized constructor - function SparseBlockTensorMap{TT,E,S,N₁,N₂,N}( - ::UndefBlocksInitializer, space::TensorMapSumSpace{S,N₁,N₂} - ) where {E,S,N₁,N₂,N,TT<:AbstractTensorMap{E,S,N₁,N₂}} + function SparseBlockTensorMap{TT, E, S, N₁, N₂, N}( + ::UndefBlocksInitializer, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, N, TT <: AbstractTensorMap{E, S, N₁, N₂}} @assert N₁ + N₂ == N "SparseBlockTensorMap: data has wrong number of dimensions" - data = Dict{CartesianIndex{N},TT}() - return new{TT,E,S,N₁,N₂,N}(data, space) + data = Dict{CartesianIndex{N}, TT}() + return new{TT, E, S, N₁, N₂, N}(data, space) end # constructor from data - function SparseBlockTensorMap{TT,E,S,N₁,N₂,N}( - data::Dict{CartesianIndex{N},TT}, space::TensorMapSumSpace{S,N₁,N₂} - ) where {E,S,N₁,N₂,N,TT<:AbstractTensorMap{E,S,N₁,N₂}} + function SparseBlockTensorMap{TT, E, S, N₁, N₂, N}( + data::Dict{CartesianIndex{N}, TT}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, N, TT <: AbstractTensorMap{E, S, N₁, N₂}} @assert N₁ + N₂ == N "SparseBlockTensorMap: data has wrong number of dimensions" - return new{TT,E,S,N₁,N₂,N}(data, space) + return new{TT, E, S, N₁, N₂, N}(data, space) end end -function SparseBlockTensorMap{TT,E,S,N₁,N₂,N}( - ::UndefInitializer, space::TensorMapSumSpace{S,N₁,N₂} -) where {E,S,N₁,N₂,N,TT<:AbstractTensorMap{E,S,N₁,N₂}} - return SparseBlockTensorMap{TT,E,S,N₁,N₂,N}(undef_blocks, space) +function SparseBlockTensorMap{TT, E, S, N₁, N₂, N}( + ::UndefInitializer, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, N, TT <: AbstractTensorMap{E, S, N₁, N₂}} + return SparseBlockTensorMap{TT, E, S, N₁, N₂, N}(undef_blocks, space) end # uninitialized constructor function SparseBlockTensorMap{TT}( - ::Union{UndefBlocksInitializer,UndefInitializer}, space::TensorMapSumSpace{S,N₁,N₂} -) where {E,S,N₁,N₂,TT<:AbstractTensorMap{E,S,N₁,N₂}} + ::Union{UndefBlocksInitializer, UndefInitializer}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, TT <: AbstractTensorMap{E, S, N₁, N₂}} N = N₁ + N₂ - return SparseBlockTensorMap{TT,E,S,N₁,N₂,N}(undef_blocks, space) + return SparseBlockTensorMap{TT, E, S, N₁, N₂, N}(undef_blocks, space) end # constructor from data function SparseBlockTensorMap{TT}( - data::Dict{CartesianIndex{N},TT}, space::TensorMapSumSpace{S,N₁,N₂} -) where {E,S,N₁,N₂,N,TT<:AbstractTensorMap{E,S,N₁,N₂}} - return SparseBlockTensorMap{TT,E,S,N₁,N₂,N}(data, space) + data::Dict{CartesianIndex{N}, TT}, space::TensorMapSumSpace{S, N₁, N₂} + ) where {E, S, N₁, N₂, N, TT <: AbstractTensorMap{E, S, N₁, N₂}} + return SparseBlockTensorMap{TT, E, S, N₁, N₂, N}(data, space) end -function sparseblocktensormaptype(::Type{S}, N₁::Int, N₂::Int, ::Type{T}) where {S,T} +function sparseblocktensormaptype(::Type{S}, N₁::Int, N₂::Int, ::Type{T}) where {S, T} TT = tensormaptype(S, N₁, N₂, T) return SparseBlockTensorMap{TT} end function sparseblocktensormaptype( - ::Type{SumSpace{S}}, N₁::Int, N₂::Int, ::Type{T} -) where {S,T} + ::Type{SumSpace{S}}, N₁::Int, N₂::Int, ::Type{T} + ) where {S, T} TT = tensormaptype(S, N₁, N₂, T) return SparseBlockTensorMap{TT} end @@ -61,10 +61,9 @@ end # Constructors # ------------ function SparseBlockTensorMap{TT}( - data::Union{Array{TT},UndefInitializer,UndefBlocksInitializer}, - codom::ProductSumSpace, - dom::ProductSumSpace, -) where {TT} + data::Union{Array{TT}, UndefInitializer, UndefBlocksInitializer}, + codom::ProductSumSpace, dom::ProductSumSpace, + ) where {TT} return SparseBlockTensorMap{TT}(data, codom ← dom) end @@ -99,17 +98,17 @@ Construct a sparse blocktensor with entries compatible with type `T` and space ` By default, the tensor will be empty, but nonzero entries can be specified by passing a tuple of indices `nonzero_inds`. """ spzeros(W::TensorMapSumSpace, args...) = spzeros(Float64, W, args...) -function spzeros(T::Type, cod::TensorSumSpace, dom::TensorSumSpace=one(cod), args...) +function spzeros(T::Type, cod::TensorSumSpace, dom::TensorSumSpace = one(cod), args...) return spzeros(T, cod ← dom, args...) end function spzeros( - T::Type, cod::TensorSumSpace, nonzero_inds::AbstractVector{<:CartesianIndex} -) + T::Type, cod::TensorSumSpace, nonzero_inds::AbstractVector{<:CartesianIndex} + ) return spzeros(T, cod, one(cod), nonzero_inds) end function spzeros( - ::Type{T}, W::TensorMapSumSpace, nonzero_inds=CartesianIndex{numind(W)}[] -) where {T} + ::Type{T}, W::TensorMapSumSpace, nonzero_inds = CartesianIndex{numind(W)}[] + ) where {T} TT = sparseblocktensormaptype(spacetype(W), numout(W), numin(W), T) tdst = TT(undef_blocks, W) @inbounds for I in nonzero_inds @@ -139,13 +138,13 @@ function sprand(T::Type, cod::TensorSumSpace, dom::TensorSumSpace, p::Real) return sprand(Random.default_rng(), T, cod ← dom, p) end function sprand( - rng::Random.AbstractRNG, T::Type, cod::TensorSumSpace, dom::TensorSumSpace, p::Real -) + rng::Random.AbstractRNG, T::Type, cod::TensorSumSpace, dom::TensorSumSpace, p::Real + ) return sprand(rng, T, cod ← dom, p) end function sprand( - rng::Random.AbstractRNG, ::Type{T}, V::TensorMapSumSpace, p::Real -) where {T<:Number} + rng::Random.AbstractRNG, ::Type{T}, V::TensorMapSumSpace, p::Real + ) where {T <: Number} TT = sparseblocktensormaptype(spacetype(V), numout(V), numin(V), T) t = TT(undef_blocks, V) @inbounds for I in eachindex(t) @@ -176,7 +175,7 @@ function Base.delete!(t::SparseBlockTensorMap, I::CartesianIndex) delete!(t.data, I) return t end -function Base.delete!(t::SparseBlockTensorMap{TT}, I::Vararg{Int,N}) where {TT,N} +function Base.delete!(t::SparseBlockTensorMap{TT}, I::Vararg{Int, N}) where {TT, N} return delete!(t, CartesianIndex(I...)) end diff --git a/src/tensors/tensoroperations.jl b/src/tensors/tensoroperations.jl index 4029630..21dcc21 100644 --- a/src/tensors/tensoroperations.jl +++ b/src/tensors/tensoroperations.jl @@ -1,6 +1,6 @@ @noinline function _check_spacetype( - ::Type{S₁}, ::Type{S₂} -) where {S₁<:ElementarySpace,S₂<:ElementarySpace} + ::Type{S₁}, ::Type{S₂} + ) where {S₁ <: ElementarySpace, S₂ <: ElementarySpace} S₁ === S₂ || S₁ === SumSpace{S₂} || SumSpace{S₁} === S₂ || @@ -11,13 +11,13 @@ end # TensorOperations # ---------------- function TO.tensoradd_type( - TC, A::AbstractBlockTensorMap, ::Index2Tuple{N₁,N₂}, ::Bool -) where {N₁,N₂} + TC, A::AbstractBlockTensorMap, ::Index2Tuple{N₁, N₂}, ::Bool + ) where {N₁, N₂} TA = eltype(A) I = sectortype(A) Tnew = sectorscalartype(I) <: Real ? TC : complex(TC) if TA isa Union - M = Union{TK.similarstoragetype(TA.a, Tnew),TK.similarstoragetype(TA.b, Tnew)} + M = Union{TK.similarstoragetype(TA.a, Tnew), TK.similarstoragetype(TA.b, Tnew)} else M = TK.similarstoragetype(TA, Tnew) end @@ -34,15 +34,11 @@ end # tensoralloc_contract # -------------------- function TO.tensorcontract_type( - TC, - A::AbstractBlockTensorMap, - ::Index2Tuple, - ::Bool, - B::AbstractBlockTensorMap, - ::Index2Tuple, - ::Bool, - ::Index2Tuple{N₁,N₂}, -) where {N₁,N₂} + TC, + A::AbstractBlockTensorMap, ::Index2Tuple, ::Bool, + B::AbstractBlockTensorMap, ::Index2Tuple, ::Bool, + ::Index2Tuple{N₁, N₂}, + ) where {N₁, N₂} _check_spacetype(spacetype(A), spacetype(B)) I = sectortype(A) @@ -56,15 +52,11 @@ function TO.tensorcontract_type( end end function TO.tensorcontract_type( - TC, - A::AbstractTensorMap, - pA::Index2Tuple, - conjA::Bool, - B::AbstractBlockTensorMap, - pB::Index2Tuple, - conjB::Bool, - pAB::Index2Tuple{N₁,N₂}, -) where {N₁,N₂} + TC, + A::AbstractTensorMap, pA::Index2Tuple, conjA::Bool, + B::AbstractBlockTensorMap, pB::Index2Tuple, conjB::Bool, + pAB::Index2Tuple{N₁, N₂}, + ) where {N₁, N₂} _check_spacetype(spacetype(A), spacetype(B)) I = sectortype(A) @@ -78,15 +70,11 @@ function TO.tensorcontract_type( end end function TO.tensorcontract_type( - TC, - A::AbstractBlockTensorMap, - ::Index2Tuple, - ::Bool, - B::AbstractTensorMap, - ::Index2Tuple, - ::Bool, - ::Index2Tuple{N₁,N₂}, -) where {N₁,N₂} + TC, + A::AbstractBlockTensorMap, ::Index2Tuple, ::Bool, + B::AbstractTensorMap, ::Index2Tuple, ::Bool, + ::Index2Tuple{N₁, N₂}, + ) where {N₁, N₂} _check_spacetype(spacetype(A), spacetype(B)) I = sectortype(A) @@ -101,17 +89,13 @@ function TO.tensorcontract_type( end function TO.tensoralloc_contract( - TC, - A::AbstractBlockTensorMap, - pA::Index2Tuple, - conjA::Bool, - B::AbstractBlockTensorMap, - pB::Index2Tuple, - conjB::Bool, - pAB::Index2Tuple, - istemp::Val=Val(false), - allocator=TO.DefaultAllocator(), -) + TC, + A::AbstractBlockTensorMap, pA::Index2Tuple, conjA::Bool, + B::AbstractBlockTensorMap, pB::Index2Tuple, conjB::Bool, + pAB::Index2Tuple, + istemp::Val = Val(false), + allocator = TO.DefaultAllocator(), + ) ttype = TO.tensorcontract_type(TC, A, pA, conjA, B, pB, conjB, pAB) structure = TO.tensorcontract_structure(A, pA, conjA, B, pB, conjB, pAB) TT = eltype(ttype) @@ -120,11 +104,11 @@ function TO.tensoralloc_contract( # do not allocate, use undef allocator E, S, N1, N2 = scalartype(TT), spacetype(TT), numout(structure), numin(structure) if issparse(A) && issparse(B) - return SparseBlockTensorMap{AbstractTensorMap{E,S,N1,N2}}( + return SparseBlockTensorMap{AbstractTensorMap{E, S, N1, N2}}( undef, codomain(structure), domain(structure) ) else - return BlockTensorMap{AbstractTensorMap{E,S,N1,N2}}( + return BlockTensorMap{AbstractTensorMap{E, S, N1, N2}}( undef, codomain(structure), domain(structure) ) end @@ -133,37 +117,37 @@ function TO.tensoralloc_contract( end end -function promote_storagetype(::Type{T}, ::Type{T₁}, ::Type{T₂}) where {T,T₁,T₂} +function promote_storagetype(::Type{T}, ::Type{T₁}, ::Type{T₂}) where {T, T₁, T₂} if T₁ isa Union - M₁ = Union{TK.similarstoragetype(T₁.a, T),TK.similarstoragetype(T₁.b, T)} + M₁ = Union{TK.similarstoragetype(T₁.a, T), TK.similarstoragetype(T₁.b, T)} else M₁ = TK.similarstoragetype(T₁, T) end if T₂ isa Union - M₂ = Union{TK.similarstoragetype(T₂.a, T),TK.similarstoragetype(T₂.b, T)} + M₂ = Union{TK.similarstoragetype(T₂.a, T), TK.similarstoragetype(T₂.b, T)} else M₂ = TK.similarstoragetype(T₂, T) end - return Union{M₁,M₂} + return Union{M₁, M₂} end # EVIL HACK!!! -TK.storagetype(::Type{AbstractTensorMap{TT,S,N₁,N₂}}) where {TT,S,N₁,N₂} = Vector{TT} +TK.storagetype(::Type{AbstractTensorMap{TT, S, N₁, N₂}}) where {TT, S, N₁, N₂} = Vector{TT} -function promote_blocktype(::Type{TT}, ::Type{A₁}, ::Type{A₂}) where {TT,A₁,A₂} +function promote_blocktype(::Type{TT}, ::Type{A₁}, ::Type{A₂}) where {TT, A₁, A₂} N = similarblocktype(A₁, TT) @assert N === similarblocktype(A₂, TT) "incompatible block types" return N end -function similarblocktype(::Type{A}, ::Type{TT}) where {A,TT} - return Core.Compiler.return_type(similar, Tuple{A,Type{TT},NTuple{numind(TT),Int}}) +function similarblocktype(::Type{A}, ::Type{TT}) where {A, TT} + return Core.Compiler.return_type(similar, Tuple{A, Type{TT}, NTuple{numind(TT), Int}}) end # By default, make "dense" allocations function TO.tensoralloc( - ::Type{BT}, structure::TensorMapSumSpace, istemp::Val, allocator=TO.DefaultAllocator() -) where {BT<:AbstractBlockTensorMap} + ::Type{BT}, structure::TensorMapSumSpace, istemp::Val, allocator = TO.DefaultAllocator() + ) where {BT <: AbstractBlockTensorMap} C = BT(undef_blocks, structure) blockallocator(V) = TO.tensoralloc(eltype(C), V, istemp, allocator) map!(blockallocator, parent(C), eachspace(C)) @@ -172,24 +156,23 @@ end # tensorfree! # ----------- -function TO.tensorfree!(t::BlockTensorMap, allocator=TO.DefaultAllocator()) +function TO.tensorfree!(t::BlockTensorMap, allocator = TO.DefaultAllocator()) foreach(Base.Fix2(TO.tensorfree!, allocator), parent(t)) return nothing end -function TO.tensorfree!(t::SparseBlockTensorMap, allocator=TO.DefaultAllocator()) +function TO.tensorfree!(t::SparseBlockTensorMap, allocator = TO.DefaultAllocator()) foreach(Base.Fix2(TO.tensorfree!, allocator), nonzero_values(t)) return nothing end function TK.trace_permute!( - tdst::AbstractBlockTensorMap, - tsrc::AbstractBlockTensorMap, - (p₁, p₂)::Index2Tuple, - (q₁, q₂)::Index2Tuple, - α::Number, - β::Number, - backend::AbstractBackend=TO.DefaultBackend(), -) + tdst::AbstractBlockTensorMap, + tsrc::AbstractBlockTensorMap, + (p₁, p₂)::Index2Tuple, + (q₁, q₂)::Index2Tuple, + α::Number, β::Number, + backend::AbstractBackend = TO.DefaultBackend(), + ) # some input checks _check_spacetype(spacetype(tdst), spacetype(tsrc)) if !(BraidingStyle(sectortype(tdst)) isa SymmetricBraiding) @@ -225,16 +208,16 @@ end # PlanarOperations # ---------------- -function TK.BraidingTensor{T,S}( - V1::SumSpace{S}, V2::SumSpace{S}, adjoint::Bool=false -) where {T,S} - τtype = BraidingTensor{T,S} +function TK.BraidingTensor{T, S}( + V1::SumSpace{S}, V2::SumSpace{S}, adjoint::Bool = false + ) where {T, S} + τtype = BraidingTensor{T, S} tdst = SparseBlockTensorMap{τtype}(undef, V2 ⊗ V1, V1 ⊗ V2) Vs = eachspace(tdst) @inbounds for I in CartesianIndices(tdst) if I[1] == I[4] && I[2] == I[3] V = Vs[I] - tdst[I] = TK.BraidingTensor{T,S}(V[2], V[1], adjoint) + tdst[I] = TK.BraidingTensor{T, S}(V[2], V[1], adjoint) end end return tdst diff --git a/src/tensors/vectorinterface.jl b/src/tensors/vectorinterface.jl index 80a8906..ebcf444 100644 --- a/src/tensors/vectorinterface.jl +++ b/src/tensors/vectorinterface.jl @@ -73,7 +73,7 @@ function VI.inner(x::SparseBlockTensorMap, y::SparseBlockTensorMap) space(x) == space(y) || throw(SpaceMismatch()) both_nonzero = intersect(nonzero_keys(x), nonzero_keys(y)) T = VI.promote_inner(x, y) - return sum(both_nonzero; init=zero(T)) do k + return sum(both_nonzero; init = zero(T)) do k inner(x[k], y[k]) end end diff --git a/src/vectorspaces/sumspace.jl b/src/vectorspaces/sumspace.jl index 1627f53..21bf105 100644 --- a/src/vectorspaces/sumspace.jl +++ b/src/vectorspaces/sumspace.jl @@ -3,17 +3,17 @@ A (lazy) direct sum of elementary vector spaces of type `S`. """ -struct SumSpace{S<:ElementarySpace} <: ElementarySpace +struct SumSpace{S <: ElementarySpace} <: ElementarySpace spaces::Vector{S} end -SumSpace(V::S, spaces::S...) where {S<:ElementarySpace} = SumSpace(collect((V, spaces...))) +SumSpace(V::S, spaces::S...) where {S <: ElementarySpace} = SumSpace(collect((V, spaces...))) SumSpace{S}() where {S} = SumSpace(S[]) # Convenience aliases -const ProductSumSpace{S,N} = ProductSpace{SumSpace{S},N} +const ProductSumSpace{S, N} = ProductSpace{SumSpace{S}, N} const TensorSumSpace{S} = TensorSpace{SumSpace{S}} -const TensorMapSumSpace{S,N₁,N₂} = TensorMapSpace{SumSpace{S},N₁,N₂} +const TensorMapSumSpace{S, N₁, N₂} = TensorMapSpace{SumSpace{S}, N₁, N₂} # AbstractArray behavior # ---------------------- @@ -62,7 +62,7 @@ TensorKit.field(::Type{SumSpace{S}}) where {S} = field(S) Return the type of a `SumSpace` with elements of type `S`. """ -sumspacetype(::Type{S}) where {S<:ElementarySpace} = SumSpace{S} +sumspacetype(::Type{S}) where {S <: ElementarySpace} = SumSpace{S} TensorKit.dims(S::SumSpace) = map(dim, S.spaces) TensorKit.dim(S::SumSpace, n::Int) = dim(S.spaces[n]) @@ -74,10 +74,10 @@ Base.conj(S::SumSpace) = dual(S) TensorKit.flip(S::SumSpace) = SumSpace(map(flip, S.spaces)) function TensorKit.hassector(S::SumSpace, s::Sector) - return mapreduce(v -> hassector(v, s), |, S.spaces; init=false) + return mapreduce(v -> hassector(v, s), |, S.spaces; init = false) end function TensorKit.hassector(S::SumSpace, ::Trivial) - return mapreduce(v -> hassector(v, Trivial()), |, S.spaces; init=false) + return mapreduce(v -> hassector(v, Trivial()), |, S.spaces; init = false) end TensorKit.sectors(S::SumSpace) = TensorKit._sectors(S, sectortype(S)) @@ -92,9 +92,9 @@ function TensorKit._sectors(S::SumSpace, ::Type{I}) where {I} return values(s) end -TensorKit.dim(S::SumSpace, sector::Sector) = sum(v -> dim(v, sector), S.spaces; init=0) +TensorKit.dim(S::SumSpace, sector::Sector) = sum(v -> dim(v, sector), S.spaces; init = 0) # ambiguity fix: -TensorKit.dim(S::SumSpace, ::Trivial) = sum(v -> dim(v, Trivial()), S.spaces; init=0) +TensorKit.dim(S::SumSpace, ::Trivial) = sum(v -> dim(v, Trivial()), S.spaces; init = 0) # TODO: find a better name for this function @@ -102,15 +102,15 @@ TensorKit.compose(V, W) = TensorKit.compose(promote(V, W)...) # bit of a hack to make spacechecks happy? Base.:(==)(V::SumSpace{S}, W::S) where {S} = ==(promote(V, W)...) Base.:(==)(V::S, W::SumSpace{S}) where {S} = ==(promote(V, W)...) -function Base.:(==)(V::TensorMapSumSpace{S}, W::TensorMapSpace{S}) where {S<:IndexSpace} +function Base.:(==)(V::TensorMapSumSpace{S}, W::TensorMapSpace{S}) where {S <: IndexSpace} return ==(promote(V, W)...) end -function Base.:(==)(V::TensorMapSpace{S}, W::TensorMapSumSpace{S}) where {S<:IndexSpace} +function Base.:(==)(V::TensorMapSpace{S}, W::TensorMapSumSpace{S}) where {S <: IndexSpace} return ==(promote(V, W)...) end # disambiguate -function Base.:(==)(V::TensorMapSumSpace{S}, W::TensorMapSumSpace{S}) where {S<:IndexSpace} - @invoke ==(V::HomSpace, W::HomSpace) +function Base.:(==)(V::TensorMapSumSpace{S}, W::TensorMapSumSpace{S}) where {S <: IndexSpace} + return @invoke ==(V::HomSpace, W::HomSpace) end # this conflicts with the definition in TensorKit, so users always need to specify # ⊕(Vs::IndexSpace...) = SumSpace(Vs...) @@ -121,7 +121,7 @@ function ⊕ end const oplus = ⊕ ⊕(V::ElementarySpace) = V isa SumSpace ? V : SumSpace(V) -function ⊕(V₁::S, V₂::S) where {S<:ElementarySpace} +function ⊕(V₁::S, V₂::S) where {S <: ElementarySpace} return if isdual(V₁) == isdual(V₂) SumSpace(V₁, V₂) else @@ -146,7 +146,7 @@ end TensorKit.:⊕(V1::SumSpace, V2::SumSpace...) = TensorKit.oplus(⊕(V1, V2...)) #! format: on -function TensorKit.fuse(V1::S, V2::S) where {S<:SumSpace} +function TensorKit.fuse(V1::S, V2::S) where {S <: SumSpace} return SumSpace(vec([fuse(v1, v2) for (v1, v2) in Base.product(V1.spaces, V2.spaces)])) end @@ -154,44 +154,44 @@ Base.oneunit(S::Type{<:SumSpace}) = SumSpace(oneunit(eltype(S))) # Promotion and conversion # ------------------------ -Base.promote_rule(::Type{S}, ::Type{SumSpace{S}}) where {S<:ElementarySpace} = SumSpace{S} +Base.promote_rule(::Type{S}, ::Type{SumSpace{S}}) where {S <: ElementarySpace} = SumSpace{S} function Base.promote_rule( - ::Type{S1}, ::Type{<:ProductSpace{S2}} -) where {S1<:ElementarySpace,S2<:ElementarySpace} + ::Type{S1}, ::Type{<:ProductSpace{S2}} + ) where {S1 <: ElementarySpace, S2 <: ElementarySpace} return ProductSpace{promote_type(S1, S2)} end function Base.promote_rule( - ::Type{<:ProductSpace{S1}}, ::Type{<:ProductSpace{S2}} -) where {S1<:ElementarySpace,S2<:ElementarySpace} + ::Type{<:ProductSpace{S1}}, ::Type{<:ProductSpace{S2}} + ) where {S1 <: ElementarySpace, S2 <: ElementarySpace} return ProductSpace{promote_type(S1, S2)} end function Base.promote_rule( - ::Type{<:TensorMapSumSpace{S}}, ::Type{<:TensorMapSpace{S}} -) where {S} + ::Type{<:TensorMapSumSpace{S}}, ::Type{<:TensorMapSpace{S}} + ) where {S} return TensorMapSumSpace{S} end -Base.convert(::Type{I}, S::SumSpace{I}) where {I<:ElementarySpace} = TensorKit.oplus(S) -Base.convert(::Type{SumSpace{S}}, V::S) where {S<:ElementarySpace} = SumSpace(V) -function Base.convert(::Type{<:ProductSumSpace{S,N}}, V::ProductSpace{S,N}) where {S,N} - return ProductSumSpace{S,N}(SumSpace.(V.spaces)...) +Base.convert(::Type{I}, S::SumSpace{I}) where {I <: ElementarySpace} = TensorKit.oplus(S) +Base.convert(::Type{SumSpace{S}}, V::S) where {S <: ElementarySpace} = SumSpace(V) +function Base.convert(::Type{<:ProductSumSpace{S, N}}, V::ProductSpace{S, N}) where {S, N} + return ProductSumSpace{S, N}(SumSpace.(V.spaces)...) end -function Base.convert(::Type{<:ProductSumSpace{S}}, V::ProductSpace{S,N}) where {S,N} - return ProductSumSpace{S,N}(SumSpace.(V.spaces)...) +function Base.convert(::Type{<:ProductSumSpace{S}}, V::ProductSpace{S, N}) where {S, N} + return ProductSumSpace{S, N}(SumSpace.(V.spaces)...) end -function Base.convert(::Type{<:ProductSpace{S,N}}, V::ProductSumSpace{S,N}) where {S,N} - return ProductSpace{S,N}(TensorKit.oplus.(V.spaces)...) +function Base.convert(::Type{<:ProductSpace{S, N}}, V::ProductSumSpace{S, N}) where {S, N} + return ProductSpace{S, N}(TensorKit.oplus.(V.spaces)...) end function Base.convert( - ::Type{<:TensorMapSumSpace{S}}, V::TensorMapSpace{S,N₁,N₂} -) where {S,N₁,N₂} - return convert(ProductSumSpace{S,N₁}, codomain(V)) ← - convert(ProductSumSpace{S,N₂}, domain(V)) + ::Type{<:TensorMapSumSpace{S}}, V::TensorMapSpace{S, N₁, N₂} + ) where {S, N₁, N₂} + return convert(ProductSumSpace{S, N₁}, codomain(V)) ← + convert(ProductSumSpace{S, N₂}, domain(V)) end function Base.convert( - ::Type{<:TensorMapSpace{S,N₁,N₂}}, V::TensorMapSumSpace{S,N₁,N₂} -) where {S,N₁,N₂} - return convert(ProductSpace{S,N₁}, codomain(V)) ← convert(ProductSpace{S,N₂}, domain(V)) + ::Type{<:TensorMapSpace{S, N₁, N₂}}, V::TensorMapSumSpace{S, N₁, N₂} + ) where {S, N₁, N₂} + return convert(ProductSpace{S, N₁}, codomain(V)) ← convert(ProductSpace{S, N₂}, domain(V)) end # Show diff --git a/src/vectorspaces/sumspaceindices.jl b/src/vectorspaces/sumspaceindices.jl index 7d3594a..090331d 100644 --- a/src/vectorspaces/sumspaceindices.jl +++ b/src/vectorspaces/sumspaceindices.jl @@ -12,20 +12,20 @@ eachspace(V::TensorMapSumSpace) = SumSpaceIndices(V) """ struct SumSpaceIndices{S,N₁,N₂} <: AbstractArray{TensorMapSpace{S,N₁,N₂},N₁ + N₂} """ -struct SumSpaceIndices{S,N₁,N₂,N} <: AbstractArray{TensorMapSpace{S,N₁,N₂},N} - sumspaces::NTuple{N,SumSpace{S}} - function SumSpaceIndices{S,N₁,N₂}(sumspaces::NTuple{N,SumSpace{S}}) where {S,N₁,N₂,N} +struct SumSpaceIndices{S, N₁, N₂, N} <: AbstractArray{TensorMapSpace{S, N₁, N₂}, N} + sumspaces::NTuple{N, SumSpace{S}} + function SumSpaceIndices{S, N₁, N₂}(sumspaces::NTuple{N, SumSpace{S}}) where {S, N₁, N₂, N} @assert N == N₁ + N₂ "Invalid number of spaces" - return new{S,N₁,N₂,N}(sumspaces) + return new{S, N₁, N₂, N}(sumspaces) end end function SumSpaceIndices(V::HomSpace{SumSpace{S}}) where {S} N₁ = length(codomain(V)) N₂ = length(domain(V)) - return SumSpaceIndices{S,N₁,N₂}((V.codomain..., V.domain...)) + return SumSpaceIndices{S, N₁, N₂}((V.codomain..., V.domain...)) end -function SumSpaceIndices{S,N₁,N₂}(spaces::Tuple) where {S,N₁,N₂} - return SumSpaceIndices{S,N₁,N₂}(map(x -> convert(SumSpace{S}, x), spaces)) +function SumSpaceIndices{S, N₁, N₂}(spaces::Tuple) where {S, N₁, N₂} + return SumSpaceIndices{S, N₁, N₂}(map(x -> convert(SumSpace{S}, x), spaces)) end # Overload show of type to hide the inferred last type parameter @@ -37,11 +37,11 @@ Base.size(I::SumSpaceIndices) = map(length, I.sumspaces) Base.IndexStyle(::Type{<:SumSpaceIndices}) = IndexCartesian() # simple scalar indexing -function Base.getindex(iter::SumSpaceIndices{S,N₁,N₂,N}, I::Vararg{Int,N}) where {S,N₁,N₂,N} - codomain = ProductSpace{S,N₁}( +function Base.getindex(iter::SumSpaceIndices{S, N₁, N₂, N}, I::Vararg{Int, N}) where {S, N₁, N₂, N} + codomain = ProductSpace{S, N₁}( map((inds, v) -> getindex(v.spaces, inds...), I[1:N₁], iter.sumspaces[1:N₁]) ) - domain = ProductSpace{S,N₂}( + domain = ProductSpace{S, N₂}( map( (inds, v) -> getindex(v.spaces, inds...), I[(N₁ + 1):N], @@ -53,16 +53,16 @@ end # non-scalar indexing @inline function Base._getindex( - ::IndexCartesian, - iter::SumSpaceIndices{S,N₁,N₂,N}, - I::Vararg{Union{Real,AbstractArray},N}, -) where {S,N₁,N₂,N} + ::IndexCartesian, + iter::SumSpaceIndices{S, N₁, N₂, N}, + I::Vararg{Union{Real, AbstractArray}, N}, + ) where {S, N₁, N₂, N} @boundscheck checkbounds(iter, I...) - return SumSpaceIndices{S,N₁,N₂}(map(getindex, iter.sumspaces, I)) + return SumSpaceIndices{S, N₁, N₂}(map(getindex, iter.sumspaces, I)) end @inline function Base._getindex( - ::IndexCartesian, iter::SumSpaceIndices{S,N₁,N₂}, I::Union{Real,AbstractVector} -) where {S,N₁,N₂} + ::IndexCartesian, iter::SumSpaceIndices{S, N₁, N₂}, I::Union{Real, AbstractVector} + ) where {S, N₁, N₂} @boundscheck checkbounds(iter, I) nontrivial_sizes = findall(>(1), size(iter)) if isempty(nontrivial_sizes) @@ -76,37 +76,37 @@ end end # disambiguate: @inline function Base._getindex( - ::IndexCartesian, iter::SumSpaceIndices{S,N₁,N₂,1}, I::Union{Real,AbstractVector} -) where {S,N₁,N₂} + ::IndexCartesian, iter::SumSpaceIndices{S, N₁, N₂, 1}, I::Union{Real, AbstractVector} + ) where {S, N₁, N₂} @boundscheck checkbounds(iter, I) - return SumSpaceIndices{S,N₁,N₂}(map(getindex, iter.sumspaces, (I,))) + return SumSpaceIndices{S, N₁, N₂}(map(getindex, iter.sumspaces, (I,))) end @inline Base._getindex(::IndexCartesian, iter::SumSpaceIndices, ::Colon) = iter # disambiguation of base methods function Base._getindex( - ::IndexCartesian, A::SumSpaceIndices{S,N₁,N₂,N}, I::Vararg{Int,M} -) where {S,N₁,N₂,N,M} + ::IndexCartesian, A::SumSpaceIndices{S, N₁, N₂, N}, I::Vararg{Int, M} + ) where {S, N₁, N₂, N, M} @inline @boundscheck checkbounds(A, I...) # generally _to_subscript_indices requires bounds checking @inbounds r = getindex(A, Base._to_subscript_indices(A, I...)...) return r end function Base._getindex( - ::IndexCartesian, A::SumSpaceIndices{S,N₁,N₂,N}, I::Vararg{Int,N} -) where {S,N₁,N₂,N} + ::IndexCartesian, A::SumSpaceIndices{S, N₁, N₂, N}, I::Vararg{Int, N} + ) where {S, N₁, N₂, N} Base.@_propagate_inbounds_meta return getindex(A, I...) end -function TensorKit.space(I::SumSpaceIndices{S,N₁,N₂,N}) where {S,N₁,N₂,N} - cod = prod(I.sumspaces[1:N₁]; init=one(sumspacetype(S))) - dom = prod(I.sumspaces[(N₁ + 1):end]; init=one(sumspacetype(S))) +function TensorKit.space(I::SumSpaceIndices{S, N₁, N₂, N}) where {S, N₁, N₂, N} + cod = prod(I.sumspaces[1:N₁]; init = one(sumspacetype(S))) + dom = prod(I.sumspaces[(N₁ + 1):end]; init = one(sumspacetype(S))) return cod ← dom end -function subblockdims(V::ProductSumSpace{S,N}, c::Sector) where {S,N} +function subblockdims(V::ProductSumSpace{S, N}, c::Sector) where {S, N} return if N == 0 [1] else @@ -119,8 +119,8 @@ function subblockdims(V::ProductSumSpace{S,N}, c::Sector) where {S,N} end function Base._cat( - dims, A::SumSpaceIndices{S,N₁,N₂}, As::SumSpaceIndices{S,N₁,N₂}... -) where {S,N₁,N₂} + dims, A::SumSpaceIndices{S, N₁, N₂}, As::SumSpaceIndices{S, N₁, N₂}... + ) where {S, N₁, N₂} @assert maximum(dims) <= N₁ + N₂ "Invalid number of spaces" catdims = Base.dims2cat(dims) allA = (A, As...) @@ -131,5 +131,5 @@ function Base._cat( A.sumspaces[i] end end - return SumSpaceIndices{S,N₁,N₂}(Vs) + return SumSpaceIndices{S, N₁, N₂}(Vs) end diff --git a/test/abstracttensor/blocktensor.jl b/test/abstracttensor/blocktensor.jl index 97185c6..a2df900 100644 --- a/test/abstracttensor/blocktensor.jl +++ b/test/abstracttensor/blocktensor.jl @@ -156,9 +156,9 @@ end for p in permutations(1:5) p1 = ntuple(n -> p[n], k) p2 = ntuple(n -> p[k + n], 5 - k) - t2 = permute(t, (p1, p2); copy=true) + t2 = permute(t, (p1, p2); copy = true) a2 = convert(TensorMap, t2) - @test a2 ≈ permute(a, (p1, p2); copy=true) + @test a2 ≈ permute(a, (p1, p2); copy = true) @test convert(TensorMap, transpose(t2)) ≈ transpose(a2) end end diff --git a/test/abstracttensor/sparseblocktensor.jl b/test/abstracttensor/sparseblocktensor.jl index f62696e..1cfb0ad 100644 --- a/test/abstracttensor/sparseblocktensor.jl +++ b/test/abstracttensor/sparseblocktensor.jl @@ -1,4 +1,3 @@ - using Test, TestExtras using TensorKit using BlockTensorKit @@ -163,9 +162,9 @@ end for p in permutations(1:5) p1 = ntuple(n -> p[n], k) p2 = ntuple(n -> p[k + n], 5 - k) - t2 = permute(t, (p1, p2); copy=true) + t2 = permute(t, (p1, p2); copy = true) a2 = convert(TensorMap, t2) - @test a2 ≈ permute(a, (p1, p2); copy=true) + @test a2 ≈ permute(a, (p1, p2); copy = true) @test convert(TensorMap, transpose(t2)) ≈ transpose(a2) end end diff --git a/test/aqua.jl b/test/aqua.jl index 218bbc8..43c7027 100644 --- a/test/aqua.jl +++ b/test/aqua.jl @@ -1,4 +1,4 @@ using Aqua: Aqua using BlockTensorKit: BlockTensorKit # dont test for piracies right now, these are deliberate. -Aqua.test_all(BlockTensorKit; piracies=false) +Aqua.test_all(BlockTensorKit; piracies = false) diff --git a/test/linalg/factorizations.jl b/test/linalg/factorizations.jl index 6c26ec5..3f7ee05 100644 --- a/test/linalg/factorizations.jl +++ b/test/linalg/factorizations.jl @@ -62,13 +62,13 @@ const leftnull_algs = (TensorKit.QR(), TensorKit.SVD(), TensorKit.SDD()) @testset "leftnull with $alg" for alg in leftnull_algs for T in (Float32, ComplexF64), isadjoint in (false, true) t = isadjoint ? rand(T, W)' : rand(T, W) - N = @constinferred leftnull(t, ((3, 4, 2), (1, 5)); alg=alg) + N = @constinferred leftnull(t, ((3, 4, 2), (1, 5)); alg = alg) NdN = N' * N @test NdN ≈ one(NdN) @test norm(N' * permute(t, ((3, 4, 2), (1, 5)))) < 100 * eps(norm(t)) t_empty = isadjoint ? rand(T, W_empty')' : rand(T, W_empty) - N = @constinferred leftnull(t_empty; alg=alg) + N = @constinferred leftnull(t_empty; alg = alg) @test N' * N ≈ id(domain(N)) @test N * N' ≈ id(codomain(N)) end @@ -86,7 +86,7 @@ const rightorth_algs = ( @testset "rightorth with $alg" for alg in rightorth_algs for T in (Float32, ComplexF64), isadjoint in (false, true) t = isadjoint ? rand(T, W)' : rand(T, W) - L, Q = @constinferred rightorth(t, ((3, 4), (2, 1, 5)); alg=alg) + L, Q = @constinferred rightorth(t, ((3, 4), (2, 1, 5)); alg = alg) QQd = Q * Q' @test QQd ≈ one(QQd) @test L * Q ≈ permute(t, ((3, 4), (2, 1, 5))) @@ -96,7 +96,7 @@ const rightorth_algs = ( end t_empty = isadjoint ? rand(T, W_empty)' : rand(T, W_empty') - L, Q = @constinferred rightorth(t_empty; alg=alg) + L, Q = @constinferred rightorth(t_empty; alg = alg) @test Q == t_empty @test dim(Q) == dim(L) == 0 end @@ -106,7 +106,7 @@ const rightnull_algs = (TensorKit.LQ(), TensorKit.SVD(), TensorKit.SDD()) @testset "rightnull with $alg" for alg in rightnull_algs for T in (Float32, ComplexF64), isadjoint in (false, true) t = isadjoint ? rand(T, W)' : rand(T, W) - M = @constinferred rightnull(t, ((3, 4), (2, 1, 5)); alg=alg) + M = @constinferred rightnull(t, ((3, 4), (2, 1, 5)); alg = alg) MMd = M * M' @test MMd ≈ one(MMd) @test norm(permute(t, ((3, 4), (2, 1, 5))) * M') < 100 * eps(norm(t)) @@ -130,7 +130,7 @@ const svd_algs = (TensorKit.SVD(), TensorKit.SDD()) @test U * S * V ≈ permute(t, ((3, 4, 2), (1, 5))) t_empty = isadjoint ? rand(T, W_empty')' : rand(T, W_empty) - U, S, V = @inferred tsvd(t_empty; alg=alg) + U, S, V = @inferred tsvd(t_empty; alg = alg) @test U == t_empty @test dim(U) == dim(S) == dim(V) end diff --git a/test/linalg/vectorinterface.jl b/test/linalg/vectorinterface.jl index a759eba..5692f50 100644 --- a/test/linalg/vectorinterface.jl +++ b/test/linalg/vectorinterface.jl @@ -15,9 +15,9 @@ Vtr = ( V = Vtr @testset "VectorInterface $(issparse ? "SparseBlockTensorMap" : "BlockTensorMap")" for issparse in - ( - false, true -) + ( + false, true, + ) if issparse t = sprand(Float64, *(V[1:3]...) ← *(V[4], V[5]), 0.5) t′ = sprand(Float64, *(V[1:3]...) ← *(V[4], V[5]), 0.5) From bed34cf073b7f6352380d3b94cb828bc7fac601c Mon Sep 17 00:00:00 2001 From: Lukas Devos Date: Thu, 24 Jul 2025 09:52:20 -0400 Subject: [PATCH 2/2] Update github action --- .github/workflows/FormatCheck.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/workflows/FormatCheck.yml b/.github/workflows/FormatCheck.yml index f58700c..40aaca1 100644 --- a/.github/workflows/FormatCheck.yml +++ b/.github/workflows/FormatCheck.yml @@ -1,4 +1,4 @@ -name: "Format Check" +name: FormatCheck on: push: @@ -7,8 +7,11 @@ on: - 'master' tags: '*' pull_request: + branches: + - 'main' + - 'master' jobs: - format-check: + formatcheck: name: "Format Check" - uses: "QuantumKitHub/.github/.github/workflows/formatcheck.yml@main" \ No newline at end of file + uses: "QuantumKitHub/QuantumKitHubActions/.github/workflows/FormatCheck.yml@main"