Merge pull request #738 from control-toolbox/auto-juliaformatter-pr

[AUTO] JuliaFormatter.jl run

Author: ocots

test/helpers/print_utils.jl

@@ -291,7 +291,11 @@ function print_test_line(
 
     # Error: scientific notation with 2 decimal places
     err_str = rel_error === missing ? "N/A" : @sprintf("%.2e", rel_error / 100)  # Convert to fraction then scientific format
-    err_color = rel_error === missing ? :white : (rel_error < 1 ? :green : (rel_error < 5 ? :yellow : :red))
+    err_color = if rel_error === missing
+        :white
+    else
+        (rel_error < 1 ? :green : (rel_error < 5 ? :yellow : :red))
+    end
     printstyled(lpad(err_str, 7); color=err_color)
 
     # Memory: optional, right-aligned, 10 characters

test/problems/double_integrator.jl

@@ -33,25 +33,25 @@ function DoubleIntegratorTime()
     xf = [0.0, 0.0]
     u_max = 1.0
     u_min = -1.0
-    
+
     @def ocp begin
         tf ∈ R, variable
         t ∈ [0, tf], time
         x = (q, v) ∈ R², state
         u ∈ R, control
-        
+
         -1 ≤ u(t) ≤ 1
-        
+
         q(0) == -1
         v(0) == 0
         q(tf) == 0
         v(tf) == 0
-        
+
         ẋ(t) == [v(t), u(t)]
-        
+
         tf → min
     end
-    
+
     return (
         ocp=ocp,
         obj=2.0,
@@ -62,7 +62,7 @@ function DoubleIntegratorTime()
         t0=t0,
         tf=2.0,
         u_max=u_max,
-        u_min=u_min
+        u_min=u_min,
     )
 end
 
@@ -93,22 +93,31 @@ function DoubleIntegratorEnergy()
     tf = 1.0
     x0 = [-1.0, 0.0]
     xf = [0.0, 0.0]
-    
+
     @def ocp begin
         t ∈ [0, 1], time
         x = (q, v) ∈ R², state
         u ∈ R, control
-        
+
         x(0) == [-1, 0]
         x(1) == [0, 0]
-        
+
         ∂(q)(t) == v(t)
         ∂(v)(t) == u(t)
-        
+
         0.5∫(u(t)^2) → min
     end
-    
-    return (ocp=ocp, obj=6.0, name="double_integrator_energy", init=nothing, x0=x0, xf=xf, t0=t0, tf=tf)
+
+    return (
+        ocp=ocp,
+        obj=6.0,
+        name="double_integrator_energy",
+        init=nothing,
+        x0=x0,
+        xf=xf,
+        t0=t0,
+        tf=tf,
+    )
 end
 
 """
@@ -141,23 +150,23 @@ function DoubleIntegratorEnergyConstrained()
     x0 = [-1.0, 0.0]
     xf = [0.0, 0.0]
     v_max = 1.2
-    
+
     @def ocp begin
         t ∈ [0, 1], time
         x = (q, v) ∈ R², state
         u ∈ R, control
-        
+
         v(t) ≤ 1.2
-        
+
         x(0) == [-1, 0]
         x(1) == [0, 0]
-        
+
         ∂(q)(t) == v(t)
         ∂(v)(t) == u(t)
-        
+
         0.5∫(u(t)^2) → min
     end
-    
+
     return (
         ocp=ocp,
         obj=7.680030,
@@ -167,6 +176,6 @@ function DoubleIntegratorEnergyConstrained()
         xf=xf,
         t0=t0,
         tf=tf,
-        v_max=v_max
+        v_max=v_max,
     )
 end

test/problems/quadrotor.jl

@@ -6,7 +6,6 @@
 #   - name :: a short problem name
 #   - init :: NamedTuple of components for CTSolvers.initial_guess
 function Quadrotor(; T=1, g=9.8, r=0.1)
-
     ocp = @def begin
         t ∈ [0, T], time
         x ∈ R⁹, state
@@ -46,9 +45,9 @@ function Quadrotor(; T=1, g=9.8, r=0.1)
     end
 
     init = @init ocp begin
-        x(t) := 0.1 * ones(9) 
-        u(t) := 0.1 * ones(4) 
+        x(t) := 0.1 * ones(9)
+        u(t) := 0.1 * ones(4)
     end
 
     return (ocp=ocp, obj=4.2679623758, name="quadrotor", init=init)
-end
+end

test/problems/transfer.jl

@@ -53,8 +53,8 @@ function F3(x)
 end
 
 function Transfer(; Tmax=60)
-
-    cTmax = 3600^2 / 1e6; T = Tmax * cTmax     # Conversion from Newtons to kg x Mm / h²
+    cTmax = 3600^2 / 1e6;
+    T = Tmax * cTmax     # Conversion from Newtons to kg x Mm / h²
     mass0 = 1500                               # Initial mass of the spacecraft
     β = 1.42e-02                               # Engine specific impulsion
     P0 = 11.625                                # Initial semilatus rectum
@@ -67,7 +67,7 @@ function Transfer(; Tmax=60)
     Lf = 3π                                    # Estimation of final longitude
     x0 = [P0, ex0, ey0, hx0, hy0, L0]          # Initial state
     xf = [Pf, exf, eyf, hxf, hyf, Lf]          # Final state
-    
+
     ocp = @def begin
         tf ∈ R, variable
         t ∈ [0, tf], time
@@ -76,17 +76,18 @@ function Transfer(; Tmax=60)
         x(0) == x0
         x[1:5](tf) == xf[1:5]
         mass = mass0 - β * T * t
-        ẋ(t) == F0(x(t)) + T / mass * (u₁(t) * F1(x(t)) + u₂(t) * F2(x(t)) + u₃(t) * F3(x(t)))
+        ẋ(t) ==
+        F0(x(t)) + T / mass * (u₁(t) * F1(x(t)) + u₂(t) * F2(x(t)) + u₃(t) * F3(x(t)))
         u₁(t)^2 + u₂(t)^2 + u₃(t)^2 ≤ 1
         tf → min
     end
-    
-    init = @init ocp begin 
+
+    init = @init ocp begin
         tf_i = 15
         x(t) := x0 + (xf - x0) * t / tf_i       # Linear interpolation
-        u(t) := [0.1, 0.5, 0.]                  # Initial guess for the control
+        u(t) := [0.1, 0.5, 0.0]                  # Initial guess for the control
         tf := tf_i                              # Initial guess for final time
     end
-    
+
     return (ocp=ocp, obj=14.79643132, name="transfer", init=init)
-end
+end

test/suite/indirect/test_double_integrator_energy.jl

@@ -6,8 +6,8 @@
 
 module TestDoubleIntegratorEnergy
 
-import Test
-import OptimalControl
+using Test: Test
+using OptimalControl: OptimalControl
 import NonlinearSolve: NonlinearProblem, solve
 import LinearAlgebra: norm
 import OrdinaryDiffEq: OrdinaryDiffEq
@@ -21,11 +21,11 @@ const SHOWTIMING = isdefined(Main, :TestOptions) ? Main.TestOptions.SHOWTIMING :
 
 function test_double_integrator_energy()
     Test.@testset "Double Integrator Energy Minimization" verbose=VERBOSE showtiming=SHOWTIMING begin
-        
+
         # ====================================================================
         # INTEGRATION TEST - Unconstrained Energy Minimization
         # ====================================================================
-        
+
         Test.@testset "Unconstrained singular control" begin
             # Get problem from TestProblems
             prob_data = TestProblems.DoubleIntegratorEnergy()
@@ -35,36 +35,36 @@ function test_double_integrator_energy()
             t0 = prob_data.t0
             tf = prob_data.tf
             obj_ref = prob_data.obj
-            
+
             # Singular control: u(x, p) = p₂
             u(x, p) = p[2]
-            
+
             # Hamiltonian flow
             f = OptimalControl.Flow(ocp, u)
-            
+
             # State projection
             π((x, p)) = x
-            
+
             # Shooting function
             S(p0) = π(f(t0, x0, p0, tf)) - xf
-            
+
             # Known solution (from documentation)
             p0_ref = [12.0, 6.0]
-            
+
             # Test shooting function with known solution
             s = S(p0_ref)
-            
+
             # Verify solution (should be close to zero)
             Test.@test norm(s) < 1e-6
-            
+
             # Note: We don't test the objective value directly here since
             # we're testing the shooting method, not the full solution
         end
-        
+
         # ====================================================================
         # INTEGRATION TEST - Constrained Energy Minimization
         # ====================================================================
-        
+
         Test.@testset "Constrained three-arc structure" begin
             # Get problem from TestProblems
             prob_data = TestProblems.DoubleIntegratorEnergyConstrained()
@@ -74,18 +74,20 @@ function test_double_integrator_energy()
             t0 = prob_data.t0
             tf = prob_data.tf
             v_max = prob_data.v_max
-            
+
             # Flow for unconstrained extremals (singular control u = p₂)
             f_interior = OptimalControl.Flow(ocp, (x, p) -> p[2])
-            
+
             # Boundary control and constraint
             ub = 0.0                    # boundary control
             g(x) = v_max - x[2]         # constraint: g(x) ≥ 0
             μ(p) = p[1]                 # dual variable
-            
+
             # Flow for boundary extremals
-            f_boundary = OptimalControl.Flow(ocp, (x, p) -> ub, (x, u) -> g(x), (x, p) -> μ(p))
-            
+            f_boundary = OptimalControl.Flow(
+                ocp, (x, p) -> ub, (x, u) -> g(x), (x, p) -> μ(p)
+            )
+
             # Shooting function
             function shoot!(s, p0, t1, t2)
                 x_t0, p_t0 = x0, p0
@@ -96,19 +98,19 @@ function test_double_integrator_energy()
                 s[3] = g(x_t1)          # constraint activation at entry
                 s[4] = p_t1[2]          # switching condition
             end
-            
+
             # Known solution (from documentation)
             p0_ref = [38.4, 9.6]
             t1_ref = 0.25
             t2_ref = 0.75
-            
+
             # Test shooting function with known solution
             s = zeros(4)
             shoot!(s, p0_ref, t1_ref, t2_ref)
-            
+
             # Verify solution (should be close to zero)
             Test.@test norm(s) < 1e-6
-            
+
             # Note: obj_ref is nothing for this problem (no reference value available)
         end
     end

test/suite/indirect/test_double_integrator_time.jl

@@ -6,8 +6,8 @@
 
 module TestDoubleIntegratorTime
 
-import Test
-import OptimalControl
+using Test: Test
+using OptimalControl: OptimalControl
 import NonlinearSolve: NonlinearProblem, solve
 import LinearAlgebra: norm
 import OrdinaryDiffEq: OrdinaryDiffEq
@@ -21,11 +21,11 @@ const SHOWTIMING = isdefined(Main, :TestOptions) ? Main.TestOptions.SHOWTIMING :
 
 function test_double_integrator_time()
     Test.@testset "Double Integrator Time Minimization" verbose=VERBOSE showtiming=SHOWTIMING begin
-        
+
         # ====================================================================
         # INTEGRATION TEST - Bang-Bang Shooting Method
         # ====================================================================
-        
+
         Test.@testset "Bang-bang shooting with switching time" begin
             # Get problem from TestProblems
             prob_data = TestProblems.DoubleIntegratorTime()
@@ -36,14 +36,14 @@ function test_double_integrator_time()
             u_max = prob_data.u_max
             u_min = prob_data.u_min
             obj_ref = prob_data.obj
-            
+
             # Pseudo-Hamiltonian: H(x, p, u) = p₁v + p₂u - 1
             H(x, p, u) = p[1] * x[2] + p[2] * u - 1
-            
+
             # Hamiltonian flows for bang-bang control
             f_max = OptimalControl.Flow(ocp, (x, p, tf) -> u_max)
             f_min = OptimalControl.Flow(ocp, (x, p, tf) -> u_min)
-            
+
             # Shooting function
             function shoot!(s, p0, t1, tf)
                 x_t0, p_t0 = x0, p0
@@ -53,19 +53,19 @@ function test_double_integrator_time()
                 s[3] = p_t1[2]                        # switching condition
                 s[4] = H(x_tf, p_tf, u_min)           # free final time
             end
-            
+
             # Known solution (from documentation)
             p0_ref = [1.0, 1.0]
             t1_ref = 1.0
             tf_ref = 2.0
-            
+
             # Test shooting function with known solution
             s = zeros(4)
             shoot!(s, p0_ref, t1_ref, tf_ref)
-            
+
             # Verify solution (should be close to zero)
             Test.@test norm(s) < 1e-6
-            
+
             # Verify objective value
             Test.@test tf_ref ≈ obj_ref atol=1e-6
         end