Specialise GradedSpace functions based on storage type

src/TensorKit.jl

@@ -44,7 +44,7 @@ export infimum, supremum, isisomorphic, ismonomorphic, isepimorphic
 export sectortype, sectors, hassector
 export unit, rightunit, leftunit, allunits, isunit, otimes, deligneproduct, timereversed
 export Nsymbol, Fsymbol, Rsymbol, Bsymbol, frobenius_schur_phase, frobenius_schur_indicator, twist, fusiontensor
-export sectorscalartype, fusionscalartype, braidingscalartype
+export sectorscalartype, fusionscalartype, braidingscalartype, dimscalartype
 
 # Export methods for fusion trees
 export fusiontrees, braid, permute, transpose

src/auxiliary/dicts.jl

@@ -89,21 +89,12 @@ end
 Base.empty(::SortedVectorDict, ::Type{K}, ::Type{V}) where {K, V} = SortedVectorDict{K, V}()
 Base.empty!(d::SortedVectorDict) = (empty!(d.keys); empty!(d.values); return d)
 
-# _searchsortedfirst(v::Vector, k) = searchsortedfirst(v, k)
-function _searchsortedfirst(v::Vector, k)
-    i = 1
-    @inbounds while i <= length(v) && isless(v[i], k)
-        i += 1
-    end
-    return i
-end
-
 function Base.delete!(d::SortedVectorDict{K}, k) where {K}
     key = convert(K, k)
     if !isequal(k, key)
         return d
     end
-    i = _searchsortedfirst(d.keys, key)
+    i = searchsortedfirst(d.keys, key)
     if i <= length(d) && isequal(d.keys[i], key)
         deleteat!(d.keys, i)
         deleteat!(d.values, i)
@@ -118,15 +109,15 @@ function Base.haskey(d::SortedVectorDict{K}, k) where {K}
     if !isequal(k, key)
         return false
     end
-    i = _searchsortedfirst(d.keys, key)
+    i = searchsortedfirst(d.keys, key)
     return (i <= length(d) && isequal(d.keys[i], key))
 end
 function Base.getindex(d::SortedVectorDict{K}, k) where {K}
     key = convert(K, k)
     if !isequal(k, key)
         throw(KeyError(k))
     end
-    i = _searchsortedfirst(d.keys, key)
+    i = searchsortedfirst(d.keys, key)
     @inbounds if (i <= length(d) && isequal(d.keys[i], key))
         return d.values[i]
     else
@@ -138,7 +129,7 @@ function Base.setindex!(d::SortedVectorDict{K}, v, k) where {K}
     if !isequal(k, key)
         throw(ArgumentError("$k is not a valid key for type $K"))
     end
-    i = _searchsortedfirst(d.keys, key)
+    i = searchsortedfirst(d.keys, key)
     if i <= length(d) && isequal(d.keys[i], key)
         d.values[i] = v
     else
@@ -153,7 +144,7 @@ function Base.get(d::SortedVectorDict{K}, k, default) where {K}
     if !isequal(k, key)
         return default
     end
-    i = _searchsortedfirst(d.keys, key)
+    i = searchsortedfirst(d.keys, key)
     @inbounds begin
         return (i <= length(d) && isequal(d.keys[i], key)) ? d.values[i] : default
     end
@@ -163,7 +154,7 @@ function Base.get(f::Union{Function, Type}, d::SortedVectorDict{K}, k) where {K}
     if !isequal(k, key)
         return f()
     end
-    i = _searchsortedfirst(d.keys, key)
+    i = searchsortedfirst(d.keys, key)
     @inbounds begin
         return (i <= length(d) && isequal(d.keys[i], key)) ? d.values[i] : f()
     end
@@ -186,6 +177,59 @@ function Base.:(==)(d1::SortedVectorDict, d2::SortedVectorDict)
     return true
 end
 
+# merge two SortedVectorDicts of `GradedSpace` dimensions, applying `combine` to keys present in
+# both; keys present in only one dict are kept as is or dropped according to `_keepunmatched(combine)`
+# zero results are dropped since `GradedSpace` never stores an explicit zero dimension
+_keepunmatched(::Any) = true
+_keepunmatched(::typeof(min)) = false # infimum: a missing sector has dimension zero, so min drops it
+
+function _sortedmerge(combine::F, d1::SortedVectorDict{K, V}, d2::SortedVectorDict{K, V}) where {F, K, V <: Integer}
+    keep = _keepunmatched(combine)
+    k1, v1 = d1.keys, d1.values
+    k2, v2 = d2.keys, d2.values
+    n1, n2 = length(k1), length(k2)
+    len = keep ? n1 + n2 : min(n1, n2)
+    ks = Vector{K}(undef, len)
+    vs = Vector{V}(undef, len)
+    i, j, n = 1, 1, 0
+    @inbounds while i <= n1 && j <= n2
+        a, b = k1[i], k2[j]
+        if isless(a, b)
+            keep && (n = _mergestore!(ks, vs, n, a, v1[i]))
+            i += 1
+        elseif isless(b, a)
+            keep && (n = _mergestore!(ks, vs, n, b, v2[j]))
+            j += 1
+        else
+            n = _mergestore!(ks, vs, n, a, combine(v1[i], v2[j]))
+            i += 1
+            j += 1
+        end
+    end
+    if keep
+        @inbounds while i <= n1
+            n = _mergestore!(ks, vs, n, k1[i], v1[i])
+            i += 1
+        end
+        @inbounds while j <= n2
+            n = _mergestore!(ks, vs, n, k2[j], v2[j])
+            j += 1
+        end
+    end
+    resize!(ks, n)
+    resize!(vs, n)
+    return SortedVectorDict{K, V}(ks, vs)
+end
+# write into slot `n + 1` and only advance the length when the value is nonzero
+@inline function _mergestore!(ks, vs, n, k, d)
+    @inbounds ks[n + 1] = k
+    @inbounds vs[n + 1] = d
+    return n + !iszero(d)
+end
+
+Base.mergewith(combine, d1::SortedVectorDict{K, V}, d2::SortedVectorDict{K, V}) where {K, V <: Integer} =
+    _sortedmerge(combine, d1, d2)
+
 """
     Hashed(value, hashfunction = Base.hash, isequal = Base.isequal)
 

src/factorizations/factorizations.jl

@@ -6,9 +6,9 @@ module Factorizations
 export copy_oftype, factorisation_scalartype, one!, truncspace
 
 using ..TensorKit
-using ..TensorKit: AdjointTensorMap, SectorDict, SectorVector,
+using ..TensorKit: AdjointTensorMap, SectorDict, SectorVector, findindex,
     blocktype, foreachblock, one!,
-    similar_diagonal, similarstoragetype
+    similar_diagonal, similarstoragetype, sectorstoragetype
 
 using LinearAlgebra: LinearAlgebra, BlasFloat, Diagonal,
     svdvals, svdvals!, eigen, eigen!,

src/factorizations/pullbacks.jl

@@ -24,16 +24,22 @@ for pullback! in (:qr_null_pullback!, :lq_null_pullback!)
         return Δt
     end
 end
-_notrunc_ind(t) = SectorDict(c => Colon() for c in blocksectors(t))
+function _notrunc_ind(t)
+    I = sectortype(t)
+    return _builddensemap(sectorstoragetype(I), I, blocks(t), Colon) do _, _
+        Colon()
+    end
+end
 
 for pullback! in (:svd_pullback!, :eig_pullback!, :eigh_pullback!)
     @eval function MAK.$pullback!(
             Δt::AbstractTensorMap, t::AbstractTensorMap, F, ΔF, inds = _notrunc_ind(t);
             kwargs...
         )
+        Isec = sectortype(t)
         foreachblock(Δt, t) do c, (Δb, b)
-            haskey(inds, c) || return nothing
-            ind = inds[c]
+            ind = _denseget(inds, Isec, c)
+            isnothing(ind) && return nothing
             Fc = block.(F, Ref(c))
             ΔFc = block.(ΔF, Ref(c))
             MAK.$pullback!(Δb, b, Fc, ΔFc, ind; kwargs...)