🤖 Format .jl files

Author: ocots

docs/extras/disc.jl

@@ -10,7 +10,6 @@ vmax = 0.1  # maximal authorized speed
 mf = 0.6    # final mass to target
 
 ocp = @def begin # definition of the optimal control problem
-
     tf ∈ R, variable
     t ∈ [t0, tf], time
     x = (r, v, m) ∈ R³, state
@@ -25,7 +24,6 @@ ocp = @def begin # definition of the optimal control problem
     ẋ(t) == F0(x(t)) + u(t) * F1(x(t))
 
     r(tf) → max
-
 end;
 
 # Dynamics
@@ -37,17 +35,19 @@ b = 2
 F0(x) = begin
     r, v, m = x
     D = Cd * v^2 * exp(-β*(r - 1)) # Drag force
-    return [ v, -D/m - 1/r^2, 0 ]
+    return [v, -D/m - 1/r^2, 0]
 end
 
 F1(x) = begin
     r, v, m = x
-    return [ 0, Tmax/m, -b*Tmax ]
+    return [0, Tmax/m, -b*Tmax]
 end
 
 # Solve the problem with different discretization methods
 solutions = []
-schemes = [:trapeze, :midpoint, :euler, :euler_implicit, :gauss_legendre_2, :gauss_legendre_3]
+schemes = [
+    :trapeze, :midpoint, :euler, :euler_implicit, :gauss_legendre_2, :gauss_legendre_3
+]
 for scheme in schemes
     sol = solve(ocp; disc_method=scheme, tol=1e-8, display=false)
     push!(solutions, (scheme, sol))
@@ -71,30 +71,27 @@ using DataFrames
 using BenchmarkTools
 
 # DataFrame to store the results
-data = DataFrame(
+data = DataFrame(;
     Backend=Symbol[],
     NNZO=Int[],
     NNZJ=Int[],
     NNZH=Int[],
     PrepTime=Float64[],
     ExecTime=Float64[],
-    Objective=Float64[], 
-    Iterations=Int[]
+    Objective=Float64[],
+    Iterations=Int[],
 )
 
 # The different AD backends to test
 backends = [:optimized, :manual]
 
 # Loop over the backends
 for adnlp_backend in backends
-
     println("Testing backend: ", adnlp_backend)
 
     # Discretize the problem with a large grid size and Gauss-Legendre method
-    bt = @btimed direct_transcription($ocp; 
-        disc_method=:euler, 
-        grid_size=1000, 
-        adnlp_backend=$adnlp_backend,
+    bt = @btimed direct_transcription(
+        $ocp; disc_method=:euler, grid_size=1000, adnlp_backend=($adnlp_backend)
     )
     docp, nlp = bt.value
     prepa_time = bt.time
@@ -105,27 +102,23 @@ for adnlp_backend in backends
     nnzh = get_nnzh(nlp) # Hessian of the Lagrangian
 
     # Solve the problem
-    bt = @btimed ipopt($nlp; 
-        print_level=0, 
-        mu_strategy="adaptive", 
-        tol=1e-8,
-        sb="yes",
-    )
+    bt = @btimed ipopt($nlp; print_level=0, mu_strategy="adaptive", tol=1e-8, sb="yes")
     nlp_sol = bt.value
     exec_time = bt.time
 
     # Store the results in the DataFrame
-    push!(data, 
+    push!(
+        data,
         (
-            Backend=adnlp_backend, 
-            NNZO=nnzo, 
-            NNZJ=nnzj, 
-            NNZH=nnzh, 
-            PrepTime=prepa_time, 
-            ExecTime=exec_time, 
-            Objective=-nlp_sol.objective, 
-            Iterations=nlp_sol.iter
-        )
+            Backend=adnlp_backend,
+            NNZO=nnzo,
+            NNZJ=nnzj,
+            NNZH=nnzh,
+            PrepTime=prepa_time,
+            ExecTime=exec_time,
+            Objective=(-nlp_sol.objective),
+            Iterations=nlp_sol.iter,
+        ),
     )
 end
-println(data)
+println(data)

docs/extras/iss.jl

@@ -7,9 +7,8 @@ const t0 = 0
 const tf = 1
 const x0 = -1
 const xf = 0
-const α  = 1.5
+const α = 1.5
 ocp = @def begin
-
     t ∈ [t0, tf], time
     x ∈ R, state
     u ∈ R, control
@@ -19,8 +18,7 @@ ocp = @def begin
 
     ẋ(t) == -x(t) + α * x(t)^2 + u(t)
 
-    ∫( 0.5u(t)^2 ) → min
-    
+    ∫(0.5u(t)^2) → min
 end
 nothing # hide
 
@@ -29,7 +27,7 @@ u(x, p) = p
 
 π((x, p)) = x
 
-S(p0) = π( φ(t0, x0, p0, tf) ) - xf    # shooting function
+S(p0) = π(φ(t0, x0, p0, tf)) - xf    # shooting function
 
 ξ = [0.1]    # initial guess
 
@@ -40,19 +38,20 @@ function fsolve(f, j, x; kwargs...)
     catch e
         println("Erreur using MINPACK")
         println(e)
-        println("hybrj not supported. Replaced by hybrd even if it is not visible on the doc.")
+        println(
+            "hybrj not supported. Replaced by hybrd even if it is not visible on the doc."
+        )
         MINPACK.fsolve(f, x; kwargs...)
     end
 end
 
 using DifferentiationInterface
-import ForwardDiff
+using ForwardDiff: ForwardDiff
 backend = AutoForwardDiff()
 
-nle!  = ( s, ξ) -> s[1] = S(ξ[1])                                 # auxiliary function
+nle! = (s, ξ) -> s[1] = S(ξ[1])                                 # auxiliary function
 jnle! = (js, ξ) -> jacobian!(nle!, similar(ξ), js, backend, ξ)    # 
 
-
 indirect_sol = fsolve(nle!, jnle!, ξ; show_trace=true)    # resolution of S(p0) = 0
 p0_sol = indirect_sol.x[1]                                # costate solution
 println("\ncostate:    p0 = ", p0_sol)
@@ -61,71 +60,85 @@ println("shoot: |S(p0)| = ", abs(S(p0_sol)), "\n")
 sol = φ((t0, tf), x0, p0_sol)
 plot(sol)
 
-using Plots.PlotMeasures 
-function Plots.plot(S::Function, p0::Float64; Np0=20, kwargs...) 
- 
+using Plots.PlotMeasures
+function Plots.plot(S::Function, p0::Float64; Np0=20, kwargs...)
+
     # times for wavefronts
-    times = range(t0, tf, length=3)
+    times = range(t0, tf; length=3)
 
     # times for trajectories
-    tspan = range(t0, tf, length=100)
+    tspan = range(t0, tf; length=100)
 
     # interval of initial covector
-    p0_min = -0.5 
-    p0_max = 2 
+    p0_min = -0.5
+    p0_max = 2
 
     # covector solution
-    p0_sol = p0 
- 
+    p0_sol = p0
+
     # plot of the flow in phase space
-    plt_flow = plot() 
-    p0s = range(p0_min, p0_max, length=Np0) 
-    for i ∈ eachindex(p0s) 
+    plt_flow = plot()
+    p0s = range(p0_min, p0_max; length=Np0)
+    for i in eachindex(p0s)
         sol = φ((t0, tf), x0, p0s[i])
         x = state(sol).(tspan)
         p = costate(sol).(tspan)
-        label = i==1 ? "extremals" : false 
-        plot!(plt_flow, x, p, color=:blue, label=label) 
-    end 
- 
+        label = i==1 ? "extremals" : false
+        plot!(plt_flow, x, p; color=:blue, label=label)
+    end
+
     # plot of wavefronts in phase space 
-    p0s = range(p0_min, p0_max, length=200) 
-    xs  = zeros(length(p0s), length(times)) 
-    ps  = zeros(length(p0s), length(times)) 
-    for i ∈ eachindex(p0s) 
-        sol = φ((t0, tf), x0, p0s[i], saveat=times)
-        xs[i, :] .= state(sol).(times) 
-        ps[i, :] .= costate(sol).(times) 
-    end 
-    for j ∈ eachindex(times) 
-        label = j==1 ? "flow at times" : false 
-        plot!(plt_flow, xs[:, j], ps[:, j], color=:green, linewidth=2, label=label) 
-    end 
- 
+    p0s = range(p0_min, p0_max; length=200)
+    xs = zeros(length(p0s), length(times))
+    ps = zeros(length(p0s), length(times))
+    for i in eachindex(p0s)
+        sol = φ((t0, tf), x0, p0s[i]; saveat=times)
+        xs[i, :] .= state(sol).(times)
+        ps[i, :] .= costate(sol).(times)
+    end
+    for j in eachindex(times)
+        label = j==1 ? "flow at times" : false
+        plot!(plt_flow, xs[:, j], ps[:, j]; color=:green, linewidth=2, label=label)
+    end
+
     #  
-    plot!(plt_flow, xlims=(-1.1, 1), ylims=(p0_min, p0_max)) 
-    plot!(plt_flow, [0, 0], [p0_min, p0_max], color=:black, xlabel="x", ylabel="p", label="x=xf") 
-     
+    plot!(plt_flow; xlims=(-1.1, 1), ylims=(p0_min, p0_max))
+    plot!(
+        plt_flow,
+        [0, 0],
+        [p0_min, p0_max];
+        color=:black,
+        xlabel="x",
+        ylabel="p",
+        label="x=xf",
+    )
+
     # solution 
     sol = φ((t0, tf), x0, p0_sol)
     x = state(sol).(tspan)
     p = costate(sol).(tspan)
-    plot!(plt_flow, x, p, color=:red, linewidth=2, label="extremal solution") 
-    plot!(plt_flow, [x[end]], [p[end]], seriestype=:scatter, color=:green, label=false) 
- 
+    plot!(plt_flow, x, p; color=:red, linewidth=2, label="extremal solution")
+    plot!(plt_flow, [x[end]], [p[end]]; seriestype=:scatter, color=:green, label=false)
+
     # plot of the shooting function  
-    p0s = range(p0_min, p0_max, length=200) 
-    plt_shoot = plot(xlims=(p0_min, p0_max), ylims=(-2, 4), xlabel="p₀", ylabel="y") 
-    plot!(plt_shoot, p0s, S, linewidth=2, label="S(p₀)", color=:green) 
-    plot!(plt_shoot, [p0_min, p0_max], [0, 0], color=:black, label="y=0") 
-    plot!(plt_shoot, [p0_sol, p0_sol], [-2, 0], color=:black, label="p₀ solution", linestyle=:dash) 
-    plot!(plt_shoot, [p0_sol], [0], seriestype=:scatter, color=:green, label=false) 
- 
+    p0s = range(p0_min, p0_max; length=200)
+    plt_shoot = plot(; xlims=(p0_min, p0_max), ylims=(-2, 4), xlabel="p₀", ylabel="y")
+    plot!(plt_shoot, p0s, S; linewidth=2, label="S(p₀)", color=:green)
+    plot!(plt_shoot, [p0_min, p0_max], [0, 0]; color=:black, label="y=0")
+    plot!(
+        plt_shoot,
+        [p0_sol, p0_sol],
+        [-2, 0];
+        color=:black,
+        label="p₀ solution",
+        linestyle=:dash,
+    )
+    plot!(plt_shoot, [p0_sol], [0]; seriestype=:scatter, color=:green, label=false)
+
     # final plot 
-    plot(plt_flow, plt_shoot; layout=(1,2), leftmargin=15px, bottommargin=15px, kwargs...) 
- 
+    plot(plt_flow, plt_shoot; layout=(1, 2), leftmargin=15px, bottommargin=15px, kwargs...)
 end
 
 p0_sol
 
-plot(S, p0_sol; size=(800, 450))
+plot(S, p0_sol; size=(800, 450))