type stability improvements

Author: lkdvos

src/fusiontrees/fusiontreeblocks.jl

@@ -607,7 +607,10 @@ end
 
 const _FSBraidKey{I,N₁,N₂} = Tuple{<:FusionTreeBlock{I},Index2Tuple{N₁,N₂},Index2Tuple}
 
-@cached function _fsbraid(key::_FSBraidKey{I,N₁,N₂})::Tuple{FusionTreeBlock{I,N₁,N₂},
+@cached function _fsbraid(key::_FSBraidKey{I,N₁,N₂})::Tuple{FusionTreeBlock{I,N₁,N₂,
+                                                                            fusiontreetype(I,
+                                                                                           N₁,
+                                                                                           N₂)},
                                                             Matrix{sectorscalartype(I)}} where {I,
                                                                                                 N₁,
                                                                                                 N₂}

src/fusiontrees/fusiontrees.jl

@@ -136,7 +136,7 @@ end
 Base.:(==)(f₁::FusionTree, f₂::FusionTree) = false
 
 # Facilitate getting correct fusion tree types
-function fusiontreetype(::Type{I}, N::Int) where {I<:Sector}
+Base.@assume_effects :foldable function fusiontreetype(::Type{I}, N::Int) where {I<:Sector}
     if N === 0
         FusionTree{I,0,0,0}
     elseif N === 1
@@ -145,7 +145,7 @@ function fusiontreetype(::Type{I}, N::Int) where {I<:Sector}
         FusionTree{I,N,N - 2,N - 1}
     end
 end
-function fusiontreetype(::Type{I}, N₁::Int, N₂::Int) where {I<:Sector}
+Base.@assume_effects :foldable function fusiontreetype(::Type{I}, N₁::Int, N₂::Int) where {I<:Sector}
     return Tuple{fusiontreetype(I, N₁),fusiontreetype(I, N₂)}
 end
 

src/fusiontrees/manipulations.jl

@@ -884,7 +884,8 @@ function artin_braid(f::FusionTree{I,N}, i; inv::Bool=false) where {I,N}
         return fusiontreedict(I)(f′ => coeff)
     elseif FusionStyle(I) isa SimpleFusion
         local newtrees
-        for c′ in intersect(a ⊗ d, e ⊗ conj(b))
+        cs = collect(I, intersect(a ⊗ d, e ⊗ conj(b)))
+        for c′ in cs
             coeff = oftype(oneT,
                            if inv
                                conj(Rsymbol(d, c, e) * Fsymbol(d, a, b, e, c′, c)) *
@@ -905,7 +906,8 @@ function artin_braid(f::FusionTree{I,N}, i; inv::Bool=false) where {I,N}
         return newtrees
     else # GenericFusion
         local newtrees
-        for c′ in intersect(a ⊗ d, e ⊗ conj(b))
+        cs = collect(I, intersect(a ⊗ d, e ⊗ conj(b)))
+        for c′ in cs
             Rmat1 = inv ? Rsymbol(d, c, e)' : Rsymbol(c, d, e)
             Rmat2 = inv ? Rsymbol(d, a, c′)' : Rsymbol(a, d, c′)
             Fmat = Fsymbol(d, a, b, e, c′, c)

src/tensors/treetransformers.jl

@@ -66,9 +66,13 @@ function GenericTreeTransformer(transform, p, Vdst, Vsrc)
     I = sectortype(Vsrc)
     T = sectorscalartype(I)
     N = numind(Vdst)
+    N₁ = numout(Vsrc)
+    N₂ = numin(Vsrc)
 
     isdual_src = (map(isdual, codomain(Vsrc).spaces), map(isdual, domain(Vsrc).spaces))
 
+    data = Vector{_GenericTransformerData{T,N}}()
+
     nthreads = get_num_transformer_threads()
     if nthreads > 1
         fusiontreeblocks = Vector{FusionTreeBlock{I,N₁,N₂,fusiontreetype(I, N₁, N₂)}}()
@@ -82,7 +86,7 @@ function GenericTreeTransformer(transform, p, Vdst, Vsrc)
             end
         end
 
-        data = Vector{_GenericTransformerData{T,N}}(undef, length(fusiontreeblocks))
+        resize!(data, length(fusiontreeblocks))
         counter = Threads.Atomic{Int}(1)
         Threads.@sync for _ in 1:min(nthreads, length(fusiontreeblocks))
             Threads.@spawn begin
@@ -106,18 +110,13 @@ function GenericTreeTransformer(transform, p, Vdst, Vsrc)
                     sz_dst, newstructs_dst = repack_transformer_structure(fusionstructure_dst,
                                                                           inds_dst)
 
-                    @debug("Created recoupling block for uncoupled: $uncoupled",
-                           sz = size(matrix),
-                           sparsity = count(!iszero, matrix) / length(matrix))
-
-                    data[local_counter] = (matrix, (sz_dst, newstructs_dst),
-                                           (sz_src, newstructs_src))
+                    data1[local_counter] = (matrix, (sz_dst, newstructs_dst),
+                                            (sz_src, newstructs_src))
                 end
             end
         end
+        transformer = GenericTreeTransformer{T,N}(data)
     else
-        data = Vector{_GenericTransformerData{T,N}}()
-
         isdual_src = (map(isdual, codomain(Vsrc).spaces), map(isdual, domain(Vsrc).spaces))
         for cod_uncoupled_src in sectors(codomain(Vsrc)),
             dom_uncoupled_src in sectors(domain(Vsrc))
@@ -140,24 +139,20 @@ function GenericTreeTransformer(transform, p, Vdst, Vsrc)
             sz_dst, newstructs_dst = repack_transformer_structure(fusionstructure_dst,
                                                                   inds_dst)
 
-            @debug("Created recoupling block for uncoupled: $uncoupled",
-                   sz = size(matrix), sparsity = count(!iszero, matrix) / length(matrix))
-
             push!(data, (matrix, (sz_dst, newstructs_dst), (sz_src, newstructs_src)))
         end
+        transformer = GenericTreeTransformer{T,N}(data)
     end
 
-    transformer = GenericTreeTransformer{T,N}(data)
-
     # sort by (approximate) weight to facilitate multi-threading strategies
     sort!(transformer)
 
     Δt = Base.time() - t₀
 
     @debug("TreeTransformer for $Vsrc to $Vdst via $p",
-           nblocks = length(data),
-           sz_median = size(data[cld(end, 2)][1], 1),
-           sz_max = size(data[1][1], 1),
+           nblocks = length(transformer.data),
+           sz_median = size(transformer.data[cld(end, 2)][1], 1),
+           sz_max = size(transformer.data[1][1], 1),
            Δt)
 
     return transformer