update definition for AbstractDimensions

Author: ytdHuang

src/QuantumToolbox.jl

@@ -79,9 +79,9 @@ include("progress_bar.jl")
 include("linear_maps.jl")
 
 # Quantum Object
+include("qobj/quantum_object_base.jl")
 include("qobj/space.jl")
 include("qobj/dimensions.jl")
-include("qobj/quantum_object_base.jl")
 include("qobj/quantum_object.jl")
 include("qobj/quantum_object_evo.jl")
 include("qobj/boolean_functions.jl")

src/qobj/dimensions.jl

@@ -1,62 +1,62 @@
-export AbstractDimensions, Dimensions#, CompoundDimensions
+export AbstractDimensions, Dimensions, CompoundDimensions
 
 abstract type AbstractDimensions{N} end
 
 struct Dimensions{N} <: AbstractDimensions{N}
-    to::SVector{N,AbstractSpace}
+    to::SVector{N,<:AbstractSpace}
 end
-Base.show(io::IO, D::Dimensions) = print(io, D.to)
-
 function Dimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N}
     _non_static_array_warning("dims", dims)
     L = length(dims)
     (L > 0) || throw(DomainError(dims, "The argument dims must be of non-zero length"))
 
-    return Dimensions(SVector{L,AbstractSpace}(Space.(dims)))
+    return Dimensions{L}(SVector{L,Space}(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
-_gen_dims(dims::Any) = throw(
+Dimensions(dims::Int) = Dimensions(SVector{1,Int}(dims))
+Dimensions(dims::Any) = throw(
     ArgumentError(
         "The argument dims must be a Tuple or a StaticVector of non-zero length and contain only positive integers.",
     ),
 )
 
-#= struct CompoundDimensions{N} <: AbstractDimensions{N}
+Base.show(io::IO, D::Dimensions) = print(io, D.to)
+
+# this creates a list of Space(1), it's used to generate `from` for Ket, and `to` for Bra)
+oneDimensions(N::Int) = Dimensions(SVector{N,Space}(ntuple(i -> Space(1), Val(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
+    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, "]")
-
 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."))
+    ((L1 > 0) && (L1 == L2)) || throw(DomainError((L1, L2), "The length of 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)))
+    return CompoundDimensions{L1}(SVector{L1,Space}(Space.(to)), SVector{L1,Space}(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 =#
+CompoundDimensions(::KetQuantumObject, dims::Dimensions{N}) where {N} = CompoundDimensions{N}(dims, oneDimensions(length(dims)))
+CompoundDimensions(::BraQuantumObject, dims::Dimensions{N}) where {N} = CompoundDimensions{N}(oneDimensions(length(dims)), dims)
+CompoundDimensions(::OperatorQuantumObject, dims::Dimensions{N}) where {N} = CompoundDimensions{N}(dims, dims)
+CompoundDimensions(::OperatorQuantumObject, dims::CompoundDimensions) = dims
+
+Base.show(io::IO, D::CompoundDimensions) = print(io, "[", D.to, ", ", D.from, "]")
+
+_gen_dims(dims::AbstractDimensions) = dims
+_gen_dims(dims::Any) = Dimensions(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
+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.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))
+LinearAlgebra.kron(Adims::Dimensions{NA}, Bdims::Dimensions{NB}) where {NA,NB} = Dimensions{NA+NB}(vcat(Adims.to, Bdims.to))
+LinearAlgebra.kron(Adims::CompoundDimensions{NA}, Bdims::CompoundDimensions{NB}) where {NA,NB} = CompoundDimensions{NA+NB}(vcat(Adims.to, Bdims.to), vcat(Adims.from, Bdims.from))

src/qobj/functions.jl

@@ -178,25 +178,53 @@ julia> a.dims, O.dims
 ([20], [20, 20])
 ```
 """
-function LinearAlgebra.kron(
-    A::AbstractQuantumObject{DT1,AOpType},
-    B::AbstractQuantumObject{DT2,BOpType},
-) where {DT1,DT2,AOpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject},BOpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject}}
+function LinearAlgebra.kron( # for same OpType. Note that `<:DimType` means same DimType but can have different length N : DimType{N}
+    A::AbstractQuantumObject{DT1,OpType,<:DimType},
+    B::AbstractQuantumObject{DT2,OpType,<:DimType},
+) where {DT1,DT2,OpType<:Union{KetQuantumObject,BraQuantumObject,OperatorQuantumObject},DimType<:AbstractDimensions}
     QType = promote_op_type(A, B)
-    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))
+    return QType(kron(A.data, B.data), A.type, kron(A.dims, B.dims))
 end
 LinearAlgebra.kron(A::AbstractQuantumObject) = A
+for DimType in (:Dimensions, :CompoundDimensions)
+    @eval begin
+        
+    end
+end
+function LinearAlgebra.kron( # if A and B are both Operator but different Dimensions type
+    A::AbstractQuantumObject{DT1,OperatorQuantumObject,<:Dimensions},
+    B::AbstractQuantumObject{DT2,OperatorQuantumObject,<:CompoundDimensions},
+) where {DT1,DT2}
+    QType = promote_op_type(A, B)
+    return QType(kron(A.data, B.data), Operator, kron(CompoundDimensions(A.type, A.dims), B.dims))
+end
+function LinearAlgebra.kron( # if A and B are both Operator but different Dimensions type
+    A::AbstractQuantumObject{DT1,OperatorQuantumObject,<:CompoundDimensions},
+    B::AbstractQuantumObject{DT2,OperatorQuantumObject,<:Dimensions},
+) where {DT1,DT2}
+    QType = promote_op_type(A, B)
+    return QType(kron(A.data, B.data), Operator, kron(A.dims, CompoundDimensions(B.type, B.dims)))
+end
+for AOpType in (:KetQuantumObject, :BraQuantumObject, :OperatorQuantumObject)
+    for BOpType in (:KetQuantumObject, :BraQuantumObject, :OperatorQuantumObject)
+        if (AOpType != BOpType)
+            @eval begin
+                function LinearAlgebra.kron(
+                    A::AbstractQuantumObject{DT1,$AOpType},
+                    B::AbstractQuantumObject{DT2,$BOpType},
+                ) where {DT1,DT2}
+                    QType = promote_op_type(A, B)
+                
+                    # transfer to CompoundDimensions
+                    _Adims = CompoundDimensions(A.type, A.dims)
+                    _Bdims = CompoundDimensions(B.type, B.dims)
+
+                    return QType(kron(A.data, B.data), Operator, kron(_Adims, _Bdims))
+                end
+            end
+        end
+    end
+end
 function LinearAlgebra.kron(A::Vector{<:AbstractQuantumObject})
     @warn "`tensor(A)` or `kron(A)` with `A` is a `Vector` can hurt performance. Try to use `tensor(A...)` or `kron(A...)` instead."
     return kron(A...)

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,N} <: AbstractQuantumObject{MT,ObjType,N}
-        data::MT
+    struct QuantumObject{DataType<:AbstractArray,ObjType<:QuantumObjectType,DimType<:AbstractDimensions} <: AbstractQuantumObject{DataType,ObjType,DimType}
+        data::DataType
         type::ObjType
-        dims::AbstractDimensions{N}
+        dims::DimType
     end
 
 Julia struct representing any quantum objects.
@@ -33,19 +33,18 @@ julia> a isa QuantumObject
 true
 ```
 """
-struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,N} <: AbstractQuantumObject{MT,ObjType,N}
-    data::MT
+struct QuantumObject{DataType<:AbstractArray,ObjType<:QuantumObjectType,DimType<:AbstractDimensions} <: AbstractQuantumObject{DataType,ObjType,DimType}
+    data::DataType
     type::ObjType
-    dims::AbstractDimensions{N}
+    dims::DimType
 
     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,N}(data, type, _dims)
+        return new{MT,ObjType,typeof(_dims)}(data, type, _dims)
     end
 end
 

src/qobj/quantum_object_base.jl

@@ -14,7 +14,7 @@ export QuantumObjectType,
 export Bra, Ket, Operator, OperatorBra, OperatorKet, SuperOperator
 
 @doc raw"""
-    abstract type AbstractQuantumObject{DataType,ObjType,N}
+    abstract type AbstractQuantumObject{DataType,ObjType,DimType}
 
 Abstract type for all quantum objects like [`QuantumObject`](@ref) and [`QuantumObjectEvolution`](@ref).
 
@@ -24,7 +24,7 @@ julia> sigmax() isa AbstractQuantumObject
 true
 ```
 """
-abstract type AbstractQuantumObject{DataType,ObjType,N} end
+abstract type AbstractQuantumObject{DataType,ObjType,DimType} 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,N} <: AbstractQuantumObject{DT,ObjType,N}
-        data::DT
+    struct QuantumObjectEvolution{DataType<:AbstractSciMLOperator,ObjType<:QuantumObjectType,DimType<:AbstractDimensions} <: AbstractQuantumObject{DataType,ObjType,DimType}
+        data::DataType
         type::ObjType
-        dims::AbstractDimensions{N}
+        dims::DimType
     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
@@ -97,13 +97,13 @@ Quantum Object:   type=Operator   dims=[10, 2]   size=(20, 20)   ishermitian=fal
 ```
 """
 struct QuantumObjectEvolution{
-    DT<:AbstractSciMLOperator,
+    DataType<:AbstractSciMLOperator,
     ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject},
-    N,
-} <: AbstractQuantumObject{DT,ObjType,N}
-    data::DT
+    DimType<:AbstractDimensions,
+} <: AbstractQuantumObject{DataType,ObjType,DimType}
+    data::DataType
     type::ObjType
-    dims::AbstractDimensions{N}
+    dims::DimType
 
     function QuantumObjectEvolution(
         data::DT,
@@ -114,12 +114,11 @@ 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,N}(data, type, _dims)
+        return new{DT,ObjType,typeof(_dims)}(data, type, _dims)
     end
 end
 

src/qobj/space.jl

@@ -3,7 +3,7 @@ export AbstractSpace, Space
 abstract type AbstractSpace end
 
 # this show function is for printing AbstractDimensions
-Base.show(io::IO, svec::SVector{N,AbstractSpace}) where {N} = print(io, "[", join(svec, ", "), "]")
+Base.show(io::IO, svec::SVector{N,<:AbstractSpace}) where {N} = print(io, "[", join(svec, ", "), "]")
 
 struct Space <: AbstractSpace
     size::Int

test/core-test/quantum_objects.jl

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