Make states stable

Author: albertomercurio

docs/src/users_guide/QuantumObject/QuantumObject.md

@@ -45,8 +45,8 @@ Qobj(M, dims = (2, 2))  # dims as Tuple (recommended)
 Qobj(M, dims = SVector(2, 2)) # dims as StaticArrays.SVector (recommended)
 ```
 
-> [!IMPORTANT]
-> Please note that here we put the `dims` as a tuple `(2, 2)`. Although it supports also `Vector` type (`dims = [2, 2]`), it is recommended to use `Tuple` or `SVector` from [`StaticArrays.jl`](https://github.com/JuliaArrays/StaticArrays.jl) to improve performance. For a brief explanation on the impact of the type of `dims`, see the Section [The Importance of Type-Stability](@ref doc:Type-Stability).
+!!! warning "Beware of type-stability!"
+    Please note that here we put the `dims` as a tuple `(2, 2)`. Although it supports also `Vector` type (`dims = [2, 2]`), it is recommended to use `Tuple` or `SVector` from [`StaticArrays.jl`](https://github.com/JuliaArrays/StaticArrays.jl) to improve performance. For a brief explanation on the impact of the type of `dims`, see the Section [The Importance of Type-Stability](@ref doc:Type-Stability).
 
 ```@example Qobj
 Qobj(rand(4, 4), type = SuperOperator)

src/qobj/states.jl

@@ -89,22 +89,22 @@ function rand_ket(dimensions::Union{AbstractVector{Int},Tuple})
 end
 
 @doc raw"""
-    fock_dm(N::Int, pos::Int=0; dims::Union{Int,AbstractVector{Int},Tuple}=N, sparse::Union{Bool,Val}=Val(false))
+    fock_dm(N::Int, j::Int=0; dims::Union{Int,AbstractVector{Int},Tuple}=N, sparse::Union{Bool,Val}=Val(false))
 
 Density matrix representation of a Fock state.
 
 Constructed via outer product of [`fock`](@ref).
 
 !!! warning "Beware of type-stability!"
-    If you want to keep type stability, it is recommended to use `fock_dm(N, pos, dims=dims, sparse=Val(sparse))` instead of `fock_dm(N, pos, dims=dims, sparse=sparse)`. Consider also to use `dims` as a `Tuple` or `SVector` instead of `Vector`. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
+    If you want to keep type stability, it is recommended to use `fock_dm(N, j, dims=dims, sparse=Val(sparse))` instead of `fock_dm(N, j, dims=dims, sparse=sparse)`. Consider also to use `dims` as a `Tuple` or `SVector` instead of `Vector`. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
 """
 function fock_dm(
     N::Int,
-    pos::Int = 0;
+    j::Int = 0;
     dims::Union{Int,AbstractVector{Int},Tuple} = N,
     sparse::Union{Bool,Val} = Val(false),
 )
-    ψ = fock(N, pos; dims = dims, sparse = sparse)
+    ψ = fock(N, j; dims = dims, sparse = sparse)
     return ket2dm(ψ)
 end
 
@@ -243,7 +243,7 @@ function spin_coherent(j::Real, θ::Real, ϕ::Real)
 end
 
 @doc raw"""
-    bell_state(x::Int, z::Int)
+    bell_state(x::Union{Int}, z::Union{Int})
 
 Return the [Bell state](https://en.wikipedia.org/wiki/Bell_state) depending on the arguments `(x, z)`:
 - `(0, 0)`: ``| \Phi^+ \rangle = ( |00\rangle + |11\rangle ) / \sqrt{2}``
@@ -263,7 +263,18 @@ Quantum Object:   type=Ket   dims=[2, 2]   size=(4,)
                 0.0 + 0.0im
                 0.0 + 0.0im
  0.7071067811865475 + 0.0im
+
+julia> bell_state(Val(1), Val(0))
+Quantum Object:   type=Ket   dims=[2, 2]   size=(4,)
+4-element Vector{ComplexF64}:
+                0.0 + 0.0im
+ 0.7071067811865475 + 0.0im
+ 0.7071067811865475 + 0.0im
+                0.0 + 0.0im
 ```
+
+!!! warning "Beware of type-stability!"
+    If you want to keep type stability, it is recommended to use `bell_state(Val(x), Val(z))` instead of `bell_state(x, z)`. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) for more details.
 """
 bell_state(x::Int, z::Int) = bell_state(Val(x), Val(z))
 bell_state(::Val{0}, ::Val{0}) = QuantumObject(ComplexF64[1, 0, 0, 1] / sqrt(2), Ket, (2, 2))

test/quantum_objects.jl

@@ -507,14 +507,12 @@
         @test ρ2.data ≈ ρ2_ptr.data atol = 1e-10
 
         @testset "Type Inference (ptrace)" begin
-            if VERSION >= v"1.10"
-                @inferred ptrace(ρ, 1)
-                @inferred ptrace(ρ, 2)
-                @inferred ptrace(ψ_d, 1)
-                @inferred ptrace(ψ_d, 2)
-                @inferred ptrace(ψ, 1)
-                @inferred ptrace(ψ, 2)
-            end
+            @inferred ptrace(ρ, 1)
+            @inferred ptrace(ρ, 2)
+            @inferred ptrace(ψ_d, 1)
+            @inferred ptrace(ψ_d, 2)
+            @inferred ptrace(ψ, 1)
+            @inferred ptrace(ψ, 2)
         end
     end
 

test/states_and_operators.jl

@@ -346,48 +346,89 @@
         @test_throws DimensionMismatch sprepost(A_wrong1, A_wrong3)
     end
 
+    @testset "Type Inference (States)" begin
+        @inferred zero_ket(4)
+        @inferred zero_ket((2, 2))
+
+        @inferred fock(4, 1, dims = (2, 2), sparse = Val(true))
+        @inferred fock(4, 1, dims = (2, 2), sparse = Val(false))
+        @inferred basis(4, 1, dims = (2, 2))
+
+        @inferred coherent(5, 0.25im)
+
+        @inferred rand_ket(10)
+        @inferred rand_ket((2, 5))
+
+        @inferred fock_dm(4; dims = (2, 2), sparse = Val(true))
+        @inferred fock_dm(4; dims = (2, 2), sparse = Val(false))
+
+        @inferred coherent_dm(5, 0.25im)
+
+        @inferred thermal_dm(10, 0.123)
+        @inferred thermal_dm(10, 0.123; sparse = Val(true))
+
+        @inferred maximally_mixed_dm(4)
+        @inferred maximally_mixed_dm((2, 2))
+
+        @inferred rand_dm((2, 2))
+        @inferred rand_dm(10, rank = 5)
+
+        @inferred spin_state(3.5, 1.5)
+        @inferred spin_coherent(0.5, π, 2π)
+
+        @inferred bell_state(Val(0), Val(0))
+        @inferred bell_state(Val(0), Val(1))
+        @inferred bell_state(Val(1), Val(0))
+        @inferred bell_state(Val(1), Val(1))
+        @inferred singlet_state()
+        @inferred triplet_states()
+        @inferred w_state(Val(2))
+
+        @inferred ghz_state(Val(2))
+        @inferred ghz_state(Val(3))
+        @inferred ghz_state(Val(3); d = 3)
+    end
+
     @testset "Type Inference (Operators)" begin
-        if VERSION >= v"1.10"
-            @inferred rand_unitary(10, Val(:haar))
-            @inferred rand_unitary(10, Val(:exp))
-
-            a = destroy(20)
-            a_d = create(20)
-            @inferred commutator(a, a_d)
-            
-            @inferred destroy(20)
-            @inferred create(20)
-            @inferred num(20)
-            @inferred displace(20, 0.5 + 0.5im)
-            @inferred squeeze(20, 0.5 + 0.5im)
-            @inferred position(20)
-            @inferred momentum(20)
-
-            @inferred phase(20, 0.5)
-
-            @inferred jmat(2.5)
-            @inferred jmat(2.5, Val(:x))
-            @inferred jmat(2.5, Val(:y))
-            @inferred jmat(2.5, Val(:z))
-
-            @inferred sigmap()
-            @inferred sigmam()
-            @inferred sigmax()
-            @inferred sigmay()
-            @inferred sigmaz()
-
-            @inferred eye(20)
-
-            @inferred fdestroy(Val(10), 4)
-            @inferred fcreate(Val(10), 4)
-
-            @inferred projection(20, 5, 3)
-
-            @inferred tunneling(20, 1, sparse=Val(false))
-            @inferred tunneling(20, 1, sparse=Val(true))
-
-            @inferred qft(20)
-            @inferred qft((2, 10))
-        end
+        @inferred rand_unitary(10, Val(:haar))
+        @inferred rand_unitary(10, Val(:exp))
+
+        a = destroy(20)
+        a_d = create(20)
+        @inferred commutator(a, a_d)
+        
+        @inferred destroy(20)
+        @inferred create(20)
+        @inferred num(20)
+        @inferred displace(20, 0.5 + 0.5im)
+        @inferred squeeze(20, 0.5 + 0.5im)
+        @inferred position(20)
+        @inferred momentum(20)
+
+        @inferred phase(20, 0.5)
+
+        @inferred jmat(2.5)
+        @inferred jmat(2.5, Val(:x))
+        @inferred jmat(2.5, Val(:y))
+        @inferred jmat(2.5, Val(:z))
+
+        @inferred sigmap()
+        @inferred sigmam()
+        @inferred sigmax()
+        @inferred sigmay()
+        @inferred sigmaz()
+
+        @inferred eye(20)
+
+        @inferred fdestroy(Val(10), 4)
+        @inferred fcreate(Val(10), 4)
+
+        @inferred projection(20, 5, 3)
+
+        @inferred tunneling(20, 1, sparse=Val(false))
+        @inferred tunneling(20, 1, sparse=Val(true))
+
+        @inferred qft(20)
+        @inferred qft((2, 10))
     end
 end