fix some tests

Author: ytdHuang

src/qobj/arithmetic_and_attributes.jl

@@ -69,7 +69,7 @@ function LinearAlgebra.:(*)(
     B::QuantumObject{DT2,BraQuantumObject},
 ) where {DT1,DT2}
     check_dims(A, B)
-    return QuantumObject(A.data * B.data, Operator, A.dims)
+    return QuantumObject(A.data * B.data, Operator, A.dims) # to align with QuTiP, don't use kron(A, B) to do it.
 end
 function LinearAlgebra.:(*)(
     A::QuantumObject{DT1,BraQuantumObject},
@@ -212,8 +212,10 @@ LinearAlgebra.adjoint(
     A::AbstractQuantumObject{DT,OpType},
 ) where {DT,OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
     get_typename_wrapper(A)(adjoint(A.data), A.type, transpose(A.dims))
-LinearAlgebra.adjoint(A::QuantumObject{DT,KetQuantumObject}) where {DT} = QuantumObject(adjoint(A.data), Bra, transpose(A.dims))
-LinearAlgebra.adjoint(A::QuantumObject{DT,BraQuantumObject}) where {DT} = QuantumObject(adjoint(A.data), Ket, transpose(A.dims))
+LinearAlgebra.adjoint(A::QuantumObject{DT,KetQuantumObject}) where {DT} =
+    QuantumObject(adjoint(A.data), Bra, transpose(A.dims))
+LinearAlgebra.adjoint(A::QuantumObject{DT,BraQuantumObject}) where {DT} =
+    QuantumObject(adjoint(A.data), Ket, transpose(A.dims))
 LinearAlgebra.adjoint(A::QuantumObject{DT,OperatorKetQuantumObject}) where {DT} =
     QuantumObject(adjoint(A.data), OperatorBra, transpose(A.dims))
 LinearAlgebra.adjoint(A::QuantumObject{DT,OperatorBraQuantumObject}) where {DT} =

src/qobj/dimensions.jl

@@ -1,4 +1,4 @@
-export AbstractDimensions, Dimensions
+export AbstractDimensions, Dimensions#, CompoundDimensions
 
 abstract type AbstractDimensions{N} end
 
@@ -15,6 +15,9 @@ function Dimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Intege
     return Dimensions(SVector{L,AbstractSpace}(Space.(dims)))
 end
 
+# this creates a list of Space(1), it's used to generate `from` for Ket, and `` for Bra)
+# oneDimensions(N::Int) = Dimensions(SVector{N,AbstractSpace}(ntuple(i -> Space(1), Val(N))))
+
 _gen_dims(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N} = Dimensions(dims)
 _gen_dims(dims::Int) = Dimensions(SVector{1,AbstractSpace}(Space(dims)))
 _gen_dims(dims::AbstractDimensions) = dims
@@ -24,16 +27,36 @@ _gen_dims(dims::Any) = throw(
     ),
 )
 
-Base.prod(dims::Dimensions) = prod(dims.to)
-Base.prod(spaces::SVector{1,AbstractSpace}) = spaces[1].size # for `Dimensions.to` has only a single Space
-
-LinearAlgebra.transpose(dims::Dimensions) = dims
-
-struct CompoundDimensions{N} <: AbstractDimensions{N}
+#= struct CompoundDimensions{N} <: AbstractDimensions{N}
     # note that the number `N` should be the same for both `to` and `from`
     to::SVector{N,AbstractSpace}   # space acting on the left
     from::SVector{N,AbstractSpace} # space acting on the right
 end
 Base.show(io::IO, D::CompoundDimensions) = print(io, "[", D.to, ", ", D.from, "]")
 
-LinearAlgebra.transpose(dims::CompoundDimensions) = CompoundDimensions(dims.from, dims.to) # switch `to` and `from`
+function CompoundDimensions(to::Union{AbstractVector{T},NTuple{N1,T}}, from::Union{AbstractVector{T},NTuple{N2,T}}) where {T<:Integer,N1,N2}
+    _non_static_array_warning("dims", to)
+    _non_static_array_warning("dims", from)
+
+    L1 = length(to)
+    L2 = length(from)
+    ((L1 > 0) && (L1 == L2)) || throw(DomainError((to, from), "The arguments `to` and `from` must be in the same length and have at least one element."))
+
+    return CompoundDimensions(SVector{L1,AbstractSpace}(Space.(to)), SVector{L1,AbstractSpace}(Space.(from)))
+end
+CompoundDimensions(to::Int, from::Int) = CompoundDimensions(SVector{1,Int}(to), SVector{1,Int}(from))
+CompoundDimensions(::KetQuantumObject, dims::Dimensions) = CompoundDimensions(dims, oneDimensions(length(dims)))
+CompoundDimensions(::BraQuantumObject, dims::Dimensions) = CompoundDimensions(oneDimensions(length(dims)), dims)
+CompoundDimensions(::OperatorQuantumObject, dims::Dimensions) = CompoundDimensions(dims, dims)
+CompoundDimensions(::OperatorQuantumObject, dims::CompoundDimensions) = dims =#
+
+Base.length(dims::AbstractDimensions) = length(dims.to)
+
+Base.prod(dims::Dimensions) = prod(dims.to)
+Base.prod(spaces::SVector{1,AbstractSpace}) = spaces[1].size # for `Dimensions.to` has only a single Space
+
+LinearAlgebra.transpose(dims::Dimensions) = dims
+# LinearAlgebra.transpose(dims::CompoundDimensions) = CompoundDimensions(dims.from, dims.to) # switch `to` and `from`
+
+LinearAlgebra.kron(Adims::Dimensions, Bdims::Dimensions) = Dimensions(vcat(Adims.to, Bdims.to))
+# LinearAlgebra.kron(Adims::CompoundDimensions, Bdims::CompoundDimensions) = CompoundDimensions(vcat(Adims.to, Bdims.to), vcat(Adims.from, Bdims.from))

src/qobj/functions.jl

@@ -179,11 +179,22 @@ julia> a.dims, O.dims
 ```
 """
 function LinearAlgebra.kron(
-    A::AbstractQuantumObject{DT1,OpType},
-    B::AbstractQuantumObject{DT2,OpType},
-) where {DT1,DT2,OpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject}}
+    A::AbstractQuantumObject{DT1,AOpType},
+    B::AbstractQuantumObject{DT2,BOpType},
+) where {DT1,DT2,AOpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject},BOpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject}}
     QType = promote_op_type(A, B)
-    return QType(kron(A.data, B.data), A.type, vcat(A.dims, B.dims))
+    kron_type = (AOpType == BOpType) ? A.type : Operator
+
+    # deal with dims; # TODO: uncomment the following if-else block when CompoundDimensions is supported
+    # if (A.dims isa Dimensions) && (B.dims isa Dimensions)
+        _Adims = A.dims
+        _Bdims = B.dims
+    # else
+    #     # transfer to CompoundDimensions
+    #     _Adims = CompoundDimensions(A.type, A.dims)
+    #     _Bdims = CompoundDimensions(B.type, B.dims) =#
+    # end
+    return QType(kron(A.data, B.data), kron_type, kron(_Adims, _Bdims))
 end
 LinearAlgebra.kron(A::AbstractQuantumObject) = A
 function LinearAlgebra.kron(A::Vector{<:AbstractQuantumObject})

src/qobj/quantum_object.jl

@@ -9,10 +9,10 @@ It also implements the fundamental functions in Julia standard library:
 export QuantumObject
 
 @doc raw"""
-    struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,DimType<:AbstractDimensions}
+    struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,N} <: AbstractQuantumObject{MT,ObjType,N}
         data::MT
         type::ObjType
-        dims::DimType
+        dims::AbstractDimensions{N}
     end
 
 Julia struct representing any quantum objects.
@@ -33,18 +33,19 @@ julia> a isa QuantumObject
 true
 ```
 """
-struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,DimType<:AbstractDimensions} <: AbstractQuantumObject{MT,ObjType,DimType}
+struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,N} <: AbstractQuantumObject{MT,ObjType,N}
     data::MT
     type::ObjType
-    dims::DimType
+    dims::AbstractDimensions{N}
 
     function QuantumObject(data::MT, type::ObjType, dims) where {MT<:AbstractArray,ObjType<:QuantumObjectType}
         _dims = _gen_dims(dims)
+        N = length(_dims)
 
         _size = _get_size(data)
         _check_QuantumObject(type, _dims, _size[1], _size[2])
 
-        return new{MT,ObjType,typeof(_dims)}(data, type, _dims)
+        return new{MT,ObjType,N}(data, type, _dims)
     end
 end
 

src/qobj/quantum_object_base.jl

@@ -24,7 +24,7 @@ julia> sigmax() isa AbstractQuantumObject
 true
 ```
 """
-abstract type AbstractQuantumObject{DataType,ObjType,DimType} end
+abstract type AbstractQuantumObject{DataType,ObjType,N} end
 
 abstract type QuantumObjectType end
 

src/qobj/quantum_object_evo.jl

@@ -5,10 +5,10 @@ This file defines the QuantumObjectEvolution (QobjEvo) structure.
 export QuantumObjectEvolution
 
 @doc raw"""
-    struct QuantumObjectEvolution{DT<:AbstractSciMLOperator,ObjType<:QuantumObjectType,DimType<:AbstractDimensions} <: AbstractQuantumObject
+    struct QuantumObjectEvolution{DT<:AbstractSciMLOperator,ObjType<:QuantumObjectType,N} <: AbstractQuantumObject{DT,ObjType,N}
         data::DT
         type::ObjType
-        dims::DimType
+        dims::AbstractDimensions{N}
     end
 
 Julia struct representing any time-dependent quantum object. The `data` field is a `AbstractSciMLOperator` object that represents the time-dependent quantum object. It can be seen as
@@ -99,11 +99,11 @@ Quantum Object:   type=Operator   dims=[10, 2]   size=(20, 20)   ishermitian=fal
 struct QuantumObjectEvolution{
     DT<:AbstractSciMLOperator,
     ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject},
-    DimType<:AbstractDimensions,
-} <: AbstractQuantumObject{DT,ObjType,DimType}
+    N,
+} <: AbstractQuantumObject{DT,ObjType,N}
     data::DT
     type::ObjType
-    dims::DimType
+    dims::AbstractDimensions{N}
 
     function QuantumObjectEvolution(
         data::DT,
@@ -114,11 +114,12 @@ struct QuantumObjectEvolution{
             throw(ArgumentError("The type $type is not supported for QuantumObjectEvolution."))
 
         _dims = _gen_dims(dims)
+        N = length(_dims)
 
         _size = _get_size(data)
         _check_QuantumObject(type, _dims, _size[1], _size[2])
 
-        return new{DT,ObjType,typeof(_dims)}(data, type, _dims)
+        return new{DT,ObjType,N}(data, type, _dims)
     end
 end
 

src/qobj/space.jl

@@ -17,4 +17,4 @@ Base.show(io::IO, s::Space) = print(io, s.size)
 
 # for `prod(::Dimensions)`
 Base.:(*)(i::Int, s::Space) = i * s.size
-Base.:(*)(s1::Space, s2::Space) = s1.size * s2.size
+Base.:(*)(s1::Space, s2::Space) = s1.size * s2.size

test/core-test/quantum_objects.jl

@@ -310,13 +310,15 @@
         for T in [ComplexF32, ComplexF64]
             N = 4
             a = rand(T, N)
-            @inferred QuantumObject{typeof(a),KetQuantumObject} Qobj(a)
+            @inferred QuantumObject{typeof(a),KetQuantumObject,1} Qobj(a)
             for type in [Ket, OperatorKet]
                 @inferred Qobj(a, type = type)
             end
 
-            UnionType =
-                Union{QuantumObject{Matrix{T},BraQuantumObject,Dimensions{1}},QuantumObject{Matrix{T},OperatorQuantumObject,Dimensions{1}}}
+            UnionType = Union{
+                QuantumObject{Matrix{T},BraQuantumObject,1},
+                QuantumObject{Matrix{T},OperatorQuantumObject,1},
+            }
             a = rand(T, 1, N)
             @inferred UnionType Qobj(a)
             for type in [Bra, OperatorBra]

test/runtests.jl

@@ -30,7 +30,7 @@ if (GROUP == "All") || (GROUP == "Code-Quality")
     using QuantumToolbox
     using Aqua, JET
 
-    #include(joinpath(testdir, "core-test", "code_quality.jl"))
+    include(joinpath(testdir, "core-test", "code_quality.jl"))
 end
 
 if (GROUP == "All") || (GROUP == "Core")