minor changes

Author: ytdHuang

src/qobj/dimensions.jl

@@ -86,6 +86,7 @@ LinearAlgebra.transpose(dimensions::Dimensions) = dimensions
 LinearAlgebra.transpose(dimensions::GeneralDimensions) = GeneralDimensions(dimensions.from, dimensions.to) # switch `to` and `from`
 LinearAlgebra.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)
     dims = dimensions_to_dims(dimensions)

src/qobj/quantum_object_base.jl

@@ -167,49 +167,49 @@ check_dimensions(Qobj_tuple::NTuple{N,AbstractQuantumObject}) where {N} =
     check_dimensions(getfield.(Qobj_tuple, :dimensions))
 check_dimensions(A::AbstractQuantumObject...) = check_dimensions(A)
 
-function _check_QuantumObject(type::KetQuantumObject, dims::Dimensions, m::Int, n::Int)
+function _check_QuantumObject(type::KetQuantumObject, dimensions::Dimensions, 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))."))
+    (prod(dimensions) != m) && throw(DimensionMismatch("Ket with dims = $(_get_dims_string(dimensions)) does not fit the array size = $((m, n))."))
     return nothing
 end
 
-function _check_QuantumObject(type::BraQuantumObject, dims::Dimensions, m::Int, n::Int)
+function _check_QuantumObject(type::BraQuantumObject, dimensions::Dimensions, m::Int, n::Int)
     (m != 1) && throw(DomainError((m, n), "The size of the array is not compatible with Bra"))
-    (prod(dims) != n) && throw(DimensionMismatch("Bra with dims = $(dims) does not fit the array size = $((m, n))."))
+    (prod(dimensions) != n) && throw(DimensionMismatch("Bra with dims = $(_get_dims_string(dimensions)) does not fit the array size = $((m, n))."))
     return nothing
 end
 
-function _check_QuantumObject(type::OperatorQuantumObject, dims::Dimensions, m::Int, n::Int)
-    L = prod(dims)
-    (L == m == n) || throw(DimensionMismatch("Operator with dims = $(dims) does not fit the array size = $((m, n))."))
+function _check_QuantumObject(type::OperatorQuantumObject, dimensions::Dimensions, m::Int, n::Int)
+    L = prod(dimensions)
+    (L == m == n) || throw(DimensionMismatch("Operator with dims = $(_get_dims_string(dimensions)) does not fit the array size = $((m, n))."))
     return nothing
 end
 
-function _check_QuantumObject(type::OperatorQuantumObject, dims::GeneralDimensions, m::Int, n::Int)
+function _check_QuantumObject(type::OperatorQuantumObject, dimensions::GeneralDimensions, m::Int, n::Int)
     ((m == 1) || (n == 1)) && throw(DomainError((m, n), "The size of the array is not compatible with Operator"))
-    ((prod(dims.to) != m) || (prod(dims.from) != n)) &&
-        throw(DimensionMismatch("Operator with dims = $(dims) does not fit the array size = $((m, n))."))
+    ((prod(dimensions.to) != m) || (prod(dimensions.from) != n)) &&
+        throw(DimensionMismatch("Operator with dims = $(_get_dims_string(dimensions)) does not fit the array size = $((m, n))."))
     return nothing
 end
 
-function _check_QuantumObject(type::SuperOperatorQuantumObject, dims::Dimensions, m::Int, n::Int)
+function _check_QuantumObject(type::SuperOperatorQuantumObject, dimensions::Dimensions, m::Int, n::Int)
     (m != n) && throw(DomainError((m, n), "The size of the array is not compatible with SuperOperator"))
-    (prod(dims) != sqrt(m)) &&
-        throw(DimensionMismatch("SuperOperator with dims = $(dims) does not fit the array size = $((m, n))."))
+    (prod(dimensions) != sqrt(m)) &&
+        throw(DimensionMismatch("SuperOperator with dims = $(_get_dims_string(dimensions)) does not fit the array size = $((m, n))."))
     return nothing
 end
 
-function _check_QuantumObject(type::OperatorKetQuantumObject, dims::Dimensions, m::Int, n::Int)
+function _check_QuantumObject(type::OperatorKetQuantumObject, dimensions::Dimensions, m::Int, n::Int)
     (n != 1) && throw(DomainError((m, n), "The size of the array is not compatible with OperatorKet"))
-    (prod(dims) != sqrt(m)) &&
-        throw(DimensionMismatch("OperatorKet with dims = $(dims) does not fit the array size = $((m, n))."))
+    (prod(dimensions) != sqrt(m)) &&
+        throw(DimensionMismatch("OperatorKet with dims = $(_get_dims_string(dimensions)) does not fit the array size = $((m, n))."))
     return nothing
 end
 
-function _check_QuantumObject(type::OperatorBraQuantumObject, dims::Dimensions, m::Int, n::Int)
+function _check_QuantumObject(type::OperatorBraQuantumObject, dimensions::Dimensions, m::Int, n::Int)
     (m != 1) && throw(DomainError((m, n), "The size of the array is not compatible with OperatorBra"))
-    (prod(dims) != sqrt(n)) &&
-        throw(DimensionMismatch("OperatorBra with dims = $(dims) does not fit the array size = $((m, n))."))
+    (prod(dimensions) != sqrt(n)) &&
+        throw(DimensionMismatch("OperatorBra with dims = $(_get_dims_string(dimensions)) does not fit the array size = $((m, n))."))
     return nothing
 end
 

src/qobj/quantum_object_evo.jl

@@ -508,8 +508,7 @@ function (A::QuantumObjectEvolution)(
     p,
     t,
 ) where {DT1,DT2,QobjType<:Union{KetQuantumObject,OperatorKetQuantumObject}}
-    check_dimensions(ψout, ψin)
-    check_dimensions(ψout, A)
+    check_dimensions(A, ψout, ψin)
 
     if isoper(A) && isoperket(ψin)
         throw(ArgumentError("The input state must be a Ket if the QuantumObjectEvolution object is an Operator."))