Add DiagonalTensorMap constructors and converters (#212)

* Update README upgrade guide; add TensorMap to DiagonalTensorMap conversion

* Minor update to TensorMap to DiagonalTensorMap conversion

* Add suggested changes

* Refactoring

* implement changes as discussed

* restore tensor.jl

* Restore README.md

* Restore README.md 2

* use `isdiag(::AbstractTensorMap)`

Co-authored-by: Lukas Devos <[email protected]>

* Fix diagonal.jl

* remove ambiguity in convert methods

---------

Co-authored-by: Jutho <[email protected]>
Co-authored-by: Lukas Devos <[email protected]>

Author: 3 people

README.md

@@ -136,7 +136,7 @@ end
 TensorKit.jl is a package that provides types and methods to represent and manipulate
 tensors with symmetries. The emphasis is on the structure and functionality needed to build
 tensor network algorithms for the simulation of quantum many-body systems. Such tensors are
-typically invariant under a symmetry group which acts via specific representions on each of
+typically invariant under a symmetry group which acts via specific representations on each of
 the indices of the tensor. TensorKit.jl provides the functionality for constructing such
 tensors and performing typical operations such as tensor contractions and decompositions,
 thereby preserving the symmetries and exploiting them for optimal performance.

src/tensors/diagonal.jl

@@ -52,6 +52,20 @@ function DiagonalTensorMap(data::DenseVector{T}, V::IndexSpace) where {T}
     return DiagonalTensorMap{T}(data, V)
 end
 
+function DiagonalTensorMap(t::AbstractTensorMap{T,S,1,1}) where {T,S}
+    isa(t, DiagonalTensorMap) && return t
+    domain(t) == codomain(t) ||
+        throw(SpaceMismatch("DiagonalTensorMap requires equal domain and codomain"))
+    A = storagetype(t)
+    d = DiagonalTensorMap{T,S,A}(undef, space(t, 1))
+    for (c, b) in blocks(d)
+        bt = block(t, c)
+        # TODO: rewrite in terms of `diagview` from MatrixAlgebraKit.jl
+        copy!(b.diag, view(bt, LinearAlgebra.diagind(bt)))
+    end
+    return d
+end
+
 # TODO: more constructors needed?
 
 # Special case adjoint:
@@ -73,12 +87,17 @@ end
 TensorMap(d::DiagonalTensorMap) = copy!(similar(d), d)
 Base.convert(::Type{TensorMap}, d::DiagonalTensorMap) = TensorMap(d)
 
-function Base.convert(::Type{DiagonalTensorMap{T,S,A}},
-                      d::DiagonalTensorMap{T,S,A}) where {T,S,A}
-    return d
-end
 function Base.convert(D::Type{<:DiagonalTensorMap}, d::DiagonalTensorMap)
-    return DiagonalTensorMap(convert(storagetype(D), d.data), d.domain)
+    return (d isa D) ? d : DiagonalTensorMap(convert(storagetype(D), d.data), d.domain)
+end
+Base.convert(::Type{DiagonalTensorMap}, t::DiagonalTensorMap) = t
+function Base.convert(::Type{DiagonalTensorMap}, t::AbstractTensorMap)
+    LinearAlgebra.isdiag(t) ||
+        throw(ArgumentError("DiagonalTensorMap requires input tensor that is diagonal"))
+    return DiagonalTensorMap(t)
+end
+function Base.convert(::Type{DiagonalTensorMap}, d::Dict{Symbol,Any})
+    return convert(DiagonalTensorMap, convert(TensorMap, d))
 end
 
 # Complex, real and imaginary parts

test/diagonal.jl

@@ -89,9 +89,14 @@ diagspacelist = ((ℂ^4)', ℂ[Z2Irrep](0 => 2, 1 => 3),
     @timedtestset "Tensor conversion" begin
         t = @constinferred DiagonalTensorMap(undef, V)
         rand!(t.data)
+        # element type conversion
         tc = complex(t)
         @test convert(typeof(tc), t) == tc
         @test typeof(convert(typeof(tc), t)) == typeof(tc)
+        # to and from generic TensorMap
+        td = DiagonalTensorMap(TensorMap(t))
+        @test t == td
+        @test typeof(td) == typeof(t)
     end
     I = sectortype(V)
     if BraidingStyle(I) isa SymmetricBraiding