cat->join

src/register.jl

@@ -228,23 +228,23 @@ See also [`rank3`](@ref).
 rank3(r::ArrayRegOrAdjointArrayReg{B}) where B = reshape(state(r), size(state(r), 1), :, B)
 
 """
-    cat(regs...)
+    join(regs...)
 
 concat a list of registers `regs` to a larger register, each register should
 have the same batch size. See also [`repeat`](@ref).
 """
-Base.cat(rs::ArrayReg{B}...) where B = _cat(cat_datatype(reverse(rs)...), reverse(rs)...)
-Base.cat(r::ArrayReg) = r
+Base.join(rs::ArrayReg{B}...) where B = _join(join_datatype(reverse(rs)...), reverse(rs)...)
+Base.join(r::ArrayReg) = r
 
-function _cat(::Type{T}, rs::ArrayReg{B}...) where {T, B}
+function _join(::Type{T}, rs::ArrayReg{B}...) where {T, B}
     state = batched_kron(rank3.(rs)...)
     return ArrayReg{B}(reshape(state, size(state, 1), :))
 end
 
-cat_datatype(r::ArrayReg{B, T}, rs::ArrayReg{B}...) where {B, T} = cat_datatype(T, r, rs...)
-cat_datatype(::Type{T}, r::ArrayReg{B, T1}, rs::ArrayReg{B}...) where {T, T1, B} =
-    cat_datatype(promote_type(T, T1), rs...)
-cat_datatype(::Type{T}) where T = T
+join_datatype(r::ArrayReg{B, T}, rs::ArrayReg{B}...) where {B, T} = join_datatype(T, r, rs...)
+join_datatype(::Type{T}, r::ArrayReg{B, T1}, rs::ArrayReg{B}...) where {T, T1, B} =
+    join_datatype(promote_type(T, T1), rs...)
+join_datatype(::Type{T}) where T = T
 
 
 # initialization methods

test/density_matrix.jl

@@ -9,8 +9,8 @@ using Test, YaoArrayRegister
     @test fidelity(reg2, reg2) ≈ [1,1,1]
 
     # mix
-    reg4 = cat(reg, reg)
-    reg5 = cat(reg_, reg_)
+    reg4 = join(reg, reg)
+    reg5 = join(reg_, reg_)
     focus!(reg4, 1:3)
     focus!(reg5, 1:3)
     @test isapprox(fidelity(reg, reg_)[], fidelity(reg4, reg5)[], atol=1e-5)
@@ -30,8 +30,8 @@ end
     @test isapprox(tracedist(dm2, dm2), tracedist(reg2, reg2), atol=1e-5)
 
     # mix
-    reg4 = cat(reg, reg)
-    reg5 = cat(reg_, reg_)
+    reg4 = join(reg, reg)
+    reg5 = join(reg_, reg_)
     focus!(reg4, 1:3)
     focus!(reg5, 1:3)
     dm4 = reg4 |> density_matrix

test/focus.jl

@@ -59,6 +59,6 @@ end
 end
 
 @testset "partial trace" begin
-    r = cat(zero_state(1), ArrayReg(bit"011"))
+    r = join(zero_state(1), ArrayReg(bit"011"))
     partial_tr(r, 1) ≈ ArrayReg(bit"011")
 end

test/register.jl

@@ -83,9 +83,9 @@ end
     @testset "test addbits!" begin
         @test addbits!(zero_state(3), 3) == zero_state(6)
         r = rand_state(3; nbatch=2)
-        @test addbits!(copy(r), 2) ≈ cat(r, zero_state(2; nbatch=2))
+        @test addbits!(copy(r), 2) ≈ join(r, zero_state(2; nbatch=2))
         r = rand_state(3; nbatch=1)
-        @test addbits!(copy(r), 2) ≈ cat(r, zero_state(2; nbatch=1))
+        @test addbits!(copy(r), 2) ≈ join(r, zero_state(2; nbatch=1))
     end
 end
 
@@ -101,18 +101,18 @@ end
 end
 
 # TODO: test concat multiple registers
-@testset "test cat" begin
+@testset "test join" begin
     r1 = rand_state(6)
     r2 = rand_state(6)
-    r3 = cat(r1, r2)
-    r4 = cat(focus!(copy(r1), 1:3), focus!(copy(r2), 1:2))
+    r3 = join(r1, r2)
+    r4 = join(focus!(copy(r1), 1:3), focus!(copy(r2), 1:2))
     @test r4 |> relaxedvec ≈ focus!(copy(r3), [1,2,3,7,8,4,5,6,9,10,11,12]) |> relaxedvec
     reg5 = focus!(repeat(r1, 3), 1:3)
     reg6 = focus!(repeat(r2, 3), 1:2)
-    @test (cat(reg5, reg6) |> relaxedvec)[:,1] ≈ r4 |> relaxedvec
+    @test (join(reg5, reg6) |> relaxedvec)[:,1] ≈ r4 |> relaxedvec
 
     # manual trace
-    r = cat(zero_state(1), ArrayReg(bit"011"))
+    r = join(zero_state(1), ArrayReg(bit"011"))
     focus!(r, 2:4)
     @test sum(r.state, dims=2) ≈ ArrayReg(bit"011").state
 end