little bit of cleanup

Author: lkdvos

src/tensors/factorizations/factorizations.jl

@@ -9,7 +9,6 @@ export leftorth, leftorth!, rightorth, rightorth!
 export leftnull, leftnull!, rightnull, rightnull!
 export copy_oftype, permutedcopy_oftype, one!
 export TruncationScheme, notrunc, truncbelow, truncerr, truncdim, truncspace, PolarViaSVD
-#export LAPACK_HouseholderQR, LAPACK_HouseholderLQ
 
 using ..TensorKit
 using ..TensorKit: AdjointTensorMap, SectorDict, OFA, blocktype, foreachblock, one!
@@ -60,30 +59,17 @@ end
 const RealOrComplexFloat = Union{AbstractFloat,Complex{<:AbstractFloat}}
 
 #------------------------------#
-# Singular value decomposition #
+# LinearAlgebra overloads
 #------------------------------#
-function LinearAlgebra.svdvals!(t::TensorMap{<:RealOrComplexFloat})
-    return SectorDict(c => LinearAlgebra.svdvals!(b) for (c, b) in blocks(t))
-end
-LinearAlgebra.svdvals!(t::AdjointTensorMap) = svdvals!(adjoint(t))
-
-#--------------------------#
-# Eigenvalue decomposition #
-#--------------------------#
-
-function LinearAlgebra.eigvals!(t::TensorMap{<:RealOrComplexFloat}; kwargs...)
-    return SectorDict(c => complex(LinearAlgebra.eigvals!(b; kwargs...))
-                      for (c, b) in blocks(t))
-end
-function LinearAlgebra.eigvals!(t::AdjointTensorMap{<:RealOrComplexFloat}; kwargs...)
-    return SectorDict(c => conj!(complex(LinearAlgebra.eigvals!(b; kwargs...)))
-                      for (c, b) in blocks(t))
-end
+LinearAlgebra.svdvals(t::AbstractTensorMap) = diagview(svd_vals(t))
+LinearAlgebra.svdvals!(t::AbstractTensorMap) = diagview(svd_vals!(t))
+LinearAlgebra.eigvals(t::AbstractTensorMap) = diagview(eigvals(t))
+LinearAlgebra.eigvals!(t::AbstractTensorMap) = diagview(eigvals!(t))
 
 #--------------------------------------------------#
 # Checks for hermiticity and positive definiteness #
 #--------------------------------------------------#
-function LinearAlgebra.ishermitian(t::TensorMap)
+function LinearAlgebra.ishermitian(t::AbstractTensorMap)
     domain(t) == codomain(t) || return false
     InnerProductStyle(t) === EuclideanInnerProduct() || return false # hermiticity only defined for euclidean
     for (c, b) in blocks(t)
@@ -92,7 +78,7 @@ function LinearAlgebra.ishermitian(t::TensorMap)
     return true
 end
 
-function LinearAlgebra.isposdef!(t::TensorMap)
+function LinearAlgebra.isposdef!(t::AbstractTensorMap)
     domain(t) == codomain(t) ||
         throw(SpaceMismatch("`isposdef` requires domain and codomain to be the same"))
     InnerProductStyle(spacetype(t)) === EuclideanInnerProduct() || return false

src/tensors/linalg.jl

@@ -179,7 +179,6 @@ end
 
 # Diagonal tensors
 # ----------------
-# TODO: consider adding a specialised DiagonalTensorMap type
 function LinearAlgebra.diag(t::AbstractTensorMap)
     return SectorDict(c => LinearAlgebra.diag(b) for (c, b) in blocks(t))
 end

test/runtests.jl

@@ -113,16 +113,16 @@ VSU₂U₁ = (Vect[SU2Irrep ⊠ U1Irrep]((0, 0) => 1, (1 // 2, -1) => 1),
 #     ℂ[SU3Irrep]((0, 0, 0) => 1, (1, 0, 0) => 1, (1, 1, 0) => 1)')
 
 Ti = time()
-#include("fusiontrees.jl")
-#include("spaces.jl")
-#include("tensors.jl")
+include("fusiontrees.jl")
+include("spaces.jl")
+include("tensors.jl")
 include("factorizations.jl")
-#include("diagonal.jl")
-#include("planar.jl")
+include("diagonal.jl")
+include("planar.jl")
 # TODO: remove once we know AD is slow on macOS CI
-#=if !(Sys.isapple() && get(ENV, "CI", "false") == "true") && isempty(VERSION.prerelease)
+if !(Sys.isapple() && get(ENV, "CI", "false") == "true") && isempty(VERSION.prerelease)
     include("ad.jl")
-end=#
+end
 include("bugfixes.jl")
 Tf = time()
 printstyled("Finished all tests in ",