Update docstrings

Author: albertomercurio

src/qobj/boolean_functions.jl

@@ -24,7 +24,7 @@ isket(::Type{QuantumObject{DT,KetQuantumObject,N}}) where {DT,N} = true
 isket(A) = false # default case
 
 @doc raw"""
-    isoper(A::AbstractQuantumObject)
+    isoper(A)
 
 Checks if the [`AbstractQuantumObject`](@ref) `A` is a [`OperatorQuantumObject`](@ref). Default case returns `false` for any other inputs.
 """
@@ -33,7 +33,7 @@ isoper(::Type{<:AbstractQuantumObject{DT,OperatorQuantumObject,N}}) where {DT,N}
 isoper(A) = false # default case
 
 @doc raw"""
-    isoperbra(A::QuantumObject)
+    isoperbra(A)
 
 Checks if the [`QuantumObject`](@ref) `A` is a [`OperatorBraQuantumObject`](@ref). Default case returns `false` for any other inputs.
 """
@@ -42,7 +42,7 @@ isoperbra(::Type{QuantumObject{DT,OperatorBraQuantumObject,N}}) where {DT,N} = t
 isoperbra(A) = false # default case
 
 @doc raw"""
-    isoperket(A::QuantumObject)
+    isoperket(A)
 
 Checks if the [`QuantumObject`](@ref) `A` is a [`OperatorKetQuantumObject`](@ref). Default case returns `false` for any other inputs.
 """
@@ -51,7 +51,7 @@ isoperket(::Type{QuantumObject{DT,OperatorKetQuantumObject,N}}) where {DT,N} = t
 isoperket(A) = false # default case
 
 @doc raw"""
-    issuper(A::AbstractQuantumObject)
+    issuper(A)
 
 Checks if the [`AbstractQuantumObject`](@ref) `A` is a [`SuperOperatorQuantumObject`](@ref). Default case returns `false` for any other inputs.
 """

src/qobj/eigsolve.jl

@@ -323,33 +323,34 @@ function eigsolve(
 end
 
 @doc raw"""
-    eigsolve_al(H::QuantumObject,
-        T::Real, c_ops::Union{Nothing,AbstractVector,Tuple}=nothing;
-        alg::OrdinaryDiffEqAlgorithm=Tsit5(),
-        H_t::Union{Nothing,Function}=nothing,
-        params::NamedTuple=NamedTuple(),
-        ρ0::Union{Nothing, AbstractMatrix} = nothing,
-        k::Int=1,
-        krylovdim::Int=min(10, size(H, 1)),
-        maxiter::Int=200,
-        eigstol::Real=1e-6,
-        kwargs...)
+    eigsolve_al(
+        H::Union{AbstractQuantumObject{DT1,HOpType},Tuple},
+        T::Real,
+        c_ops::Union{Nothing,AbstractVector,Tuple} = nothing;
+        alg::OrdinaryDiffEqAlgorithm = Tsit5(),
+        params::NamedTuple = NamedTuple(),
+        ρ0::AbstractMatrix = rand_dm(prod(H.dims)).data,
+        k::Int = 1,
+        krylovdim::Int = min(10, size(H, 1)),
+        maxiter::Int = 200,
+        eigstol::Real = 1e-6,
+        kwargs...,
+    )
 
 Solve the eigenvalue problem for a Liouvillian superoperator `L` using the Arnoldi-Lindblad method.
 
 # Arguments
-- `H`: The Hamiltonian (or directly the Liouvillian) of the system.
-- `T`: The time at which to evaluate the time evolution
+- `H`: The Hamiltonian (or directly the Liouvillian) of the system. It can be a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a tuple of the form supported by [`mesolve`](@ref).
+- `T`: The time at which to evaluate the time evolution.
 - `c_ops`: A vector of collapse operators. Default is `nothing` meaning the system is closed.
-- `alg`: The differential equation solver algorithm
-- `H_t`: A function `H_t(t)` that returns the additional term at time `t`
-- `params`: A dictionary of additional parameters
-- `ρ0`: The initial density matrix. If not specified, a random density matrix is used
-- `k`: The number of eigenvalues to compute
-- `krylovdim`: The dimension of the Krylov subspace
-- `maxiter`: The maximum number of iterations for the eigsolver
-- `eigstol`: The tolerance for the eigsolver
-- `kwargs`: Additional keyword arguments passed to the differential equation solver
+- `alg`: The differential equation solver algorithm. Default is `Tsit5()`.
+- `params`: A `NamedTuple` containing the parameters of the system.
+- `ρ0`: The initial density matrix. If not specified, a random density matrix is used.
+- `k`: The number of eigenvalues to compute.
+- `krylovdim`: The dimension of the Krylov subspace.
+- `maxiter`: The maximum number of iterations for the eigsolver.
+- `eigstol`: The tolerance for the eigsolver.
+- `kwargs`: Additional keyword arguments passed to the differential equation solver.
 
 # Notes
 - For more details about `alg` please refer to [`DifferentialEquations.jl` (ODE Solvers)](https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/)

src/qobj/quantum_object_base.jl

@@ -17,6 +17,12 @@ export Bra, Ket, Operator, OperatorBra, OperatorKet, SuperOperator
     abstract type AbstractQuantumObject{DataType,ObjType,N}
 
 Abstract type for all quantum objects like [`QuantumObject`](@ref) and [`QuantumObjectEvolution`](@ref).
+
+# Example
+```
+julia> sigmax() isa AbstractQuantumObject
+true
+```
 """
 abstract type AbstractQuantumObject{DataType,ObjType,N} end
 

src/qobj/quantum_object_evo.jl

@@ -13,7 +13,7 @@ Julia struct representing any time-dependent quantum object. The `data` field is
 \hat{O}(t) = \sum_{i} c_i(p, t) \hat{O}_i
 ```
 
-where `c_i(p, t)` is a function that depends on the parameters `p` and time `t`, and `\hat{O}_i` are the operators that form the quantum object. The `type` field is the type of the quantum object, and the `dims` field is the dimensions of the quantum object. For more information about `type` and `dims`, see [`QuantumObject`](@ref). For more information about `AbstractSciMLOperator`, see the [SciML](https://docs.sciml.ai/SciMLOperators/stable/) documentation.
+where ``c_i(p, t)`` is a function that depends on the parameters `p` and time `t`, and ``\hat{O}_i`` are the operators that form the quantum object. The `type` field is the type of the quantum object, and the `dims` field is the dimensions of the quantum object. For more information about `type` and `dims`, see [`QuantumObject`](@ref). For more information about `AbstractSciMLOperator`, see the [SciML](https://docs.sciml.ai/SciMLOperators/stable/) documentation.
 
 # Examples
 This operator can be initialized in the same way as the QuTiP `QobjEvo` object. For example
@@ -82,7 +82,7 @@ Quantum Object:   type=Operator   dims=[10, 2]   size=(20, 20)   ishermitian=fal
 ⎢⠀⠀⠀⠀⠂⡑⢄⠀⠀⠀⎥
 ⎢⠀⠀⠀⠀⠀⠀⠂⡑⢄⠀⎥
 ⎣⠀⠀⠀⠀⠀⠀⠀⠀⠂⡑⎦
-````
+```
 """
 struct QuantumObjectEvolution{
     DT<:AbstractSciMLOperator,

src/qobj/synonyms.jl

@@ -20,7 +20,7 @@ Qobj(A; kwargs...) = QuantumObject(A; kwargs...)
 @doc raw"""
     QobjEvo(op_func_list::Union{Tuple,AbstractQuantumObject}, α::Union{Nothing,Number}=nothing; type::Union{Nothing, QuantumObjectType}=nothing, f::Function=identity)
 
-Generate [`QuantumObjectEvolution`](@ref)
+Generate [`QuantumObjectEvolution`](@ref).
 
 Note that this functions is same as `QuantumObjectEvolution(op_func_list)`. If `α` is provided, all the operators in `op_func_list` will be pre-multiplied by `α`. The `type` parameter is used to specify the type of the [`QuantumObject`](@ref), either `Operator` or `SuperOperator`. The `f` parameter is used to pre-apply a function to the operators before converting them to SciML operators.
 
@@ -99,7 +99,7 @@ Quantum Object:   type=Operator   dims=[10, 2]   size=(20, 20)   ishermitian=fal
 ⎢⠀⠀⠀⠀⠂⡑⢄⠀⠀⠀⎥
 ⎢⠀⠀⠀⠀⠀⠀⠂⡑⢄⠀⎥
 ⎣⠀⠀⠀⠀⠀⠀⠀⠀⠂⡑⎦
-````
+```
 """
 QobjEvo(
     op_func_list::Union{Tuple,AbstractQuantumObject},

src/steadystate.jl

@@ -65,26 +65,26 @@ end
 
 @doc raw"""
     steadystate(
-        H::QuantumObject,
+        H::QuantumObject{DT,OpType},
         c_ops::Union{Nothing,AbstractVector,Tuple} = nothing;
         solver::SteadyStateSolver = SteadyStateDirectSolver(),
-        kwargs...
+        kwargs...,
     )
 
 Solve the stationary state based on different solvers.
 
 # Parameters
-- `H::QuantumObject`: The Hamiltonian or the Liouvillian of the system.
-- `c_ops::Union{Nothing,AbstractVector,Tuple}=nothing`: The list of the collapse operators.
-- `solver::SteadyStateSolver=SteadyStateDirectSolver()`: see documentation [Solving for Steady-State Solutions](@ref doc:Solving-for-Steady-State-Solutions) for different solvers.
-- `kwargs...`: The keyword arguments for the solver.
+- `H`: The Hamiltonian or the Liouvillian of the system.
+- `c_ops`: The list of the collapse operators.
+- `solver`: see documentation [Solving for Steady-State Solutions](@ref doc:Solving-for-Steady-State-Solutions) for different solvers.
+- `kwargs`: The keyword arguments for the solver.
 """
 function steadystate(
-    H::QuantumObject{<:AbstractArray,OpType},
+    H::QuantumObject{DT,OpType},
     c_ops::Union{Nothing,AbstractVector,Tuple} = nothing;
     solver::SteadyStateSolver = SteadyStateDirectSolver(),
     kwargs...,
-) where {OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}}
+) where {DT,OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}}
     L = liouvillian(H, c_ops)
 
     return _steadystate(L, solver; kwargs...)
@@ -185,14 +185,14 @@ _steadystate(
 
 @doc raw"""
     steadystate(
-        H::QuantumObject,
-        ψ0::QuantumObject,
+        H::QuantumObject{DT1,HOpType},
+        ψ0::QuantumObject{DT2,StateOpType},
         tmax::Real = Inf,
         c_ops::Union{Nothing,AbstractVector,Tuple} = nothing;
         solver::SteadyStateODESolver = SteadyStateODESolver(),
         reltol::Real = 1.0e-8,
         abstol::Real = 1.0e-10,
-        kwargs...
+        kwargs...,
     )
 
 Solve the stationary state based on time evolution (ordinary differential equations; `OrdinaryDiffEq.jl`) with a given initial state.
@@ -210,14 +210,14 @@ or
 ```
 
 # Parameters
-- `H::QuantumObject`: The Hamiltonian or the Liouvillian of the system.
-- `ψ0::QuantumObject`: The initial state of the system.
-- `tmax::Real=Inf`: The final time step for the steady state problem.
-- `c_ops::Union{Nothing,AbstractVector,Tuple}=nothing`: The list of the collapse operators.
-- `solver::SteadyStateODESolver=SteadyStateODESolver()`: see [`SteadyStateODESolver`](@ref) for more details.
-- `reltol::Real=1.0e-8`: Relative tolerance in steady state terminate condition and solver adaptive timestepping.
-- `abstol::Real=1.0e-10`: Absolute tolerance in steady state terminate condition and solver adaptive timestepping.
-- `kwargs...`: The keyword arguments for the ODEProblem.
+- `H`: The Hamiltonian or the Liouvillian of the system.
+- `ψ0`: The initial state of the system.
+- `tmax=Inf`: The final time step for the steady state problem.
+- `c_ops=nothing`: The list of the collapse operators.
+- `solver`: see [`SteadyStateODESolver`](@ref) for more details.
+- `reltol=1.0e-8`: Relative tolerance in steady state terminate condition and solver adaptive timestepping.
+- `abstol=1.0e-10`: Absolute tolerance in steady state terminate condition and solver adaptive timestepping.
+- `kwargs`: The keyword arguments for the ODEProblem.
 """
 function steadystate(
     H::QuantumObject{DT1,HOpType},