Make adjointtensormap generic (#148)

Author: lkdvos

Changelog.md

@@ -6,7 +6,7 @@ Features that are planned to be implemented before the release of v1.0.0, in no
 - [ ] Make `TrivialTensorMap` and `TensorMap` be the same
 - [ ] Simplify `TensorMap` type to hide `rowr` and `colr`
 - [ ] Change block order in `rowr` / `colr` to speed up particular contractions
-- [ ] Make `AdjointTensorMap` generic
+- [x] Make `AdjointTensorMap` generic
 - [ ] Rewrite planar operations in order to be AD-compatible
 - [x] Fix rrules for fermionic tensors
 - [ ] Fix GPU support

src/tensors/adjoint.jl

@@ -1,71 +1,83 @@
 # AdjointTensorMap: lazy adjoint
 #==========================================================#
 """
-    struct AdjointTensorMap{T, S, N₁, N₂, ...} <: AbstractTensorMap{T, S, N₁, N₂}
+    struct AdjointTensorMap{T, S, N₁, N₂, TT<:AbstractTensorMap} <: AbstractTensorMap{T, S, N₁, N₂}
 
 Specific subtype of [`AbstractTensorMap`](@ref) that is a lazy wrapper for representing the
-adjoint of an instance of [`TensorMap`](@ref).
+adjoint of an instance of [`AbstractTensorMap`](@ref).
 """
-struct AdjointTensorMap{T,S,N₁,N₂,I,A,F₁,F₂} <:
+struct AdjointTensorMap{T,S,N₁,N₂,TT<:AbstractTensorMap{T,S,N₂,N₁}} <:
        AbstractTensorMap{T,S,N₁,N₂}
-    parent::TensorMap{T,S,N₂,N₁,I,A,F₂,F₁}
+    parent::TT
 end
 
 #! format: off
-const AdjointTrivialTensorMap{T,S,N₁,N₂,A<:DenseMatrix} =
-    AdjointTensorMap{T,S,N₁,N₂,Trivial,A,Nothing,Nothing}
+const AdjointTrivialTensorMap{T,S,N₁,N₂,TT<:TrivialTensorMap{T,S,N₂,N₁}} =
+    AdjointTensorMap{T,S,N₁,N₂,TT}
 #! format: on
 
 # Constructor: construct from taking adjoint of a tensor
-Base.adjoint(t::TensorMap) = AdjointTensorMap(t)
-Base.adjoint(t::AdjointTensorMap) = t.parent
+Base.adjoint(t::AbstractTensorMap) = AdjointTensorMap(t)
+Base.adjoint(t::AdjointTensorMap) = parent(t)
+
+Base.parent(t::AdjointTensorMap) = t.parent
+parenttype(::Type{<:AdjointTensorMap{T,S,N₁,N₂,TT}}) where {T,S,N₁,N₂,TT} = TT
 
 function Base.similar(t::AdjointTensorMap, ::Type{TorA},
                       P::TensorMapSpace) where {TorA<:MatOrNumber}
     return similar(t', TorA, P)
 end
 
 # Properties
-codomain(t::AdjointTensorMap) = domain(t.parent)
-domain(t::AdjointTensorMap) = codomain(t.parent)
+codomain(t::AdjointTensorMap) = domain(parent(t))
+domain(t::AdjointTensorMap) = codomain(parent(t))
 
-blocksectors(t::AdjointTensorMap) = blocksectors(t.parent)
+blocksectors(t::AdjointTensorMap) = blocksectors(parent(t))
 
-#! format: off
-storagetype(::Type{<:AdjointTrivialTensorMap{T,S,N₁,N₂,A}}) where {T,S,N₁,N₂,A<:DenseMatrix} = A
-storagetype(::Type{<:AdjointTensorMap{T,S,N₁,N₂,I,<:SectorDict{I,A}}}) where {T,S,N₁,N₂,I<:Sector,A<:DenseMatrix} = A
-#! format: on
+storagetype(::Type{TT}) where {TT<:AdjointTensorMap} = storagetype(parenttype(TT))
 
-dim(t::AdjointTensorMap) = dim(t.parent)
+dim(t::AdjointTensorMap) = dim(parent(t))
 
 # Indexing
 #----------
-hasblock(t::AdjointTensorMap, s::Sector) = hasblock(t.parent, s)
-block(t::AdjointTensorMap, s::Sector) = block(t.parent, s)'
-blocks(t::AdjointTensorMap) = (c => b' for (c, b) in blocks(t.parent))
+hasblock(t::AdjointTensorMap, s::Sector) = hasblock(parent(t), s)
+block(t::AdjointTensorMap, s::Sector) = block(parent(t), s)'
+blocks(t::AdjointTensorMap) = (c => b' for (c, b) in blocks(parent(t)))
 
 fusiontrees(::AdjointTrivialTensorMap) = ((nothing, nothing),)
-fusiontrees(t::AdjointTensorMap) = TensorKeyIterator(t.parent.colr, t.parent.rowr)
+function fusiontrees(t::AdjointTensorMap{T,S,N₁,N₂,TT}) where {T,S,N₁,N₂,TT<:TensorMap}
+    return TensorKeyIterator(parent(t).colr, parent(t).rowr)
+end
 
-function Base.getindex(t::AdjointTensorMap{T,S,N₁,N₂,I},
+function Base.getindex(t::AdjointTensorMap{T,S,N₁,N₂,<:TensorMap{T,S,N₁,N₂,I}},
                        f₁::FusionTree{I,N₁}, f₂::FusionTree{I,N₂}) where {T,S,N₁,N₂,I}
     c = f₁.coupled
     @boundscheck begin
         c == f₂.coupled || throw(SectorMismatch())
         hassector(codomain(t), f₁.uncoupled) && hassector(domain(t), f₂.uncoupled)
     end
-    return sreshape((StridedView(t.parent.data[c])[t.parent.rowr[c][f₂],
-                                                   t.parent.colr[c][f₁]])',
+    return sreshape((StridedView(parent(t).data[c])[parent(t).rowr[c][f₂],
+                                                    parent(t).colr[c][f₁]])',
                     (dims(codomain(t), f₁.uncoupled)..., dims(domain(t), f₂.uncoupled)...))
 end
+@propagate_inbounds function Base.getindex(t::AdjointTensorMap{T,S,N₁,N₂},
+                                           f₁::FusionTree{I,N₁},
+                                           f₂::FusionTree{I,N₂}) where {T,S,N₁,N₂,I}
+    d_cod = dims(codomain(t), f₁.uncoupled)
+    d_dom = dims(domain(t), f₂.uncoupled)
+    return sreshape(sreshape(StridedView(parent(t)[f₂, f₁]), (prod(d_dom), prod(d_cod)))',
+                    (d_cod..., d_dom...))
+end
+
 @propagate_inbounds function Base.setindex!(t::AdjointTensorMap{T,S,N₁,N₂,I}, v,
                                             f₁::FusionTree{I,N₁},
                                             f₂::FusionTree{I,N₂}) where {T,S,N₁,N₂,I}
     return copy!(getindex(t, f₁, f₂), v)
 end
 
 @inline function Base.getindex(t::AdjointTrivialTensorMap)
-    return sreshape(StridedView(t.parent.data)', (dims(codomain(t))..., dims(domain(t))...))
+    return sreshape(StridedView(parent(t).data)',
+                    (dims(codomain(t))..., dims(domain(t))...))
 end
 @inline Base.setindex!(t::AdjointTrivialTensorMap, v) = copy!(getindex(t), v)