Add vinds for internal use of inds without Tuple specialization (#335)

* Add `vinds` for internal use of `inds` without `Tuple` specialization

* Fix type-inference in `dim(::Tensor, ::Symbol)`

* Update `dim` test

* Fix type-inference issues in `contract!`

Author: mofeing

src/Numerics.jl

@@ -57,19 +57,19 @@ function contract(a::Tensor, b::Tensor; kwargs...)
 end
 
 function allocate_result(
-    ::typeof(contract), a::Tensor, b::Tensor; fillzero=false, dims=(∩(inds(a), inds(b))), out=nothing
+    ::typeof(contract), a::Tensor, b::Tensor; fillzero=false, dims=(∩(vinds(a), vinds(b))), out=nothing
 )
-    ia = collect(inds(a))
-    ib = collect(inds(b))
+    ia = collect(vinds(a))
+    ib = collect(vinds(b))
     i = ∩(dims, ia, ib)
 
     ic = if isnothing(out)
-        Tuple(setdiff(ia ∪ ib, i isa Base.AbstractVecOrTuple ? i : (i,)))
+        setdiff(ia ∪ ib, i isa Base.AbstractVecOrTuple ? i : [i])
     else
         out
     end
 
-    data = OMEinsum.get_output_array((parent(a), parent(b)), [size(i in ia ? a : b, i) for i in ic]; fillzero)
+    data = OMEinsum.get_output_array((parent(a), parent(b)), Int[size(i in ia ? a : b, i) for i in ic]; fillzero)
     return Tensor(data, ic)
 end
 
@@ -88,12 +88,12 @@ function contract(a::Tensor; kwargs...)
     return contract!(c, a)
 end
 
-function allocate_result(::typeof(contract), a::Tensor; fillzero=false, dims=nonunique(inds(a)), out=nothing)
-    ia = inds(a)
+function allocate_result(::typeof(contract), a::Tensor; fillzero=false, dims=nonunique(vinds(a)), out=nothing)
+    ia = vinds(a)
     i = ∩(dims, ia)
 
     ic::Vector{Symbol} = if isnothing(out)
-        setdiff(ia, i isa Base.AbstractVecOrTuple ? i : (i,))
+        setdiff(ia, i isa Base.AbstractVecOrTuple ? i : [i])
     else
         out
     end
@@ -114,11 +114,11 @@ contract(tensors::Tensor...; kwargs...) = reduce((x, y) -> contract(x, y; kwargs
 Perform a binary tensor contraction operation between `a` and `b` and store the result in `c`.
 """
 function contract!(c::Tensor, a::Tensor, b::Tensor)
-    ixs = (inds(a), inds(b))
-    iy = inds(c)
+    ixs = (vinds(a), vinds(b))
+    iy = vinds(c)
     xs = (parent(a), parent(b))
     y = parent(c)
-    size_dict = merge!(Dict{Symbol,Int}.([inds(a) .=> size(a), inds(b) .=> size(b)])...)
+    size_dict = merge!(Dict{Symbol,Int}.([vinds(a) .=> size(a), vinds(b) .=> size(b)])...)
 
     einsum!(ixs, iy, xs, y, true, false, size_dict)
     return c
@@ -130,9 +130,9 @@ end
 Perform a unary tensor contraction operation on `a` and store the result in `c`.
 """
 function contract!(y::Tensor, x::Tensor)
-    ixs = (inds(x),)
-    iy = inds(y)
-    size_dict = Dict{Symbol,Int}(inds(x) .=> size(x))
+    ixs = (vinds(x),)
+    iy = vinds(y)
+    size_dict = Dict{Symbol,Int}(vinds(x) .=> size(x))
 
     einsum!(ixs, iy, (parent(x),), parent(y), true, false, size_dict)
     return y

src/Tensor.jl

@@ -42,10 +42,12 @@ Return the indices of the tensor in the order of the dimensions.
 """
 inds(t::Tensor) = Tuple(t.inds)
 
+# WARN internal use only because it can mutate `Tensor`
+vinds(t::Tensor) = t.inds
+
 function Base.copy(t::Tensor{T,N,<:SubArray{T,N}}) where {T,N}
     data = copy(t.data)
-    inds = t.inds
-    return Tensor(data, inds)
+    return Tensor(data, vinds(t))
 end
 
 """
@@ -55,7 +57,7 @@ Return a uninitialize tensor of the same size, eltype and [`inds`](@ref) as `ten
 """
 Base.similar(t::Tensor; inds=inds(t)) = Tensor(similar(parent(t)), inds)
 Base.similar(t::Tensor, S::Type; inds=inds(t)) = Tensor(similar(parent(t), S), inds)
-function Base.similar(t::Tensor{T,N}, S::Type, dims::Base.Dims{N}; inds=inds(t)) where {T,N}
+function Base.similar(t::Tensor{T,N}, S::Type, dims::Base.Dims{N}; inds=vinds(t)) where {T,N}
     return Tensor(similar(parent(t), S, dims), inds)
 end
 function Base.similar(t::Tensor, ::Type, dims::Base.Dims{N}; kwargs...) where {N}
@@ -71,7 +73,7 @@ end
 
 Return a tensor of the same size, eltype and [`inds`](@ref) as `tensor` but filled with zeros.
 """
-Base.zero(t::Tensor) = Tensor(zero(parent(t)), inds(t))
+Base.zero(t::Tensor) = Tensor(zero(parent(t)), vinds(t))
 
 function __find_index_permutation(a, b)
     inds_b = collect(Union{Missing,Symbol}, b)
@@ -107,8 +109,8 @@ Base.isequal(a::Tensor{A,0}, b::Tensor{B,0}) where {A,B} = isequal(only(a), only
 Base.isapprox(a::AbstractArray, b::Tensor) = false
 Base.isapprox(a::Tensor, b::AbstractArray) = false
 function Base.isapprox(a::Tensor, b::Tensor; kwargs...)
-    issetequal(inds(a), inds(b)) || return false
-    perm = __find_index_permutation(inds(a), inds(b))
+    issetequal(vinds(a), vinds(b)) || return false
+    perm = __find_index_permutation(vinds(a), vinds(b))
     return all(eachindex(IndexCartesian(), a)) do i
         j = CartesianIndex(Tuple(permute!(collect(Tuple(i)), invperm(perm))))
         isapprox(a[i], b[j]; kwargs...)
@@ -150,7 +152,7 @@ parenttype(::T) where {T<:Tensor} = parenttype(T)
 Return the location of the dimension of `tensor` corresponding to the given index `i`.
 """
 dim(::Tensor, i::Number) = i
-dim(t::Tensor, i::Symbol) = first(findall(==(i), inds(t)))
+dim(t::Tensor, i::Symbol) = findfirst(==(i), vinds(t))
 
 # Iteration interface
 Base.IteratorSize(T::Type{Tensor}) = Iterators.IteratorSize(parenttype(T))
@@ -240,10 +242,10 @@ Return a view of the tensor where the index for dimension `dim` equals `i`.
 
 See also: [`selectdim`](@ref)
 """
-Base.selectdim(t::Tensor, d::Integer, i) = Tensor(selectdim(parent(t), d, i), inds(t))
+Base.selectdim(t::Tensor, d::Integer, i) = Tensor(selectdim(parent(t), d, i), vinds(t))
 function Base.selectdim(t::Tensor, d::Integer, i::Integer)
     data = selectdim(parent(t), d, i)
-    indices = [label for (i, label) in enumerate(inds(t)) if i != d]
+    indices = [label for (i, label) in enumerate(vinds(t)) if i != d]
     return Tensor(data, indices)
 end
 

src/TensorNetwork.jl

@@ -209,7 +209,7 @@ tensors(tn::AbstractTensorNetwork; kwargs...) = tensors(sort_nt(values(kwargs)),
 function tensors(::@NamedTuple{}, tn::AbstractTensorNetwork)
     tn = TensorNetwork(tn)
     get!(tn.sorted_tensors) do
-        sort!(collect(keys(tn.tensormap)); by=sort ∘ collect ∘ inds)
+        sort!(collect(keys(tn.tensormap)); by=sort ∘ collect ∘ vinds)
     end
 end
 

test/unit/Tensor_test.jl

@@ -167,7 +167,7 @@ end
         @test dim(tensor, label) == i
     end
 
-    @test_throws BoundsError dim(tensor, :_)
+    @test isnothing(dim(tensor, :_))
 end
 
 @testset "Broadcasting" begin