uniformize into similarstoragetype

Author: lkdvos

src/tensors/abstracttensor.jl

@@ -45,11 +45,51 @@ end
 Return the type of vector that stores the data of a tensor.
 """ storagetype
 
-similarstoragetype(TT::Type{<:AbstractTensorMap}) = similarstoragetype(TT, scalartype(TT))
+# storage type determination and promotion - hooks for specializing
+# the default implementation tries to leverarge inference and `similar`
+@doc """
+    similarstoragetype(t, [T = scalartype(t)]) -> Type{<:DenseVector{T}}
+    similarstoragetype(TT, [T = scalartype(t)]) -> Type{<:DenseVector{T}}
+    similarstoragetype(A, [T = scalartype(t)]) -> Type{<:DenseVector{T}}
+    similarstoragetype(D, [T = scalartype(t)]) -> Type{<:DenseVector{T}}
 
-function similarstoragetype(TT::Type{<:AbstractTensorMap}, ::Type{T}) where {T}
-    return Core.Compiler.return_type(similar, Tuple{storagetype(TT), Type{T}})
-end
+    similarstoragetype(T::Type{<:Number}) -> Vector{T}
+
+For a given tensor `t`, tensor type `TT <: AbstractTensorMap`, array type `A <: AbstractArray`,
+or sector dictionary type `D <: AbstractDict{<:Sector, <:AbstractMatrix}`, compute an appropriate
+storage type for tensors. Optionally, a different scalar type `T` can be supplied as well.
+
+This function determines the type of newly allocated `TensorMap`s throughout TensorKit.jl.
+It does so by leveraging type inference and calls to `Base.similar` for automatically determining
+appropriate storage types. Additionally this registers the default storage type when only a type
+`T <: Number` is provided, which is `Vector{T}`.
+""" similarstoragetype
+
+# implement in type domain and fill in default value
+@inline similarstoragetype(t, ::Type{T} = scalartype(t)) where {T <: Number} =
+    similarstoragetype(typeof(t), T)
+
+# implement on tensors
+similarstoragetype(::Type{TT}, ::Type{T}) where {TT <: AbstractTensorMap, T <: Number} =
+    similarstoragetype(storagetype(TT), T)
+
+# implement on arrays
+similarstoragetype(::Type{A}, ::Type{T}) where {T <: Number, A <: DenseVector{T}} = A
+Base.@assume_effects :foldable similarstoragetype(::Type{A}, ::Type{T}) where {A <: AbstractArray, T <: Number} =
+    Core.Compiler.return_type(similar, Tuple{A, Type{T}, Int})
+
+# implement on sectordicts - intercept scalartype defaults!
+similarstoragetype(d::D, ::Type{T} = scalartype(valtype(d))) where {D <: AbstractDict{<:Sector}, T <: Number} =
+    similarstoragetype(typeof(d), T)
+similarstoragetype(::Type{D}, ::Type{T} = scalartype(valtype(D))) where {D <: AbstractDict{<:Sector}, T <: Number} =
+    similarstoragetype(valtype(D), T)
+
+# default storage type for numbers
+similarstoragetype(::Type{T}) where {T <: Number} = Vector{T}
+
+# avoid infinite recursion
+similarstoragetype(X::Type, Y::Type) =
+    throw(ArgumentError("Cannot determine a storagetype for tensor / array type `$X` and/or scalar type `$Y`"))
 
 # tensor characteristics: space and index information
 #-----------------------------------------------------
@@ -175,7 +215,6 @@ end
 InnerProductStyle(t::AbstractTensorMap) = InnerProductStyle(typeof(t))
 storagetype(t::AbstractTensorMap) = storagetype(typeof(t))
 blocktype(t::AbstractTensorMap) = blocktype(typeof(t))
-similarstoragetype(t::AbstractTensorMap, T = scalartype(t)) = similarstoragetype(typeof(t), T)
 
 numout(t::AbstractTensorMap) = numout(typeof(t))
 numin(t::AbstractTensorMap) = numin(typeof(t))

src/tensors/tensor.jl

@@ -48,22 +48,11 @@ i.e. a tensor map with only a non-trivial output space.
 """
 const Tensor{T, S, N, A} = TensorMap{T, S, N, 0, A}
 
-function tensormaptype(S::Type{<:IndexSpace}, N₁, N₂, TorA::Type)
-    A = _tensormap_storagetype(TorA)
-    A <: DenseVector || throw(ArgumentError("Cannot determine a valid storage type from argument $TorA"))
+function tensormaptype(::Type{S}, N₁, N₂, ::Type{TorA}) where {S <: IndexSpace, TorA}
+    A = similarstoragetype(TorA)
     return TensorMap{scalartype(A), S, N₁, N₂, A}
 end
 
-# hook for mapping input types to storage types -- to be implemented in extensions
-_tensormap_storagetype(::Type{A}) where {A <: DenseVector{<:Number}} = A
-_tensormap_storagetype(::Type{A}) where {A <: Array} = _tensormap_storagetype(scalartype(A))
-_tensormap_storagetype(::Type{T}) where {T <: Number} = Vector{T}
-function _tensormap_storagetype(::Type{A}) where {A <: AbstractArray}
-    PA = parenttype(A)
-    PA === A && throw(MethodError(_tensormap_storagetype, A)) # avoid infinite recursion
-    return _tensormap_storagetype(PA)
-end
-
 # Basic methods for characterising a tensor:
 #--------------------------------------------
 space(t::TensorMap) = t.space
@@ -201,9 +190,8 @@ cases.
     the specified symmetry structure, up to a tolerance `tol`.
 """
 function TensorMap(data::AbstractArray, V::TensorMapSpace; tol = sqrt(eps(real(float(eltype(data))))))
-    T = eltype(data)
-    A = _tensormap_storagetype(typeof(data))
-    return TensorMapWithStorage{T, A}(data, V; tol)
+    A = similarstoragetype(data)
+    return TensorMapWithStorage{scalartype(A), A}(data, V; tol)
 end
 TensorMap(data::AbstractArray, codom::TensorSpace, dom::TensorSpace; kwargs...) =
     TensorMap(data, codom ← dom; kwargs...)
@@ -259,7 +247,7 @@ Construct a `TensorMap` by explicitly specifying its block data.
 - `domain::ProductSpace{S, N₂}`: the domain as a `ProductSpace` of `N₂` spaces of type `S <: ElementarySpace`.
 """
 function TensorMap(data::_BlockData, V::TensorMapSpace)
-    A = _tensormap_storagetype(valtype(data))
+    A = similarstoragetype(data)
     return TensorMapWithStorage{scalartype(A), A}(data, V)
 end
 TensorMap(data::_BlockData, codom::TensorSpace, dom::TensorSpace) =