Remove Dimensions. Rename GeneralDimensions with ProductDimensions. Rename Space with HilbertSpace

Author: albertomercurio

src/qobj/dimensions.jl

@@ -7,50 +7,22 @@ export AbstractDimensions, Dimensions, GeneralDimensions
 abstract type AbstractDimensions{M,N} end
 
 @doc raw"""
-    struct Dimensions{N,T<:Tuple} <: AbstractDimensions{N, N}
-        to::T
-    end
-
-A structure that describes the Hilbert [`Space`](@ref) of each subsystems.
-"""
-struct Dimensions{N,T<:Tuple} <: AbstractDimensions{N,N}
-    to::T
-
-    # make sure the elements in the tuple are all AbstractSpace
-    Dimensions(to::NTuple{N,AbstractSpace}) where {N} = new{N,typeof(to)}(to)
-end
-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(Tuple(Space.(dims)))
-end
-Dimensions(dims::Int) = Dimensions(Space(dims))
-Dimensions(dims::DimType) where {DimType<:AbstractSpace} = Dimensions((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.",
-    ),
-)
-
-@doc raw"""
-    struct GeneralDimensions{N,T1<:Tuple,T2<:Tuple} <: AbstractDimensions{N}
+    struct ProductDimensions{M,N,T1<:Tuple,T2<:Tuple} <: AbstractDimensions{M,N}
         to::T1
         from::T2
     end
 
-A structure that describes the left-hand side (`to`) and right-hand side (`from`) Hilbert [`Space`](@ref) of an [`Operator`](@ref).
+A structure that describes the left-hand side (`to`) and right-hand side (`from`) dimensions of a quantum object.
 """
-struct GeneralDimensions{M,N,T1<:Tuple,T2<:Tuple} <: AbstractDimensions{M,N}
+struct ProductDimensions{M,N,T1<:Tuple,T2<:Tuple} <: AbstractDimensions{M,N}
     to::T1   # space acting on the left
     from::T2 # space acting on the right
 
     # make sure the elements in the tuple are all AbstractSpace
     GeneralDimensions(to::NTuple{M,AbstractSpace}, from::NTuple{N,AbstractSpace}) where {M,N} =
         new{M,N,typeof(to),typeof(from)}(to, from)
 end
-function GeneralDimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Union{AbstractVector,NTuple},N}
+function ProductDimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Union{AbstractVector,NTuple},N}
     (length(dims) != 2) && throw(ArgumentError("Invalid dims = $dims"))
 
     _non_static_array_warning("dims[1]", dims[1])
@@ -61,44 +33,40 @@ function GeneralDimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<
     (L1 > 0) || throw(DomainError(L1, "The length of `dims[1]` must be larger or equal to 1."))
     (L2 > 0) || throw(DomainError(L2, "The length of `dims[2]` must be larger or equal to 1."))
 
-    return GeneralDimensions(Tuple(Space.(dims[1])), Tuple(Space.(dims[2])))
+    to = ntuple(i -> HilbertSpace(dims[1][i]), Val(L1))
+    from = ntuple(i -> HilbertSpace(dims[2][i]), Val(L2))
+
+    return ProductDimensions(to, from)
 end
 
-_gen_dimensions(dims::AbstractDimensions) = dims
-_gen_dimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N} = Dimensions(dims)
-_gen_dimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Union{AbstractVector,NTuple},N} =
-    GeneralDimensions(dims)
-_gen_dimensions(dims::Any) = Dimensions(dims)
+ProductDimensions(dims::Union{Int, AbstractSpace}) = ProductDimensions((dims,), (dims,))
+ProductDimensions(to::NTuple{M,Int}, from::NTuple{N,Int}) where {M,N} = ProductDimensions((to, from))
+ProductDimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N} = ProductDimensions(dims, dims)
+ProductDimensions(dims::ProductDimensions) = dims
 
 # obtain dims in the type of SVector with integers
-dimensions_to_dims(dimensions::NTuple{N,AbstractSpace}) where {N} = vcat(map(dimensions_to_dims, dimensions)...)
-dimensions_to_dims(dimensions::Dimensions) = dimensions_to_dims(dimensions.to)
-dimensions_to_dims(dimensions::GeneralDimensions) =
+dimensions_to_dims(dimensions::NTuple{N,AbstractSpace}) where {N} = SVector{N}(map(dimensions_to_dims, dimensions))
+dimensions_to_dims(dimensions::ProductDimensions) =
     SVector{2}(dimensions_to_dims(dimensions.to), dimensions_to_dims(dimensions.from))
-
 dimensions_to_dims(::Nothing) = nothing # for EigsolveResult.dimensions = nothing
 
-Base.length(::AbstractDimensions{N}) where {N} = N
+hilbert_dimensions_to_size(dimensions::ProductDimensions) = (prod(hilbert_dimensions_to_size, dimensions.to), prod(hilbert_dimensions_to_size, dimensions.from))
+liouvillian_dimensions_to_size(dimensions::ProductDimensions) =
+    (prod(liouvillian_dimensions_to_size, dimensions.to), prod(liouvillian_dimensions_to_size, dimensions.from))
+
 
-# need to specify return type `Int` for `_get_space_size`
-# otherwise the type of `prod(::Dimensions)` will be unstable
-_get_space_size(s::AbstractSpace)::Int = s.size
-Base.prod(dims::Dimensions) = prod(dims.to)
-Base.prod(spaces::NTuple{N,AbstractSpace}) where {N} = prod(_get_space_size, spaces)
+Base.length(::AbstractDimensions{N}) where {N} = N
 
-Base.transpose(dimensions::Dimensions) = dimensions
-Base.transpose(dimensions::GeneralDimensions) = GeneralDimensions(dimensions.from, dimensions.to) # switch `to` and `from`
+Base.transpose(dimensions::ProductDimensions) = ProductDimensions(dimensions.from, dimensions.to) # switch `to` and `from`
 Base.adjoint(dimensions::AbstractDimensions) = transpose(dimensions)
 
 # this is used to show `dims` for Qobj and QobjEvo
 _get_dims_string(dimensions::Dimensions) = string(dimensions_to_dims(dimensions))
-function _get_dims_string(dimensions::GeneralDimensions)
+function _get_dims_string(dimensions::ProductDimensions)
     dims = dimensions_to_dims(dimensions)
+    dims[1] == dims[2] && return string(dims[1])
     return "[$(string(dims[1])), $(string(dims[2]))]"
 end
 _get_dims_string(::Nothing) = "nothing" # for EigsolveResult.dimensions = nothing
 
-Base.:(==)(dim1::Dimensions, dim2::Dimensions) = dim1.to == dim2.to
-Base.:(==)(dim1::GeneralDimensions, dim2::GeneralDimensions) = (dim1.to == dim2.to) && (dim1.from == dim2.from)
-Base.:(==)(dim1::Dimensions, dim2::GeneralDimensions) = false
-Base.:(==)(dim1::GeneralDimensions, dim2::Dimensions) = false
+Base.:(==)(dim1::ProductDimensions, dim2::ProductDimensions) = (dim1.to == dim2.to) && (dim1.from == dim2.from)

src/qobj/space.jl

@@ -7,19 +7,21 @@ export AbstractSpace, Space
 abstract type AbstractSpace end
 
 @doc raw"""
-    struct Space <: AbstractSpace
+    struct HilbertSpace <: AbstractSpace
         size::Int
     end
 
 A structure that describes a single Hilbert space with size = `size`.
 """
-struct Space <: AbstractSpace
+struct HilbertSpace <: AbstractSpace
     size::Int
 
-    function Space(size::Int)
+    function HilbertSpace(size::Int)
         (size < 1) && throw(DomainError(size, "The size of Space must be positive integer (≥ 1)."))
         return new(size)
     end
 end
 
-dimensions_to_dims(s::Space) = SVector{1,Int}(s.size)
+dimensions_to_dims(s::HilbertSpace) = SVector{1,Int}(s.size)
+hilbert_dimensions_to_size(s::HilbertSpace) = s.size
+liouvillian_dimensions_to_size(s::HilbertSpace) = s.size^2