bring back insertleft/rightunit and removeunit

Author: borisdevos

docs/src/lib/spaces.md

@@ -112,9 +112,9 @@ isisomorphic
 Inserting trivial space factors or removing such factors for `ProductSpace` instances
 can be done with the following methods.
 ```@docs
-insertleftunitspace(::ProductSpace, ::Val{i}) where {i}
-insertrightunitspace(::ProductSpace, ::Val{i}) where {i}
-removeunitspace(::ProductSpace, ::Val{i}) where {i}
+insertleftunit(::ProductSpace, ::Val{i}) where {i}
+insertrightunit(::ProductSpace, ::Val{i}) where {i}
+removeunit(::ProductSpace, ::Val{i}) where {i}
 ```
 
 There are also specific methods for `HomSpace` instances, that are used in determining
@@ -125,7 +125,7 @@ flip(W::HomSpace{S}, I) where {S}
 TensorKit.permute(::HomSpace{S}, ::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
 TensorKit.select(::HomSpace{S}, ::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
 TensorKit.compose(::HomSpace{S}, ::HomSpace{S}) where {S}
-insertleftunitspace(::HomSpace, ::Val{i}) where {i}
-insertrightunitspace(::HomSpace, ::Val{i}) where {i}
-removeunitspace(::HomSpace, ::Val{i}) where {i}
+insertleftunit(::HomSpace, ::Val{i}) where {i}
+insertrightunit(::HomSpace, ::Val{i}) where {i}
+removeunit(::HomSpace, ::Val{i}) where {i}
 ```

docs/src/lib/tensors.md

@@ -184,9 +184,9 @@ transpose(::AbstractTensorMap, ::Index2Tuple)
 repartition(::AbstractTensorMap, ::Int, ::Int)
 flip(t::AbstractTensorMap, I)
 twist(::AbstractTensorMap, ::Int)
-insertleftunitspace(::AbstractTensorMap, ::Val{i}) where {i}
-insertrightunitspace(::AbstractTensorMap, ::Val{i}) where {i}
-removeunitspace(::AbstractTensorMap, ::Val{i}) where {i}
+insertleftunit(::AbstractTensorMap, ::Val{i}) where {i}
+insertrightunit(::AbstractTensorMap, ::Val{i}) where {i}
+removeunit(::AbstractTensorMap, ::Val{i}) where {i}
 ```
 
 ```@docs

src/TensorKit.jl

@@ -37,7 +37,7 @@ export SpaceMismatch, SectorMismatch, IndexError # error types
 # Export general vector space methods
 export space, field, dual, dim, reduceddim, dims, fuse, flip, isdual
 export unitspace, zerospace, oplus, ominus
-export insertleftunitspace, insertrightunitspace, removeunitspace
+export insertleftunit, insertrightunit, removeunit
 
 # partial order for vector spaces
 export infimum, supremum, isisomorphic, ismonomorphic, isepimorphic

src/auxiliary/deprecate.jl

@@ -33,7 +33,7 @@ end
 
 Base.@deprecate EuclideanProduct() EuclideanInnerProduct()
 
-Base.@deprecate insertunit(P::ProductSpace, args...; kwargs...) insertleftunitspace(args...; kwargs...)
+Base.@deprecate insertunit(P::ProductSpace, args...; kwargs...) insertleftunit(args...; kwargs...)
 
 # Factorization structs
 @deprecate QR() MatrixAlgebraKit.LAPACK_HouseholderQR()

src/spaces/homspace.jl

@@ -196,62 +196,62 @@ function compose(W::HomSpace{S}, V::HomSpace{S}) where {S}
 end
 
 """
-    insertleftunitspace(W::HomSpace, i=numind(W) + 1; conj=false, dual=false)
+    insertleftunit(W::HomSpace, i=numind(W) + 1; conj=false, dual=false)
 
 Insert a trivial vector space, isomorphic to the underlying field, at position `i`,
 which can be specified as an `Int` or as `Val(i)` for improved type stability.
 More specifically, adds a left monoidal unit or its dual.
 
-See also [`insertrightunitspace`](@ref insertrightunitspace(::HomSpace, ::Val{i}) where {i}),
-[`removeunitspace`](@ref removeunitspace(::HomSpace, ::Val{i}) where {i}).
+See also [`insertrightunit`](@ref insertrightunit(::HomSpace, ::Val{i}) where {i}),
+[`removeunit`](@ref removeunit(::HomSpace, ::Val{i}) where {i}).
 """
-function insertleftunitspace(
+function insertleftunit(
         W::HomSpace, ::Val{i} = Val(numind(W) + 1);
         conj::Bool = false, dual::Bool = false
     ) where {i}
     if i ≤ numout(W)
-        return insertleftunitspace(codomain(W), Val(i); conj, dual) ← domain(W)
+        return insertleftunit(codomain(W), Val(i); conj, dual) ← domain(W)
     else
-        return codomain(W) ← insertleftunitspace(domain(W), Val(i - numout(W)); conj, dual)
+        return codomain(W) ← insertleftunit(domain(W), Val(i - numout(W)); conj, dual)
     end
 end
 
 """
-    insertrightunitspace(W::HomSpace, i=numind(W); conj=false, dual=false)
+    insertrightunit(W::HomSpace, i=numind(W); conj=false, dual=false)
 
 Insert a trivial vector space, isomorphic to the underlying field, after position `i`,
 which can be specified as an `Int` or as `Val(i)` for improved type stability.
 More specifically, adds a right monoidal unit or its dual.
 
-See also [`insertleftunitspace`](@ref insertleftunitspace(::HomSpace, ::Val{i}) where {i}),
-[`removeunitspace`](@ref removeunitspace(::HomSpace, ::Val{i}) where {i}).
+See also [`insertleftunit`](@ref insertleftunit(::HomSpace, ::Val{i}) where {i}),
+[`removeunit`](@ref removeunit(::HomSpace, ::Val{i}) where {i}).
 """
-function insertrightunitspace(
+function insertrightunit(
         W::HomSpace, ::Val{i} = Val(numind(W));
         conj::Bool = false, dual::Bool = false
     ) where {i}
     if i ≤ numout(W)
-        return insertrightunitspace(codomain(W), Val(i); conj, dual) ← domain(W)
+        return insertrightunit(codomain(W), Val(i); conj, dual) ← domain(W)
     else
-        return codomain(W) ← insertrightunitspace(domain(W), Val(i - numout(W)); conj, dual)
+        return codomain(W) ← insertrightunit(domain(W), Val(i - numout(W)); conj, dual)
     end
 end
 
 """
-    removeunitspace(P::HomSpace, i)
+    removeunit(P::HomSpace, i)
 
 This removes a trivial tensor product factor at position `1 ≤ i ≤ N`, where `i`
 can be specified as an `Int` or as `Val(i)` for improved type stability.
 For this to work, the space at position `i` has to be isomorphic to the field of scalars.
 
-This operation undoes the work of [`insertleftunitspace`](@ref insertleftunitspace(::HomSpace, ::Val{i}) where {i}) 
-and [`insertrightunitspace`](@ref insertrightunitspace(::HomSpace, ::Val{i}) where {i}).
+This operation undoes the work of [`insertleftunit`](@ref insertleftunit(::HomSpace, ::Val{i}) where {i}) 
+and [`insertrightunit`](@ref insertrightunit(::HomSpace, ::Val{i}) where {i}).
 """
-function removeunitspace(P::HomSpace, ::Val{i}) where {i}
+function removeunit(P::HomSpace, ::Val{i}) where {i}
     if i ≤ numout(P)
-        return removeunitspace(codomain(P), Val(i)) ← domain(P)
+        return removeunit(codomain(P), Val(i)) ← domain(P)
     else
-        return codomain(P) ← removeunitspace(domain(P), Val(i - numout(P)))
+        return codomain(P) ← removeunit(domain(P), Val(i - numout(P)))
     end
 end
 

src/spaces/productspace.jl

@@ -249,15 +249,15 @@ fuse(P::ProductSpace{S, 0}) where {S <: ElementarySpace} = unitspace(S)
 fuse(P::ProductSpace{S}) where {S <: ElementarySpace} = fuse(P.spaces...)
 
 """
-    insertleftunitspace(P::ProductSpace, i::Int=length(P) + 1; conj=false, dual=false)
+    insertleftunit(P::ProductSpace, i::Int=length(P) + 1; conj=false, dual=false)
 
 Insert a trivial vector space, isomorphic to the underlying field, at position `i`,
 which can be specified as an `Int` or as `Val(i)` for improved type stability.
 More specifically, adds a left monoidal unit or its dual.
 
-See also [`insertrightunitspace`](@ref insertrightunitspace(::ProductSpace, ::Val{i}) where {i}), [`removeunitspace`](@ref removeunitspace(::ProductSpace, ::Val{i}) where {i}).
+See also [`insertrightunit`](@ref insertrightunit(::ProductSpace, ::Val{i}) where {i}), [`removeunit`](@ref removeunit(::ProductSpace, ::Val{i}) where {i}).
 """
-function insertleftunitspace(P::ProductSpace, ::Val{i}=Val(length(P) + 1);
+function insertleftunit(P::ProductSpace, ::Val{i}=Val(length(P) + 1);
                         conj::Bool=false, dual::Bool=false) where {i}
     N = length(P)
     I = sectortype(P)
@@ -278,15 +278,15 @@ function insertleftunitspace(P::ProductSpace, ::Val{i}=Val(length(P) + 1);
 end
 
 """
-    insertrightunitspace(P::ProductSpace, i=length(P); conj=false, dual=false)
+    insertrightunit(P::ProductSpace, i=length(P); conj=false, dual=false)
 
 Insert a trivial vector space, isomorphic to the underlying field, after position `i`,
 which can be specified as an `Int` or as `Val(i)` for improved type stability.
 More specifically, adds a right monoidal unit or its dual.
 
-See also [`insertleftunitspace`](@ref insertleftunitspace(::ProductSpace, ::Val{i}) where {i}), [`removeunitspace`](@ref removeunitspace(::ProductSpace, ::Val{i}) where {i}).
+See also [`insertleftunit`](@ref insertleftunit(::ProductSpace, ::Val{i}) where {i}), [`removeunit`](@ref removeunit(::ProductSpace, ::Val{i}) where {i}).
 """
-function insertrightunitspace(P::ProductSpace, ::Val{i}=Val(length(P));
+function insertrightunit(P::ProductSpace, ::Val{i}=Val(length(P));
                          conj::Bool=false, dual::Bool=false) where {i}
     N = length(P)
     I = sectortype(P)
@@ -307,16 +307,16 @@ function insertrightunitspace(P::ProductSpace, ::Val{i}=Val(length(P));
 end
 
 """
-    removeunitspace(P::ProductSpace, i::Int)
+    removeunit(P::ProductSpace, i::Int)
 
 This removes a trivial tensor product factor at position `1 ≤ i ≤ N`, where `i`
 can be specified as an `Int` or as `Val(i)` for improved type stability.
 For this to work, that factor has to be isomorphic to the field of scalars.
 
-This operation undoes the work of [`insertleftunitspace`](@ref insertleftunitspace(::ProductSpace, ::Val{i}) where {i}) 
-and [`insertrightunitspace`](@ref insertrightunitspace(::ProductSpace, ::Val{i}) where {i}).
+This operation undoes the work of [`insertleftunit`](@ref insertleftunit(::ProductSpace, ::Val{i}) where {i}) 
+and [`insertrightunit`](@ref insertrightunit(::ProductSpace, ::Val{i}) where {i}).
 """
-function removeunitspace(P::ProductSpace, ::Val{i}) where {i}
+function removeunit(P::ProductSpace, ::Val{i}) where {i}
     1 ≤ i ≤ length(P) || _boundserror(P, i)
     I = sectortype(P)
     if isa(UnitStyle(I), SimpleUnit)

src/spaces/vectorspaces.jl

@@ -219,14 +219,14 @@ end
 
 # In the following, X can be a ProductSpace, a HomSpace or an AbstractTensorMap
 # TODO: should we deprecate those in the future?
-@constprop :aggressive function insertleftunitspace(X, i::Int; kwargs...)
-    return insertleftunitspace(X, Val(i); kwargs...)
+@constprop :aggressive function insertleftunit(X, i::Int; kwargs...)
+    return insertleftunit(X, Val(i); kwargs...)
 end
-@constprop :aggressive function insertrightunitspace(X, i::Int; kwargs...)
-    return insertrightunitspace(X, Val(i); kwargs...)
+@constprop :aggressive function insertrightunit(X, i::Int; kwargs...)
+    return insertrightunit(X, Val(i); kwargs...)
 end
-@constprop :aggressive function removeunitspace(X, i::Int; kwargs...)
-    return removeunitspace(X, Val(i); kwargs...)
+@constprop :aggressive function removeunit(X, i::Int; kwargs...)
+    return removeunit(X, Val(i); kwargs...)
 end
 
 # trait to describe the inner product type of vector spaces

src/tensors/indexmanipulations.jl

@@ -306,7 +306,7 @@ twist(t::AbstractTensorMap, i; inv::Bool = false) = twist!(copy(t), i; inv)
 
 # Methods which change the number of indices, implement using `Val(i)` for type inference
 """
-    insertleftunitspace(tsrc::AbstractTensorMap, i=numind(t) + 1;
+    insertleftunit(tsrc::AbstractTensorMap, i=numind(t) + 1;
                    conj=false, dual=false, copy=false) -> tdst
 
 Insert a trivial vector space, isomorphic to the underlying field, at position `i`,
@@ -315,12 +315,12 @@ More specifically, adds a left monoidal unit or its dual.
 
 If `copy=false`, `tdst` might share data with `tsrc` whenever possible. Otherwise, a copy is always made.
 
-See also [`insertrightunitspace`](@ref insertrightunitspace(::AbstractTensorMap, ::Val{i}) where {i}),
-[`removeunitspace`](@ref removeunitspace(::AbstractTensorMap, ::Val{i}) where {i}).
+See also [`insertrightunit`](@ref insertrightunit(::AbstractTensorMap, ::Val{i}) where {i}),
+[`removeunit`](@ref removeunit(::AbstractTensorMap, ::Val{i}) where {i}).
 """
-function insertleftunitspace(t::AbstractTensorMap, ::Val{i}=Val(numind(t) + 1);
+function insertleftunit(t::AbstractTensorMap, ::Val{i}=Val(numind(t) + 1);
                         copy::Bool=false, conj::Bool=false, dual::Bool=false) where {i}
-    W = insertleftunitspace(space(t), Val(i); conj, dual)
+    W = insertleftunit(space(t), Val(i); conj, dual)
     if t isa TensorMap
         return TensorMap{scalartype(t)}(copy ? Base.copy(t.data) : t.data, W)
     else
@@ -333,7 +333,7 @@ function insertleftunitspace(t::AbstractTensorMap, ::Val{i}=Val(numind(t) + 1);
 end
 
 """
-    insertrightunitspace(tsrc::AbstractTensorMap, i=numind(t);
+    insertrightunit(tsrc::AbstractTensorMap, i=numind(t);
                     conj=false, dual=false, copy=false) -> tdst
 
 Insert a trivial vector space, isomorphic to the underlying field, after position `i`,
@@ -342,12 +342,12 @@ More specifically, adds a right monoidal unit or its dual.
 
 If `copy=false`, `tdst` might share data with `tsrc` whenever possible. Otherwise, a copy is always made.
 
-See also [`insertleftunitspace`](@ref insertleftunitspace(::AbstractTensorMap, ::Val{i}) where {i}),
-[`removeunitspace`](@ref removeunitspace(::AbstractTensorMap, ::Val{i}) where {i}).
+See also [`insertleftunit`](@ref insertleftunit(::AbstractTensorMap, ::Val{i}) where {i}),
+[`removeunit`](@ref removeunit(::AbstractTensorMap, ::Val{i}) where {i}).
 """
-function insertrightunitspace(t::AbstractTensorMap, ::Val{i}=Val(numind(t));
+function insertrightunit(t::AbstractTensorMap, ::Val{i}=Val(numind(t));
                          copy::Bool=false, conj::Bool=false, dual::Bool=false) where {i}
-    W = insertrightunitspace(space(t), Val(i); conj, dual)
+    W = insertrightunit(space(t), Val(i); conj, dual)
     if t isa TensorMap
         return TensorMap{scalartype(t)}(copy ? Base.copy(t.data) : t.data, W)
     else
@@ -360,19 +360,19 @@ function insertrightunitspace(t::AbstractTensorMap, ::Val{i}=Val(numind(t));
 end
 
 """
-    removeunitspace(tsrc::AbstractTensorMap, i; copy=false) -> tdst
+    removeunit(tsrc::AbstractTensorMap, i; copy=false) -> tdst
 
 This removes a trivial tensor product factor at position `1 ≤ i ≤ N`, where `i`
 can be specified as an `Int` or as `Val(i)` for improved type stability.
 For this to work, that factor has to be isomorphic to the field of scalars.
 
 If `copy=false`, `tdst` might share data with `tsrc` whenever possible. Otherwise, a copy is always made.
 
-This operation undoes the work of [`insertleftunitspace`](@ref insertleftunitspace(::AbstractTensorMap, ::Val{i}) where {i}) 
-and [`insertrightunitspace`](@ref insertrightunitspace(::AbstractTensorMap, ::Val{i}) where {i}).
+This operation undoes the work of [`insertleftunit`](@ref insertleftunit(::AbstractTensorMap, ::Val{i}) where {i}) 
+and [`insertrightunit`](@ref insertrightunit(::AbstractTensorMap, ::Val{i}) where {i}).
 """
-function removeunitspace(t::AbstractTensorMap, ::Val{i}; copy::Bool=false) where {i}
-    W = removeunitspace(space(t), Val(i))
+function removeunit(t::AbstractTensorMap, ::Val{i}; copy::Bool=false) where {i}
+    W = removeunit(space(t), Val(i))
     if t isa TensorMap
         return TensorMap{scalartype(t)}(copy ? Base.copy(t.data) : t.data, W)
     else

test/symmetries/spaces.jl

@@ -304,9 +304,9 @@ end
     @test @constinferred(⊗(V1, V2, V3 ⊗ V4)) == P
     @test @constinferred(⊗(V1, V2 ⊗ V3, V4)) == P
     @test V1 * V2 * unitspace(V1) * V3 * V4 ==
-        @constinferred(insertleftunitspace(P, 3)) ==
-        @constinferred(insertrightunitspace(P, 2))
-    @test @constinferred(removeunitspace(V1 * V2 * unitspace(V1)' * V3 * V4, 3)) == P
+        @constinferred(insertleftunit(P, 3)) ==
+        @constinferred(insertrightunit(P, 2))
+    @test @constinferred(removeunit(V1 * V2 * unitspace(V1)' * V3 * V4, 3)) == P
     @test fuse(V1, V2', V3) ≅ V1 ⊗ V2' ⊗ V3
     @test fuse(V1, V2', V3) ≾ V1 ⊗ V2' ⊗ V3
     @test fuse(V1, V2', V3) ≿ V1 ⊗ V2' ⊗ V3
@@ -365,9 +365,9 @@ end
     @test @constinferred(⊗(V1, V2, V3)) == P
     @test @constinferred(adjoint(P)) == dual(P) == V3' ⊗ V2' ⊗ V1'
     @test V1 * V2 * unitspace(V1)' * V3 ==
-        @constinferred(insertleftunitspace(P, 3; conj = true)) ==
-        @constinferred(insertrightunitspace(P, 2; conj = true))
-    @test P == @constinferred(removeunitspace(insertleftunitspace(P, 3), 3))
+        @constinferred(insertleftunit(P, 3; conj = true)) ==
+        @constinferred(insertrightunit(P, 2; conj = true))
+    @test P == @constinferred(removeunit(insertleftunit(P, 3), 3))
     @test fuse(V1, V2', V3) ≅ V1 ⊗ V2' ⊗ V3
     @test fuse(V1, V2', V3) ≾ V1 ⊗ V2' ⊗ V3 ≾ fuse(V1 ⊗ V2' ⊗ V3)
     @test fuse(V1, V2') ⊗ V3 ≾ V1 ⊗ V2' ⊗ V3
@@ -446,22 +446,22 @@ end
         @test permute(W, ((2, 4, 5), (3, 1))) == (V2 ⊗ V4' ⊗ V5' ← V3 ⊗ V1')
         @test (V1 ⊗ V2 ← V1 ⊗ V2) == @constinferred TensorKit.compose(W, W')
         @test (V1 ⊗ V2 ← V3 ⊗ V4 ⊗ V5 ⊗ unitspace(V5)) ==
-            @constinferred(insertleftunitspace(W)) ==
-            @constinferred(insertrightunitspace(W))
-        @test @constinferred(removeunitspace(insertleftunitspace(W), $(numind(W) + 1))) == W
+            @constinferred(insertleftunit(W)) ==
+            @constinferred(insertrightunit(W))
+        @test @constinferred(removeunit(insertleftunit(W), $(numind(W) + 1))) == W
         @test (V1 ⊗ V2 ← V3 ⊗ V4 ⊗ V5 ⊗ unitspace(V5)') ==
-            @constinferred(insertleftunitspace(W; conj = true)) ==
-            @constinferred(insertrightunitspace(W; conj = true))
+            @constinferred(insertleftunit(W; conj = true)) ==
+            @constinferred(insertrightunit(W; conj = true))
         @test (unitspace(V1) ⊗ V1 ⊗ V2 ← V3 ⊗ V4 ⊗ V5) ==
-            @constinferred(insertleftunitspace(W, 1)) ==
-            @constinferred(insertrightunitspace(W, 0))
+            @constinferred(insertleftunit(W, 1)) ==
+            @constinferred(insertrightunit(W, 0))
         @test (V1 ⊗ V2 ⊗ unitspace(V1) ← V3 ⊗ V4 ⊗ V5) ==
-            @constinferred(insertrightunitspace(W, 2))
+            @constinferred(insertrightunit(W, 2))
         @test (V1 ⊗ V2 ← unitspace(V1) ⊗ V3 ⊗ V4 ⊗ V5) ==
-            @constinferred(insertleftunitspace(W, 3))
-        @test @constinferred(removeunitspace(insertleftunitspace(W, 3), 3)) == W
-        @test @constinferred(insertrightunitspace(one(V1) ← V1, 0)) == (unitspace(V1) ← V1)
-        @test_throws BoundsError insertleftunitspace(one(V1) ← V1, 0)
+            @constinferred(insertleftunit(W, 3))
+        @test @constinferred(removeunit(insertleftunit(W, 3), 3)) == W
+        @test @constinferred(insertrightunit(one(V1) ← V1, 0)) == (unitspace(V1) ← V1)
+        @test_throws BoundsError insertleftunit(one(V1) ← V1, 0)
     end
 end