Format code and add expv coverage

Author: krugx

ext/QuantumPropagatorsExponentialUtilitiesExt.jl

@@ -29,8 +29,11 @@ LinearAlgebra.ishermitian(op::_SizedOp) = LinearAlgebra.ishermitian(op.A)
 LinearAlgebra.mul!(y, op::_SizedOp, x) = mul!(y, op.A, x)
 
 _ensure_size_dim(A) =
-    hasmethod(size, Tuple{typeof(A), Int}) ? A :
-    (hasmethod(size, Tuple{typeof(A)}) ? _SizedOp(A) : A)
+    if hasmethod(size, Tuple{typeof(A),Int})
+        A
+    else
+        (hasmethod(size, Tuple{typeof(A)}) ? _SizedOp(A) : A)
+    end
 
 
 """Propagator for Krylov expv propagation via ExponentialUtilities (`method=ExponentialUtilities`).
@@ -85,7 +88,7 @@ expv_propagator = init_prop(
 )
 ```
 
-initializes an [`ExpvPropagator`](@ref).
+ initializes an `ExpvPropagator`.
 
 # Method-specific keyword arguments
 
@@ -121,7 +124,7 @@ function init_prop(
     t = tlist[1]
     if backward
         n = length(tlist) - 1
-        t = float(tlist[n + 1])
+        t = float(tlist[n+1])
     end
     GT = typeof(generator)
     OT = typeof(G)
@@ -154,16 +157,18 @@ function prop_step!(propagator::ExpvPropagator)
     @timeit_debug propagator.timing_data "prop_step!" begin
         if nameof(typeof(propagator.state)) == :GradVector &&
            nameof(parentmodule(typeof(propagator.state))) == :QuantumGradientGenerators
-            throw(ArgumentError(
-                "ExponentialUtilities propagation does not support GRAPE `gradient_method=:gradgen`. " *
-                "Use `gradient_method=:taylor` instead."
-            ))
+            throw(
+                ArgumentError(
+                    "ExponentialUtilities propagation does not support GRAPE `gradient_method=:gradgen`. " *
+                    "Use `gradient_method=:taylor` instead."
+                )
+            )
         end
         H = propagator.genop
         n = propagator.n
         tlist = getfield(propagator, :tlist)
         (0 < n < length(tlist)) || return nothing
-        dt = tlist[n + 1] - tlist[n]
+        dt = tlist[n+1] - tlist[n]
         if propagator.backward
             dt = -dt
         end

src/newton.jl

@@ -34,7 +34,7 @@ mutable struct NewtonWrk{T}
     restarts::Int64
     m_max::Int64
     timing_data::TimerOutput
-    function NewtonWrk(v0::T; m_max::Int64=10, _timing_data=TimerOutput()) where {T}
+    function NewtonWrk(v0::T; m_max::Int64 = 10, _timing_data = TimerOutput()) where {T}
         if m_max <= 2
             error("Newton propagation requires m_max > 2")
         end
@@ -60,8 +60,8 @@ mutable struct NewtonWrk{T}
 end
 
 
-lbound(array::OffsetArray, dim=1) = first(axes(array)[dim])
-ubound(array::OffsetArray, dim=1) = last(axes(array)[dim])
+lbound(array::OffsetArray, dim = 1) = first(axes(array)[dim])
+ubound(array::OffsetArray, dim = 1) = last(axes(array)[dim])
 
 
 function leja_radius(z)
@@ -281,9 +281,9 @@ function newton!(Ψ, H, dt, wrk; kwargs...)
                 wrk.v,
                 H,
                 _dt;
-                extended=true,
-                norm_min=norm_min,
-                _timing_data=wrk.timing_data
+                extended = true,
+                norm_min = norm_min,
+                _timing_data = wrk.timing_data
             )
         end
         if m == 1 && s == 0
@@ -294,7 +294,7 @@ function newton!(Ψ, H, dt, wrk; kwargs...)
             break
         end
         @timeit_debug wrk.timing_data "diagonalize_hessenberg_matrix" begin
-            ritz = diagonalize_hessenberg_matrix(Hess, m, accumulate=true)
+            ritz = diagonalize_hessenberg_matrix(Hess, m, accumulate = true)
         end
 
         # In the first iteration, the radius will be determined

test/runtests.jl

@@ -98,7 +98,9 @@ using SafeTestsets
         include("test_grape_exponentialutilities.jl")
     end
 
-    println("\n* GRAPE ExponentialUtilities Liouvillian (test_grape_exputils_liouvillian.jl):")
+    println(
+        "\n* GRAPE ExponentialUtilities Liouvillian (test_grape_exputils_liouvillian.jl):"
+    )
     @time @safetestset "GRAPE ExponentialUtilities Liouvillian" begin
         include("test_grape_exputils_liouvillian.jl")
     end

test/test_grape_exponentialutilities.jl

@@ -9,21 +9,21 @@ using ExponentialUtilities
 @testset "GRAPE with ExponentialUtilities" begin
     rng = StableRNG(20260204)
     problem = dummy_control_problem(
-        N=4,
-        n_trajectories=1,
-        n_controls=1,
-        n_steps=10,
-        dt=0.1,
-        density=1.0,
-        hermitian=true,
-        complex_operators=true,
-        prop_method=ExponentialUtilities,
-        J_T=J_T_sm,
-        iter_stop=1,
-        rng=rng
+        N = 4,
+        n_trajectories = 1,
+        n_controls = 1,
+        n_steps = 10,
+        dt = 0.1,
+        density = 1.0,
+        hermitian = true,
+        complex_operators = true,
+        prop_method = ExponentialUtilities,
+        J_T = J_T_sm,
+        iter_stop = 1,
+        rng = rng
     )
 
-    res = QuantumControl.optimize(problem; method=GRAPE, iter_stop=1, verbose=false)
+    res = QuantumControl.optimize(problem; method = GRAPE, iter_stop = 1, verbose = false)
 
     @test res.iter >= res.iter_start
     @test isfinite(res.J_T)

test/test_grape_exputils_liouvillian.jl

@@ -17,14 +17,14 @@ function qubit_lvn(eps)
 
     H0 = 1 / 2 * sigma_z
 
-    return liouvillian((H0, (sigma_x, eps[1])); convention=:TDSE)
+    return liouvillian((H0, (sigma_x, eps[1])); convention = :TDSE)
 end
 
 @testset "GRAPE ExponentialUtilities Liouvillian" begin
     # Pulse Parameters (Same as unitary)
     tf = 20ns
     Nsteps = 100
-    tgrid = collect(range(0, tf; length=Nsteps + 1))
+    tgrid = collect(range(0, tf; length = Nsteps + 1))
 
     # Target gate on the qubit subspace (embed 2×2 into 3×3)
     U_tgt = ComplexF64[0 1; 1 0]
@@ -38,33 +38,34 @@ end
     basis_tgt = [U_tgt * b * U_tgt' for b in basis]
 
     eps = [
-        0.2 * (1 + 0.05 * rand()) *
-        QuantumControl.Shapes.flattop.(tgrid, T=tf, t_rise=0.3, func=:blackman)
-        for _ in 1:2
+        0.2 *
+        (1 + 0.05 * rand()) *
+        QuantumControl.Shapes.flattop.(tgrid, T = tf, t_rise = 0.3, func = :blackman)
+        for _ = 1:2
     ]
 
     lvn = qubit_lvn(eps)
 
     trajectories = [
         Trajectory(
-            initial_state=reshape(basis[i], :),
-            generator=lvn,
-            target_state=reshape(basis_tgt[i], :)
+            initial_state = reshape(basis[i], :),
+            generator = lvn,
+            target_state = reshape(basis_tgt[i], :)
         ) for i in eachindex(basis)
     ]
 
     problem = ControlProblem(
-        trajectories=trajectories,
-        tlist=tgrid,
-        iter_stop=10,
-        prop_method=:expv,
-        gradient_method=:taylor,
-        prop_expv_kwargs=(; ishermitian=false),
-        J_T=QuantumControl.Functionals.J_T_re
+        trajectories = trajectories,
+        tlist = tgrid,
+        iter_stop = 10,
+        prop_method = :expv,
+        gradient_method = :taylor,
+        prop_expv_kwargs = (; ishermitian = false),
+        J_T = QuantumControl.Functionals.J_T_re
     )
 
     println("Starting optimization with QuantumPropagators: ExponentialUtilities...")
-    result = QuantumControl.optimize(problem; method=GRAPE, print_iters=true)
+    result = QuantumControl.optimize(problem; method = GRAPE, print_iters = true)
     display(result)
 
     @test isfinite(result.J_T)
@@ -73,7 +74,7 @@ end
 @testset "GRAPE ExponentialUtilities Gradgen Error" begin
     tf = 1.0
     Nsteps = 10
-    tgrid = collect(range(0, tf; length=Nsteps + 1))
+    tgrid = collect(range(0, tf; length = Nsteps + 1))
 
     basis = Matrix{ComplexF64}[]
     push!(basis, [1 0; 0 0])
@@ -84,28 +85,28 @@ end
     U_tgt = ComplexF64[0 1; 1 0]
     basis_tgt = [U_tgt * b * U_tgt' for b in basis]
 
-    eps = [0.2 * QuantumControl.Shapes.flattop.(tgrid, T=tf, t_rise=0.3) for _ in 1:2]
+    eps = [0.2 * QuantumControl.Shapes.flattop.(tgrid, T = tf, t_rise = 0.3) for _ = 1:2]
     lvn = qubit_lvn(eps)
 
     trajectories = [
         Trajectory(
-            initial_state=reshape(basis[i], :),
-            generator=lvn,
-            target_state=reshape(basis_tgt[i], :),
+            initial_state = reshape(basis[i], :),
+            generator = lvn,
+            target_state = reshape(basis_tgt[i], :),
         ) for i in eachindex(basis)
     ]
 
     problem = ControlProblem(
-        trajectories=trajectories,
-        tlist=tgrid,
-        iter_stop=1,
-        prop_method=:expv,
-        prop_expv_kwargs=(; ishermitian=false),
-        grad_prop_method=:expv,
-        gradient_method=:gradgen,
-        J_T=QuantumControl.Functionals.J_T_re
+        trajectories = trajectories,
+        tlist = tgrid,
+        iter_stop = 1,
+        prop_method = :expv,
+        prop_expv_kwargs = (; ishermitian = false),
+        grad_prop_method = :expv,
+        gradient_method = :gradgen,
+        J_T = QuantumControl.Functionals.J_T_re
     )
 
-    res = QuantumControl.optimize(problem; method=GRAPE, print_iters=false)
+    res = QuantumControl.optimize(problem; method = GRAPE, print_iters = false)
     @test occursin("gradient_method=:gradgen", res.message)
 end