Apply Yi-Te comments

Author: albertomercurio

src/QuantumToolbox.jl

@@ -34,7 +34,7 @@ import SciMLBase:
     DiscreteCallback
 import StochasticDiffEq: StochasticDiffEqAlgorithm, SRA1
 import SciMLOperators:
-    AbstractSciMLOperator, MatrixOperator, ScalarOperator, cache_operator, update_coefficients!, concretize
+    AbstractSciMLOperator, MatrixOperator, ScalarOperator, cache_operator, update_coefficients!, concretize, isconstant
 import LinearSolve: LinearProblem, SciMLLinearSolveAlgorithm, KrylovJL_MINRES, KrylovJL_GMRES
 import DiffEqBase: get_tstops
 import DiffEqCallbacks: PeriodicCallback, PresetTimeCallback, TerminateSteadyState
@@ -64,6 +64,7 @@ include("progress_bar.jl")
 include("linear_maps.jl")
 
 # Quantum Object
+include("qobj/quantum_object_base.jl")
 include("qobj/quantum_object.jl")
 include("qobj/quantum_object_evo.jl")
 include("qobj/boolean_functions.jl")

src/qobj/arithmetic_and_attributes.jl

@@ -38,10 +38,8 @@ for op in (:(+), :(-), :(*))
     @eval begin
         function LinearAlgebra.$op(A::AbstractQuantumObject, B::AbstractQuantumObject)
             check_dims(A, B)
-            if A isa QuantumObjectEvolution || B isa QuantumObjectEvolution
-                return QuantumObjectEvolution($(op)(A.data, B.data), A.type, A.dims)
-            end
-            return QuantumObject($(op)(A.data, B.data), A.type, A.dims)
+            QType = promote_type(A, B)
+            return QType($(op)(A.data, B.data), A.type, A.dims)
         end
         LinearAlgebra.$op(A::AbstractQuantumObject) = get_typename_wrapper(A)($(op)(A.data), A.type, A.dims)
 
@@ -132,7 +130,7 @@ end
 @doc raw"""
     dot(i::QuantumObject, A::AbstractQuantumObject j::QuantumObject)
 
-Compute the generalized dot product `dot(i, A*j)` between three [`AbstractQuantumObject`](@ref): ``\langle i | \hat{A} | j \rangle``
+Compute the generalized dot product `dot(i, A*j)` between a [`AbstractQuantumObject`](@ref) and two [`QuantumObject`](@ref) (`i` and `j`), namely ``\langle i | \hat{A} | j \rangle``.
 
 Supports the following inputs:
 - `A` is in the type of [`Operator`](@ref), with `i` and `j` are both [`Ket`](@ref).

src/qobj/boolean_functions.jl

@@ -3,7 +3,7 @@ All boolean functions for checking the data or type in `QuantumObject`
 =#
 
 export isket, isbra, isoper, isoperbra, isoperket, issuper
-export isunitary
+export isunitary, isconstant
 
 @doc raw"""
     isbra(A)
@@ -89,3 +89,10 @@ Note that all the keyword arguments will be passed to `Base.isapprox`.
 """
 isunitary(U::QuantumObject{<:AbstractArray{T}}; kwargs...) where {T} =
     isoper(U) ? isapprox(U.data * U.data', I(size(U, 1)); kwargs...) : false
+
+@doc raw"""
+    isconstant(A::AbstractQuantumObject)
+
+Test whether the [`AbstractQuantumObject`](@ref) `A` is constant in time. For a [`QuantumObject`](@ref), this function returns `false`, while for a [`QuantumObjectEvolution`](@ref), this function returns `true` if the operator is contant in time.
+"""
+isconstant(A::AbstractQuantumObject) = isconstant(A.data)

src/qobj/functions.jl

@@ -193,10 +193,8 @@ function LinearAlgebra.kron(
     A::AbstractQuantumObject{DT1,OpType},
     B::AbstractQuantumObject{DT2,OpType},
 ) where {DT1,DT2,OpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject}}
-    if A isa QuantumObjectEvolution || B isa QuantumObjectEvolution
-        return QuantumObjectEvolution(kron(A.data, B.data), A.type, vcat(A.dims, B.dims))
-    end
-    return QuantumObject(kron(A.data, B.data), A.type, vcat(A.dims, B.dims))
+    QType = promote_type(A, B)
+    return QType(kron(A.data, B.data), A.type, vcat(A.dims, B.dims))
 end
 LinearAlgebra.kron(A::AbstractQuantumObject) = A
 function LinearAlgebra.kron(A::Vector{<:AbstractQuantumObject})

src/qobj/quantum_object.jl

@@ -7,114 +7,7 @@ Also support for fundamental functions in Julia standard library:
     - SparseArrays: sparse, nnz, nonzeros, rowvals, droptol!, dropzeros, dropzeros!, SparseVector, SparseMatrixCSC
 =#
 
-export AbstractQuantumObject, QuantumObject
-export QuantumObjectType,
-    BraQuantumObject,
-    KetQuantumObject,
-    OperatorQuantumObject,
-    OperatorBraQuantumObject,
-    OperatorKetQuantumObject,
-    SuperOperatorQuantumObject
-export Bra, Ket, Operator, OperatorBra, OperatorKet, SuperOperator
-
-@doc raw"""
-    AbstractQuantumObject{DataType,ObjType,N}
-
-Abstract type for all quantum objects like [`QuantumObject`](@ref) and [`QuantumObjectEvolution`](@ref).
-"""
-abstract type AbstractQuantumObject{DataType,ObjType,N} end
-
-abstract type QuantumObjectType end
-
-@doc raw"""
-    BraQuantumObject <: QuantumObjectType
-
-Constructor representing a bra state ``\langle\psi|``.
-"""
-struct BraQuantumObject <: QuantumObjectType end
-Base.show(io::IO, ::BraQuantumObject) = print(io, "Bra")
-
-@doc raw"""
-    const Bra = BraQuantumObject()
-
-A constant representing the type of [`BraQuantumObject`](@ref): a bra state ``\langle\psi|``
-"""
-const Bra = BraQuantumObject()
-
-@doc raw"""
-    KetQuantumObject <: QuantumObjectType
-
-Constructor representing a ket state ``|\psi\rangle``.
-"""
-struct KetQuantumObject <: QuantumObjectType end
-Base.show(io::IO, ::KetQuantumObject) = print(io, "Ket")
-
-@doc raw"""
-    const Ket = KetQuantumObject()
-
-A constant representing the type of [`KetQuantumObject`](@ref): a ket state ``|\psi\rangle``
-"""
-const Ket = KetQuantumObject()
-
-@doc raw"""
-    OperatorQuantumObject <: QuantumObjectType
-
-Constructor representing an operator ``\hat{O}``.
-"""
-struct OperatorQuantumObject <: QuantumObjectType end
-Base.show(io::IO, ::OperatorQuantumObject) = print(io, "Operator")
-
-@doc raw"""
-    const Operator = OperatorQuantumObject()
-
-A constant representing the type of [`OperatorQuantumObject`](@ref): an operator ``\hat{O}``
-"""
-const Operator = OperatorQuantumObject()
-
-@doc raw"""
-    SuperOperatorQuantumObject <: QuantumObjectType
-
-Constructor representing a super-operator ``\hat{\mathcal{O}}`` acting on vectorized density operator matrices.
-"""
-struct SuperOperatorQuantumObject <: QuantumObjectType end
-Base.show(io::IO, ::SuperOperatorQuantumObject) = print(io, "SuperOperator")
-
-@doc raw"""
-    const SuperOperator = SuperOperatorQuantumObject()
-
-A constant representing the type of [`SuperOperatorQuantumObject`](@ref): a super-operator ``\hat{\mathcal{O}}`` acting on vectorized density operator matrices
-"""
-const SuperOperator = SuperOperatorQuantumObject()
-
-@doc raw"""
-    OperatorBraQuantumObject <: QuantumObjectType
-
-Constructor representing a bra state in the [`SuperOperator`](@ref) formalism ``\langle\langle\rho|``.
-"""
-struct OperatorBraQuantumObject <: QuantumObjectType end
-Base.show(io::IO, ::OperatorBraQuantumObject) = print(io, "OperatorBra")
-
-@doc raw"""
-    const OperatorBra = OperatorBraQuantumObject()
-
-A constant representing the type of [`OperatorBraQuantumObject`](@ref): a bra state in the [`SuperOperator`](@ref) formalism ``\langle\langle\rho|``.
-"""
-const OperatorBra = OperatorBraQuantumObject()
-
-@doc raw"""
-    OperatorKetQuantumObject <: QuantumObjectType
-
-Constructor representing a ket state in the [`SuperOperator`](@ref) formalism ``|\rho\rangle\rangle``.
-"""
-struct OperatorKetQuantumObject <: QuantumObjectType end
-Base.show(io::IO, ::OperatorKetQuantumObject) = print(io, "OperatorKet")
-
-@doc raw"""
-    const OperatorKet = OperatorKetQuantumObject()
-
-A constant representing the type of [`OperatorKetQuantumObject`](@ref): a ket state in the [`SuperOperator`](@ref) formalism ``|\rho\rangle\rangle``
-"""
-const OperatorKet = OperatorKetQuantumObject()
+export QuantumObject
 
 @doc raw"""
     struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,N}
@@ -232,11 +125,6 @@ _check_dims(dims::Any) = throw(
     ),
 )
 
-function check_dims(A::AbstractQuantumObject, B::AbstractQuantumObject)
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
-    return nothing
-end
-
 function _check_QuantumObject(type::KetQuantumObject, dims, m::Int, n::Int)
     (n != 1) && throw(DomainError((m, n), "The size of the array is not compatible with Ket"))
     (prod(dims) != m) && throw(DimensionMismatch("Ket with dims = $(dims) does not fit the array size = $((m, n))."))
@@ -321,41 +209,6 @@ function Base.show(io::IO, QO::AbstractQuantumObject)
     return show(io, MIME("text/plain"), op_data)
 end
 
-@doc raw"""
-    size(A::AbstractQuantumObject)
-    size(A::AbstractQuantumObject, idx::Int)
-
-Returns a tuple containing each dimensions of the array in the [`AbstractQuantumObject`](@ref).
-
-Optionally, you can specify an index (`idx`) to just get the corresponding dimension of the array.
-"""
-Base.size(A::AbstractQuantumObject) = size(A.data)
-Base.size(A::AbstractQuantumObject, idx::Int) = size(A.data, idx)
-
-Base.getindex(A::AbstractQuantumObject, inds...) = getindex(A.data, inds...)
-Base.setindex!(A::AbstractQuantumObject, val, inds...) = setindex!(A.data, val, inds...)
-
-@doc raw"""
-    eltype(A::AbstractQuantumObject)
-
-Returns the elements type of the matrix or vector corresponding to the [`AbstractQuantumObject`](@ref) `A`.
-"""
-Base.eltype(A::AbstractQuantumObject) = eltype(A.data)
-
-@doc raw"""
-    length(A::AbstractQuantumObject)
-
-Returns the length of the matrix or vector corresponding to the [`AbstractQuantumObject`](@ref) `A`.
-"""
-Base.length(A::AbstractQuantumObject) = length(A.data)
-
-Base.isequal(A::AbstractQuantumObject, B::AbstractQuantumObject) =
-    isequal(A.type, B.type) && isequal(A.dims, B.dims) && isequal(A.data, B.data)
-Base.isapprox(A::AbstractQuantumObject, B::AbstractQuantumObject; kwargs...) =
-    isequal(A.type, B.type) && isequal(A.dims, B.dims) && isapprox(A.data, B.data; kwargs...)
-Base.:(==)(A::AbstractQuantumObject, B::AbstractQuantumObject) =
-    (A.type == B.type) && (A.dims == B.dims) && (A.data == B.data)
-
 Base.real(x::QuantumObject) = QuantumObject(real(x.data), x.type, x.dims)
 Base.imag(x::QuantumObject) = QuantumObject(imag(x.data), x.type, x.dims)
 
@@ -379,9 +232,3 @@ SparseArrays.SparseMatrixCSC(A::QuantumObject{<:AbstractMatrix}) =
     QuantumObject(SparseMatrixCSC(A.data), A.type, A.dims)
 SparseArrays.SparseMatrixCSC{T}(A::QuantumObject{<:SparseMatrixCSC}) where {T<:Number} =
     QuantumObject(SparseMatrixCSC{T}(A.data), A.type, A.dims)
-
-get_typename_wrapper(A::AbstractQuantumObject) = Base.typename(typeof(A)).wrapper
-
-# functions for getting Float or Complex element type
-_FType(::QuantumObject{<:AbstractArray{T}}) where {T<:Number} = _FType(T)
-_CType(::QuantumObject{<:AbstractArray{T}}) where {T<:Number} = _CType(T)