centralize numin/numout/numind

Author: lkdvos

src/spaces/homspace.jl

@@ -39,18 +39,14 @@ end
 
 spacetype(::Type{<:HomSpace{S}}) where {S} = S
 
-numout(W::HomSpace) = length(codomain(W))
-numin(W::HomSpace) = length(domain(W))
-numind(W::HomSpace) = numin(W) + numout(W)
-
 const TensorSpace{S <: ElementarySpace} = Union{S, ProductSpace{S}}
 const TensorMapSpace{S <: ElementarySpace, N₁, N₂} = HomSpace{
     S, ProductSpace{S, N₁},
     ProductSpace{S, N₂},
 }
+
 numout(::Type{TensorMapSpace{S, N₁, N₂}}) where {S, N₁, N₂} = N₁
 numin(::Type{TensorMapSpace{S, N₁, N₂}}) where {S, N₁, N₂} = N₂
-numind(T::Type{TensorMapSpace{S, N₁, N₂}}) where {S, N₁, N₂} = numout(T) + numin(T)
 
 function Base.getindex(W::TensorMapSpace{<:IndexSpace, N₁, N₂}, i) where {N₁, N₂}
     return i <= N₁ ? codomain(W)[i] : dual(domain(W)[i - N₁])

src/tensors/abstracttensor.jl

@@ -89,70 +89,74 @@ domain(t::AbstractTensorMap) = domain(space(t))
 domain(t::AbstractTensorMap, i) = domain(t)[i]
 source(t::AbstractTensorMap) = domain(t) # categorical terminology
 
-"""
-    numout(::Union{TT,Type{TT}}) where {TT<:AbstractTensorMap} -> Int
+@doc """
+    numout(x) -> Int
+    numout(T::Type) -> Int
 
-Return the number of output spaces of a tensor. This is equivalent to the number of spaces in the codomain of that tensor.
+Return the length of the codomain, i.e. the number of output spaces.
+By default, this is implemented in the type domain.
 
 See also [`numin`](@ref) and [`numind`](@ref).
-"""
+""" numout
+
+numout(x) = numout(typeof(x))
+numout(T::Type) = throw(MethodError(numout, T)) # avoid infinite recursion
 numout(::Type{<:AbstractTensorMap{T, S, N₁}}) where {T, S, N₁} = N₁
 
-"""
-    numin(::Union{TT,Type{TT}}) where {TT<:AbstractTensorMap} -> Int
+@doc """
+    numin(x) -> Int
+    numin(T::Type) -> Int
 
-Return the number of input spaces of a tensor. This is equivalent to the number of spaces in the domain of that tensor.
+Return the length of the domain, i.e. the number of input spaces.
+By default, this is implemented in the type domain.
 
 See also [`numout`](@ref) and [`numind`](@ref).
-"""
+""" numin
+
+numin(x) = numin(typeof(x))
+numin(T::Type) = throw(MethodError(numin, T)) # avoid infinite recursion
 numin(::Type{<:AbstractTensorMap{T, S, N₁, N₂}}) where {T, S, N₁, N₂} = N₂
 
 """
-    numind(::Union{T,Type{T}}) where {T<:AbstractTensorMap} -> Int
+    numind(x) -> Int
+    numind(T::Type) -> Int
+    order(x) = numind(x)
 
-Return the total number of input and output spaces of a tensor. This is equivalent to the
-total number of spaces in the domain and codomain of that tensor.
+Return the total number of input and output spaces, i.e. `numin(x) + numout(x)`.
+Alternatively, the alias `order` can also be used.
 
 See also [`numout`](@ref) and [`numin`](@ref).
 """
-numind(::Type{TT}) where {TT <: AbstractTensorMap} = numin(TT) + numout(TT)
+numind(x) = numin(x) + numout(x)
+
 const order = numind
 
 """
-    codomainind(::Union{TT, Type{TT}}) where {TT <: Union{HomSpace, AbstractTensorMap}} -> Tuple{Int}
+    codomainind(x) -> Tuple{Int}
 
-Return all indices of the codomain of a tensor or tensor space.
+Return all indices of the codomain.
 
 See also [`domainind`](@ref) and [`allind`](@ref).
 """
-function codomainind(::Type{TT}) where {TT <: Union{AbstractTensorMap, HomSpace}}
-    return ntuple(identity, numout(TT))
-end
-codomainind(t::Union{AbstractTensorMap, HomSpace}) = codomainind(typeof(t))
+codomainind(x) = ntuple(identity, numout(x))
 
 """
-    domainind(::Union{TT,Type{TT}}) where {TT<:AbstractTensorMap} -> Tuple{Int}
+    domainind(x) -> Tuple{Int}
 
-Return all indices of the domain of a tensor or tensor space.
+Return all indices of the domain.
 
 See also [`codomainind`](@ref) and [`allind`](@ref).
 """
-function domainind(::Type{TT}) where {TT <: Union{HomSpace, AbstractTensorMap}}
-    return ntuple(n -> numout(TT) + n, numin(TT))
-end
-domainind(t::Union{AbstractTensorMap, HomSpace}) = domainind(typeof(t))
+domainind(x) = ntuple(n -> numout(x) + n, numin(x))
 
 """
-    allind(::Union{TT,Type{TT}}) where {TT<:AbstractTensorMap} -> Tuple{Int}
+    allind(x) -> Tuple{Int}
 
-Return all indices of a tensor or tensor space, i.e. the indices of its domain and codomain.
+Return all indices, i.e. the indices of both domain and codomain.
 
 See also [`codomainind`](@ref) and [`domainind`](@ref).
 """
-function allind(::Type{TT}) where {TT <: Union{HomSpace, AbstractTensorMap}}
-    return ntuple(identity, numind(TT))
-end
-allind(t::Union{HomSpace, AbstractTensorMap}) = allind(typeof(t))
+allind(x) = ntuple(identity, numind(x))
 
 function adjointtensorindex(t, i)
     return ifelse(i <= numout(t), numin(t) + i, i - numout(t))