Merge branch 'main' into dev/visualization

Author: ytdHuang

CHANGELOG.md

@@ -7,8 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased](https://github.com/qutip/QuantumToolbox.jl/tree/main)
 
-- Introduce `plot_wigner` function for easy plotting of Wigner functions. ([#86], [#292])
-
+- Improve the construction of `QobjEvo`. ([#338], [#339])
+- Support `Base.zero` and `Base.one` for `AbstractQuantumObject`. ([#342], [#346])
+- Introduce visualization and function `plot_wigner` for easy plotting of Wigner functions. ([#86], [#292], [#347])
 
 ## [v0.23.1]
 Release date: 2024-12-06
@@ -56,3 +57,7 @@ Release date: 2024-11-13
 [#324]: https://github.com/qutip/QuantumToolbox.jl/issues/324
 [#330]: https://github.com/qutip/QuantumToolbox.jl/issues/330
 [#335]: https://github.com/qutip/QuantumToolbox.jl/issues/335
+[#338]: https://github.com/qutip/QuantumToolbox.jl/issues/338
+[#339]: https://github.com/qutip/QuantumToolbox.jl/issues/339
+[#342]: https://github.com/qutip/QuantumToolbox.jl/issues/342
+[#346]: https://github.com/qutip/QuantumToolbox.jl/issues/346

docs/src/resources/api.md

@@ -52,6 +52,8 @@ SciMLOperators.isconstant
 ## [Qobj arithmetic and attributes](@id doc-API:Qobj-arithmetic-and-attributes)
 
 ```@docs
+Base.zero
+Base.one
 Base.conj
 LinearAlgebra.transpose
 LinearAlgebra.adjoint

docs/src/users_guide/QuantumObject/QuantumObject_functions.md

@@ -10,6 +10,8 @@ Here is a table that summarizes all the supported linear algebra functions and a
 
 | **Description** | **Function call** | **Synonyms** |
 |:----------------|:------------------|:-------------|
+| zero-like array | [`zero(Q)`](@ref zero) | - |
+| identity-like matrix | [`one(Q)`](@ref one) | - |
 | conjugate | [`conj(Q)`](@ref conj) | - |
 | transpose | [`transpose(Q)`](@ref transpose) | [`trans(Q)`](@ref trans) |
 | conjugate transposition | [`adjoint(Q)`](@ref adjoint) | [`Q'`](@ref adjoint), [`dag(Q)`](@ref dag) |

src/qobj/arithmetic_and_attributes.jl

@@ -156,6 +156,25 @@ function LinearAlgebra.dot(
     return LinearAlgebra.dot(i.data, A.data, j.data)
 end
 
+@doc raw"""
+    zero(A::AbstractQuantumObject)
+
+Return a similar [`AbstractQuantumObject`](@ref) with `dims` and `type` are same as `A`, but `data` is a zero-array.
+"""
+Base.zero(A::AbstractQuantumObject) = get_typename_wrapper(A)(zero(A.data), A.type, A.dims)
+
+@doc raw"""
+    one(A::AbstractQuantumObject)
+
+Return a similar [`AbstractQuantumObject`](@ref) with `dims` and `type` are same as `A`, but `data` is an identity matrix.
+
+Note that `A` must be [`Operator`](@ref) or [`SuperOperator`](@ref).
+"""
+Base.one(
+    A::AbstractQuantumObject{DT,OpType},
+) where {DT,OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
+    get_typename_wrapper(A)(one(A.data), A.type, A.dims)
+
 @doc raw"""
     conj(A::AbstractQuantumObject)
 

src/qobj/quantum_object_evo.jl

@@ -180,8 +180,19 @@ function QuantumObjectEvolution(
     return QuantumObjectEvolution(data, type, dims)
 end
 
-QuantumObjectEvolution(op::QuantumObject, f::Function; type::Union{Nothing,QuantumObjectType} = nothing) =
-    QuantumObjectEvolution(((op, f),); type = type)
+# this is a extra method if user accidentally specify `QuantumObjectEvolution( (op, func) )` or `QuantumObjectEvolution( ((op, func)) )`
+QuantumObjectEvolution(
+    op_func::Tuple{QuantumObject,Function},
+    α::Union{Nothing,Number} = nothing;
+    type::Union{Nothing,QuantumObjectType} = nothing,
+) = QuantumObjectEvolution((op_func,), α; type = type)
+
+QuantumObjectEvolution(
+    op::QuantumObject,
+    f::Function,
+    α::Union{Nothing,Number} = nothing;
+    type::Union{Nothing,QuantumObjectType} = nothing,
+) = QuantumObjectEvolution(((op, f),), α; type = type)
 
 function QuantumObjectEvolution(
     op::QuantumObject,
@@ -229,13 +240,15 @@ Parse the `op_func_list` and generate the data for the `QuantumObjectEvolution`
     N = length(op_func_list_types)
 
     dims_expr = ()
+    func_methods_expr = ()
     first_op = nothing
     data_expr = :(0)
     qobj_expr_const = :(0)
 
     for i in 1:N
         op_func_type = op_func_list_types[i]
         if op_func_type <: Tuple
+            # check the structure of the tuple
             length(op_func_type.parameters) == 2 || throw(ArgumentError("The tuple must have two elements."))
             op_type = op_func_type.parameters[1]
             func_type = op_func_type.parameters[2]
@@ -248,6 +261,7 @@ Parse the `op_func_list` and generate the data for the `QuantumObjectEvolution`
             op = :(op_func_list[$i][1])
             data_type = op_type.parameters[1]
             dims_expr = (dims_expr..., :($op.dims))
+            func_methods_expr = (func_methods_expr..., :(methods(op_func_list[$i][2], [Any, Real]))) # [Any, Real] means each func must accept 2 arguments
             if i == 1
                 first_op = :($op)
             end
@@ -267,10 +281,20 @@ Parse the `op_func_list` and generate the data for the `QuantumObjectEvolution`
     end
 
     quote
+        # check the dims of the operators
         dims = tuple($(dims_expr...))
-
         allequal(dims) || throw(ArgumentError("The dimensions of the operators must be the same."))
 
+        # check if each func accepts 2 arguments
+        func_methods = tuple($(func_methods_expr...))
+        for f_method in func_methods
+            length(f_method.ms) == 0 && throw(
+                ArgumentError(
+                    "The following function must accept two arguments: `$(f_method.mt.name)(p, t)` with t<:Real",
+                ),
+            )
+        end
+
         data_expr_const = $qobj_expr_const isa Integer ? $qobj_expr_const : _make_SciMLOperator($qobj_expr_const, α)
 
         data_expr = data_expr_const + $data_expr

src/time_evolution/sesolve.jl

@@ -2,7 +2,8 @@ export sesolveProblem, sesolve
 
 _sesolve_make_U_QobjEvo(H::QuantumObjectEvolution{<:MatrixOperator}) =
     QobjEvo(MatrixOperator(-1im * H.data.A), dims = H.dims, type = Operator)
-_sesolve_make_U_QobjEvo(H) = QobjEvo(H, -1im)
+_sesolve_make_U_QobjEvo(H::QuantumObject) = QobjEvo(MatrixOperator(-1im * H.data), dims = H.dims, type = Operator)
+_sesolve_make_U_QobjEvo(H::Union{QuantumObjectEvolution,Tuple}) = QobjEvo(H, -1im)
 
 @doc raw"""
     sesolveProblem(

test/core-test/quantum_objects.jl

@@ -166,6 +166,14 @@
         @test (a2 + 2).data == a2.data + 2 * I
         @test a2 * 2 == 2 * a2
 
+        zero_like = zero(a2)
+        iden_like = one(a3)
+        zero_array = spzeros(ComplexF64, 100, 100)
+        iden_array = sparse(1:100, 1:100, ones(ComplexF64, 100))
+        @test zero_like == Qobj(zero_array, type = a2.type, dims = a2.dims)
+        @test typeof(zero_like.data) == typeof(zero_array)
+        @test iden_like == Qobj(iden_array, type = a3.type, dims = a3.dims)
+        @test typeof(iden_like.data) == typeof(iden_array)
         @test trans(trans(a2)) == a2
         @test trans(a2).data == transpose(a2.data)
         @test adjoint(a2) ≈ trans(conj(a2))

test/core-test/quantum_objects_evo.jl

@@ -74,6 +74,14 @@
         @test (a2 + 2).data == a2.data + 2 * I
         @test a2 * 2 == 2 * a2
 
+        zero_like = zero(a2)
+        iden_like = one(a3)
+        zero_array = NullOperator(100)
+        iden_array = IdentityOperator(100)
+        @test zero_like == QobjEvo(zero_array, type = a2.type, dims = a2.dims)
+        @test typeof(zero_like.data) == typeof(zero_array)
+        @test iden_like == QobjEvo(iden_array, type = a3.type, dims = a3.dims)
+        @test typeof(iden_like.data) == typeof(iden_array)
         @test trans(trans(a2)) == a2
         @test trans(a2).data == transpose(a2.data)
         # @test adjoint(a2) ≈ trans(conj(a2)) # Currently doesn't work
@@ -119,16 +127,24 @@
               "Quantum Object Evo.:   type=SuperOperator   dims=$L_dims   size=$L_size   ishermitian=$L_isherm   isconstant=$L_isconst\n$datastring"
     end
 
-    @testset "Type Inference (QuantumObject)" begin
+    @testset "Type Inference (QobjEvo)" begin
+        N = 4
         for T in [ComplexF32, ComplexF64]
-            N = 4
             a = MatrixOperator(rand(T, N, N))
             @inferred QobjEvo(a)
             for type in [Operator, SuperOperator]
                 @inferred QobjEvo(a, type = type)
             end
         end
 
+        a = destroy(N)
+        coef1(p, t) = exp(-t)
+        coef2(p::Vector, t) = sin(p[1] * t)
+        coef3(p::NamedTuple, t) = cos(p.ω * t)
+        @inferred QobjEvo(a, coef1)
+        @inferred QobjEvo((a', coef2))
+        @inferred QobjEvo((a' * a, (a, coef1), (a', coef2), (a + a', coef3)))
+
         @testset "Math Operation" begin
             a = QobjEvo(destroy(20))
             σx = QobjEvo(sigmax())
@@ -182,6 +198,7 @@
         @test isconstant(H_td) == false
         @test isconstant(QobjEvo(a)) == true
         @test isoper(H_td) == true
+        @test QobjEvo(a, coef1) == QobjEvo((a, coef1))
 
         # SuperOperator
         X = a * a'
@@ -205,7 +222,11 @@
         @test isconstant(L_td) == false
         @test issuper(L_td) == true
 
+        coef_wrong1(t) = nothing
+        coef_wrong2(p, t::ComplexF64) = nothing
         @test_logs (:warn,) (:warn,) liouvillian(H_td * H_td) # warnings from lazy tensor
+        @test_throws ArgumentError QobjEvo(a, coef_wrong1)
+        @test_throws ArgumentError QobjEvo(a, coef_wrong2)
         @test_throws MethodError QobjEvo([[a, coef1], a' * a, [a', coef2]])
         @test_throws ArgumentError H_td(ρvec, p, t)
         @test_throws ArgumentError cache_operator(H_td, ρvec)

test/runtests.jl

@@ -39,7 +39,7 @@ if (GROUP == "All") || (GROUP == "Core")
     using QuantumToolbox
     import QuantumToolbox: position, momentum
     import Random: MersenneTwister
-    import SciMLOperators: MatrixOperator
+    import SciMLOperators: MatrixOperator, NullOperator, IdentityOperator
 
     QuantumToolbox.about()