Allow complex float conversion of general types and make _CType function name more Julia-like

Author: albertomercurio

src/qobj/quantum_object_base.jl

@@ -245,5 +245,5 @@ _get_dims_length(::Space) = 1
 _get_dims_length(::EnrSpace{N}) where {N} = N
 
 # functions for getting Float or Complex element type
-_FType(A::AbstractQuantumObject) = _FType(eltype(A))
-_CType(A::AbstractQuantumObject) = _CType(eltype(A))
+_float_type(A::AbstractQuantumObject) = _float_type(eltype(A))
+_complex_float_type(A::AbstractQuantumObject) = _complex_float_type(eltype(A))

src/spectrum.jl

@@ -127,17 +127,17 @@ function _spectrum(
 )
     check_dimensions(L, A, B)
 
-    ωList = convert(Vector{_FType(L)}, ωlist) # Convert it to support GPUs and avoid type instabilities
+    ωList = convert(Vector{_float_type(L)}, ωlist) # Convert it to support GPUs and avoid type instabilities
     Length = length(ωList)
-    spec = Vector{_FType(L)}(undef, Length)
+    spec = Vector{_float_type(L)}(undef, Length)
 
     # calculate vectorized steadystate, multiply by operator B on the left (spre)
     ρss = mat2vec(steadystate(L))
     b = (spre(B) * ρss).data
 
     # multiply by operator A on the left (spre) and then perform trace operation
     D = prod(L.dimensions)
-    _tr = SparseVector(D^2, [1 + n * (D + 1) for n in 0:(D-1)], ones(_CType(L), D)) # same as vec(system_identity_matrix)
+    _tr = SparseVector(D^2, [1 + n * (D + 1) for n in 0:(D-1)], ones(_complex_float_type(L), D)) # same as vec(system_identity_matrix)
     _tr_A = transpose(_tr) * spre(A).data
 
     Id = I(D^2)
@@ -169,8 +169,8 @@ function _spectrum(
     check_dimensions(L, A, B)
 
     # Define type shortcuts
-    fT = _FType(L)
-    cT = _CType(L)
+    fT = _float_type(L)
+    cT = _complex_float_type(L)
 
     # Calculate |v₁> = B|ρss>
     ρss =

src/steadystate.jl

@@ -206,7 +206,7 @@ function _steadystate(L::QuantumObject{SuperOperator}, solver::SteadyStateODESol
     abstol = haskey(kwargs, :abstol) ? kwargs[:abstol] : DEFAULT_ODE_SOLVER_OPTIONS.abstol
     reltol = haskey(kwargs, :reltol) ? kwargs[:reltol] : DEFAULT_ODE_SOLVER_OPTIONS.reltol
 
-    ftype = _FType(ψ0)
+    ftype = _float_type(ψ0)
     _terminate_func = SteadyStateODECondition(similar(mat2vec(ket2dm(ψ0)).data))
     cb = TerminateSteadyState(abstol, reltol, _terminate_func)
     sol = mesolve(

src/time_evolution/lr_mesolve.jl

@@ -412,7 +412,7 @@ function lr_mesolveProblem(
     c_ops = get_data.(c_ops)
     e_ops = get_data.(e_ops)
 
-    t_l = _check_tlist(tlist, _FType(H))
+    t_l = _check_tlist(tlist, _float_type(H))
 
     # Initialization of Arrays
     expvals = Array{ComplexF64}(undef, length(e_ops), length(t_l))

src/time_evolution/mcsolve.jl

@@ -125,7 +125,7 @@ function mcsolveProblem(
     c_ops isa Nothing &&
         throw(ArgumentError("The list of collapse operators must be provided. Use sesolveProblem instead."))
 
-    tlist = _check_tlist(tlist, _FType(ψ0))
+    tlist = _check_tlist(tlist, _float_type(ψ0))
 
     H_eff_evo = _mcsolve_make_Heff_QobjEvo(H, c_ops)
 

src/time_evolution/mesolve.jl

@@ -79,16 +79,16 @@ function mesolveProblem(
     haskey(kwargs, :save_idxs) &&
         throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox."))
 
-    tlist = _check_tlist(tlist, _FType(ψ0))
+    tlist = _check_tlist(tlist, _float_type(ψ0))
 
     L_evo = _mesolve_make_L_QobjEvo(H, c_ops)
     check_dimensions(L_evo, ψ0)
 
     T = Base.promote_eltype(L_evo, ψ0)
     ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type
-        to_dense(_CType(T), copy(ψ0.data))
+        to_dense(_complex_float_type(T), copy(ψ0.data))
     else
-        to_dense(_CType(T), mat2vec(ket2dm(ψ0).data))
+        to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))
     end
     L = L_evo.data
 

src/time_evolution/sesolve.jl

@@ -61,14 +61,14 @@ function sesolveProblem(
     haskey(kwargs, :save_idxs) &&
         throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox."))
 
-    tlist = _check_tlist(tlist, _FType(ψ0))
+    tlist = _check_tlist(tlist, _float_type(ψ0))
 
     H_evo = _sesolve_make_U_QobjEvo(H) # Multiply by -i
     isoper(H_evo) || throw(ArgumentError("The Hamiltonian must be an Operator."))
     check_dimensions(H_evo, ψ0)
 
     T = Base.promote_eltype(H_evo, ψ0)
-    ψ0 = to_dense(_CType(T), get_data(ψ0)) # Convert it to dense vector with complex element type
+    ψ0 = to_dense(_complex_float_type(T), get_data(ψ0)) # Convert it to dense vector with complex element type
     U = H_evo.data
 
     kwargs2 = _merge_saveat(tlist, e_ops, DEFAULT_ODE_SOLVER_OPTIONS; kwargs...)

src/time_evolution/smesolve.jl

@@ -94,17 +94,17 @@ function smesolveProblem(
     sc_ops_list = _make_c_ops_list(sc_ops) # If it is an AbstractQuantumObject but we need to iterate
     sc_ops_isa_Qobj = sc_ops isa AbstractQuantumObject # We can avoid using non-diagonal noise if sc_ops is just an AbstractQuantumObject
 
-    tlist = _check_tlist(tlist, _FType(ψ0))
+    tlist = _check_tlist(tlist, _float_type(ψ0))
 
     L_evo = _mesolve_make_L_QobjEvo(H, c_ops) + _mesolve_make_L_QobjEvo(nothing, sc_ops_list)
     check_dimensions(L_evo, ψ0)
     dims = L_evo.dimensions
 
     T = Base.promote_eltype(L_evo, ψ0)
     ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type
-        to_dense(_CType(T), copy(ψ0.data))
+        to_dense(_complex_float_type(T), copy(ψ0.data))
     else
-        to_dense(_CType(T), mat2vec(ket2dm(ψ0).data))
+        to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data))
     end
 
     progr = ProgressBar(length(tlist), enable = getVal(progress_bar))

src/time_evolution/ssesolve.jl

@@ -94,14 +94,14 @@ function ssesolveProblem(
     sc_ops_list = _make_c_ops_list(sc_ops) # If it is an AbstractQuantumObject but we need to iterate
     sc_ops_isa_Qobj = sc_ops isa AbstractQuantumObject # We can avoid using non-diagonal noise if sc_ops is just an AbstractQuantumObject
 
-    tlist = _check_tlist(tlist, _FType(ψ0))
+    tlist = _check_tlist(tlist, _float_type(ψ0))
 
     H_eff_evo = _mcsolve_make_Heff_QobjEvo(H, sc_ops_list)
     isoper(H_eff_evo) || throw(ArgumentError("The Hamiltonian must be an Operator."))
     check_dimensions(H_eff_evo, ψ0)
     dims = H_eff_evo.dimensions
 
-    ψ0 = to_dense(_CType(ψ0), get_data(ψ0))
+    ψ0 = to_dense(_complex_float_type(ψ0), get_data(ψ0))
 
     progr = ProgressBar(length(tlist), enable = getVal(progress_bar))
 

src/utilities.jl

@@ -46,7 +46,7 @@ where ``\hbar`` is the reduced Planck constant, and ``k_B`` is the Boltzmann con
 function n_thermal(ω::T1, ω_th::T2) where {T1<:Real,T2<:Real}
     x = exp(ω / ω_th)
     n = ((x != 1) && (ω_th > 0)) ? 1 / (x - 1) : 0
-    return _FType(promote_type(T1, T2))(n)
+    return _float_type(promote_type(T1, T2))(n)
 end
 
 @doc raw"""
@@ -125,7 +125,7 @@ julia> round(convert_unit(1, :meV, :mK), digits=4)
 function convert_unit(value::T, unit1::Symbol, unit2::Symbol) where {T<:Real}
     !haskey(_energy_units, unit1) && throw(ArgumentError("Invalid unit :$(unit1)"))
     !haskey(_energy_units, unit2) && throw(ArgumentError("Invalid unit :$(unit2)"))
-    return _FType(T)(value * (_energy_units[unit1] / _energy_units[unit2]))
+    return _float_type(T)(value * (_energy_units[unit1] / _energy_units[unit2]))
 end
 
 get_typename_wrapper(A) = Base.typename(typeof(A)).wrapper
@@ -174,24 +174,26 @@ for AType in (:AbstractArray, :AbstractSciMLOperator)
 end
 
 # functions for getting Float or Complex element type
-_FType(::AbstractArray{T}) where {T<:Number} = _FType(T)
-_FType(::Type{Int32}) = Float32
-_FType(::Type{Int64}) = Float64
-_FType(::Type{Float32}) = Float32
-_FType(::Type{Float64}) = Float64
-_FType(::Type{Complex{Int32}}) = Float32
-_FType(::Type{Complex{Int64}}) = Float64
-_FType(::Type{Complex{Float32}}) = Float32
-_FType(::Type{Complex{Float64}}) = Float64
-_CType(::AbstractArray{T}) where {T<:Number} = _CType(T)
-_CType(::Type{Int32}) = ComplexF32
-_CType(::Type{Int64}) = ComplexF64
-_CType(::Type{Float32}) = ComplexF32
-_CType(::Type{Float64}) = ComplexF64
-_CType(::Type{Complex{Int32}}) = ComplexF32
-_CType(::Type{Complex{Int64}}) = ComplexF64
-_CType(::Type{Complex{Float32}}) = ComplexF32
-_CType(::Type{Complex{Float64}}) = ComplexF64
+_float_type(::AbstractArray{T}) where {T<:Number} = _float_type(T)
+_float_type(::Type{Int32}) = Float32
+_float_type(::Type{Int64}) = Float64
+_float_type(::Type{Float32}) = Float32
+_float_type(::Type{Float64}) = Float64
+_float_type(::Type{Complex{Int32}}) = Float32
+_float_type(::Type{Complex{Int64}}) = Float64
+_float_type(::Type{Complex{Float32}}) = Float32
+_float_type(::Type{Complex{Float64}}) = Float64
+_float_type(T::Type{<:Real}) = T # Allow other untracked Real types, like ForwardDiff.Dual
+_complex_float_type(::AbstractArray{T}) where {T<:Number} = _complex_float_type(T)
+_complex_float_type(::Type{Int32}) = ComplexF32
+_complex_float_type(::Type{Int64}) = ComplexF64
+_complex_float_type(::Type{Float32}) = ComplexF32
+_complex_float_type(::Type{Float64}) = ComplexF64
+_complex_float_type(::Type{Complex{Int32}}) = ComplexF32
+_complex_float_type(::Type{Complex{Int64}}) = ComplexF64
+_complex_float_type(::Type{Complex{Float32}}) = ComplexF32
+_complex_float_type(::Type{Complex{Float64}}) = ComplexF64
+_complex_float_type(T::Type{<:Complex}) = T # Allow other untracked Complex types, like ForwardDiff.Dual
 
 _convert_eltype_wordsize(::Type{T}, ::Val{64}) where {T<:Int} = Int64
 _convert_eltype_wordsize(::Type{T}, ::Val{32}) where {T<:Int} = Int32