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

[AUTO] JuliaFormatter.jl run

Author: ocots

ext/JuMPModels/beam.jl

@@ -36,13 +36,13 @@ function OptimalControlProblems.beam(::JuMPBackend; nh::Int=500)
     @constraints(
         model,
         begin
-            ∂x1[t=1:nh], x1[t] == x1[t - 1] + 0.5 * step * (x2[t] + x2[t - 1])
-            ∂x2[t=1:nh], x2[t] == x2[t - 1] + 0.5 * step * (u[t] + u[t - 1])
+            ∂x1[t = 1:nh], x1[t] == x1[t - 1] + 0.5 * step * (x2[t] + x2[t - 1])
+            ∂x2[t = 1:nh], x2[t] == x2[t - 1] + 0.5 * step * (u[t] + u[t - 1])
         end
     )
 
     # objective
-    @objective(model, Min, 0.5 * step * sum(u[t]^2 + u[t-1]^2 for t in 1:nh))
+    @objective(model, Min, 0.5 * step * sum(u[t]^2 + u[t - 1]^2 for t in 1:nh))
 
     return model
 end

ext/JuMPModels/bioreactor.jl

@@ -48,36 +48,35 @@ function OptimalControlProblems.bioreactor(::JuMPBackend; nh::Int=500)
             step, T / nh
 
             # intermediate variables
-            growth[k=0:nh], μ2m * s[k] / (s[k] + Ks)
-            μ2[k=0:nh], growth[k]
+            growth[k = 0:nh], μ2m * s[k] / (s[k] + Ks)
+            μ2[k = 0:nh], growth[k]
 
-            days[k=0:nh], (k * step) / (halfperiod * 2)
-            tau[k=0:nh], (days[k] - floor(days[k])) * 2π
-            light[k=0:nh], max(0, sin(tau[k]))^2
-            μ[k=0:nh], light[k] * μbar
+            days[k = 0:nh], (k * step) / (halfperiod * 2)
+            tau[k = 0:nh], (days[k] - floor(days[k])) * 2π
+            light[k = 0:nh], max(0, sin(tau[k]))^2
+            μ[k = 0:nh], light[k] * μbar
 
             # dynamics
-            dy[k=0:nh], μ[k] * y[k] / (1 + y[k]) - (r + u[k]) * y[k]
-            ds[k=0:nh], -μ2[k] * b[k] + u[k] * β * (gamma * y[k] - s[k])
-            db[k=0:nh], (μ2[k] - u[k] * β) * b[k]
+            dy[k = 0:nh], μ[k] * y[k] / (1 + y[k]) - (r + u[k]) * y[k]
+            ds[k = 0:nh], -μ2[k] * b[k] + u[k] * β * (gamma * y[k] - s[k])
+            db[k = 0:nh], (μ2[k] - u[k] * β) * b[k]
 
             # objective
-            dc[k=0:nh], -μ2[k] * b[k] / (β + c)
-
+            dc[k = 0:nh], -μ2[k] * b[k] / (β + c)
         end
     )
 
     @constraints(
         model,
         begin
-            ∂y[k=1:nh], y[k] == y[k - 1] + 0.5 * step * (dy[k] + dy[k - 1])
-            ∂s[k=1:nh], s[k] == s[k - 1] + 0.5 * step * (ds[k] + ds[k - 1])
-            ∂b[k=1:nh], b[k] == b[k - 1] + 0.5 * step * (db[k] + db[k - 1])
+            ∂y[k = 1:nh], y[k] == y[k - 1] + 0.5 * step * (dy[k] + dy[k - 1])
+            ∂s[k = 1:nh], s[k] == s[k - 1] + 0.5 * step * (ds[k] + ds[k - 1])
+            ∂b[k = 1:nh], b[k] == b[k - 1] + 0.5 * step * (db[k] + db[k - 1])
         end
     )
 
     # objective
-    @objective(model, Min, 0.5 * step * sum(dc[k] + dc[k-1] for k in 1:nh))
+    @objective(model, Min, 0.5 * step * sum(dc[k] + dc[k - 1] for k in 1:nh))
 
     return model
 end

ext/JuMPModels/cart_pendulum.jl

@@ -5,7 +5,7 @@ The Cart-Pendulum Problem:
     The problem is formulated as a JuMP model, and can be found [here](https://arxiv.org/pdf/2303.16746).
 """
 function OptimalControlProblems.cart_pendulum(::JuMPBackend; nh::Int=500)
-    
+
     # parameters
     g = 9.81            # gravitation [m/s^2]
     L = 1               # pendulum length [m]
@@ -23,13 +23,13 @@ function OptimalControlProblems.cart_pendulum(::JuMPBackend; nh::Int=500)
     @variables(
         model,
         begin
-            0.1 <= tf,                      (start = 1.0)
-            ddx,                            (start = 0.1)
-            -max_x <= x[0:nh] <= max_x,     (start = 0.1)
-            -max_v <= v[0:nh] <= max_v,     (start = 0.1)
-            θ[0:nh],                        (start = 0.1)
-            ω[0:nh],                        (start = 0.1)
-            -max_f <= Fex[0:nh] <= max_f,   (start = 0.1)
+            0.1 <= tf, (start = 1.0)
+            ddx, (start = 0.1)
+            -max_x <= x[0:nh] <= max_x, (start = 0.1)
+            -max_v <= v[0:nh] <= max_v, (start = 0.1)
+            θ[0:nh], (start = 0.1)
+            ω[0:nh], (start = 0.1)
+            -max_f <= Fex[0:nh] <= max_f, (start = 0.1)
         end
     )
 
@@ -51,32 +51,33 @@ function OptimalControlProblems.cart_pendulum(::JuMPBackend; nh::Int=500)
         begin
             step, tf / nh
 
-            α_ddx[i=0:nh], 1 / (I + 0.25 * m * L^2) * 0.5 * L * m * (-ddx * cos(θ[i]) - g * sin(θ[i]))
-            
-            ddCOG_1[i=0:nh], - L * sin(θ[i]) * ω[i] + L / 2 * cos(θ[i]) * α_ddx[i] + ddx
-            ddCOG_2[i=0:nh],   L * cos(θ[i]) * ω[i] + L / 2 * sin(θ[i]) * α_ddx[i]
+            α_ddx[i = 0:nh],
+            1 / (I + 0.25 * m * L^2) * 0.5 * L * m * (-ddx * cos(θ[i]) - g * sin(θ[i]))
+
+            ddCOG_1[i = 0:nh], - L * sin(θ[i]) * ω[i] + L / 2 * cos(θ[i]) * α_ddx[i] + ddx
+            ddCOG_2[i = 0:nh], L * cos(θ[i]) * ω[i] + L / 2 * sin(θ[i]) * α_ddx[i]
 
-            FXFY_1[i=0:nh], m * ddCOG_1[i]
+            FXFY_1[i = 0:nh], m * ddCOG_1[i]
             #FXFY_2[i=0:nh], m * ddCOG_2[i] + m * g
 
-            eq[i=0:nh], -FXFY_1[i] + Fex[i] - mcart * ddx
+            eq[i = 0:nh], -FXFY_1[i] + Fex[i] - mcart * ddx
 
             J, mcart
-            c[i=0:nh], eq[i] - J * ddx
-
-            dv[i=0:nh], -1 / J * c[i]
-            dω[i=0:nh], 1 / (I + 0.25 * m * L^2) * 0.5 * L * m * (-dv[i] * cos(θ[i]) - g * sin(θ[i]))
+            c[i = 0:nh], eq[i] - J * ddx
 
+            dv[i = 0:nh], -1 / J * c[i]
+            dω[i = 0:nh],
+            1 / (I + 0.25 * m * L^2) * 0.5 * L * m * (-dv[i] * cos(θ[i]) - g * sin(θ[i]))
         end
     )
 
     @constraints(
         model,
         begin
-            ∂x[k=1:nh], x[k] == x[k - 1] + 0.5 * step * ( v[k] +  v[k - 1])
-            ∂v[k=1:nh], v[k] == v[k - 1] + 0.5 * step * (dv[k] + dv[k - 1])
-            ∂θ[k=1:nh], θ[k] == θ[k - 1] + 0.5 * step * ( ω[k] +  ω[k - 1])
-            ∂ω[k=1:nh], ω[k] == ω[k - 1] + 0.5 * step * (dω[k] + dω[k - 1])
+            ∂x[k = 1:nh], x[k] == x[k - 1] + 0.5 * step * (v[k] + v[k - 1])
+            ∂v[k = 1:nh], v[k] == v[k - 1] + 0.5 * step * (dv[k] + dv[k - 1])
+            ∂θ[k = 1:nh], θ[k] == θ[k - 1] + 0.5 * step * (ω[k] + ω[k - 1])
+            ∂ω[k = 1:nh], ω[k] == ω[k - 1] + 0.5 * step * (dω[k] + dω[k - 1])
         end
     )
 

ext/JuMPModels/chain.jl

@@ -22,23 +22,24 @@ function OptimalControlProblems.chain(::JuMPBackend; nh::Int=500)
     @expressions(
         model,
         begin
-            t[k=0:nh], k * tf / nh
+            t[k = 0:nh], k * tf / nh
         end
     )
 
     # variables and initial guess
     @variables(
         model,
         begin
-            u[k=0:nh],    (start = 4 * abs(b - a) * (t[k] / tf - tmin))
-            x1[k=0:nh],   (start = 4 * abs(b - a) * t[k] / tf * (0.5 * t[k] / tf - tmin) + a)
-            x2[k=0:nh],
+            u[k = 0:nh], (start = 4 * abs(b - a) * (t[k] / tf - tmin))
+            x1[k = 0:nh],
+            (start = 4 * abs(b - a) * t[k] / tf * (0.5 * t[k] / tf - tmin) + a)
+            x2[k = 0:nh],
             (
                 start =
                     (4 * abs(b - a) * t[k] / tf * (0.5 * t[k] / tf - tmin) + a) *
                     (4 * abs(b - a) * (t[k] / tf - tmin))
             )
-            x3[k=0:nh],   (start = 4 * abs(b - a) * (t[k] / tf - tmin))
+            x3[k = 0:nh], (start = 4 * abs(b - a) * (t[k] / tf - tmin))
         end
     )
 
@@ -58,18 +59,18 @@ function OptimalControlProblems.chain(::JuMPBackend; nh::Int=500)
         model,
         begin
             step, tf / nh
-            dx1[k=0:nh], u[k]
-            dx2[k=0:nh], x1[k] * √(1 + u[k]^2)
-            dx3[k=0:nh], √(1 + u[k]^2)
+            dx1[k = 0:nh], u[k]
+            dx2[k = 0:nh], x1[k] * √(1 + u[k]^2)
+            dx3[k = 0:nh], √(1 + u[k]^2)
         end
     )
 
     @constraints(
         model,
         begin
-            ∂x1[k=1:nh], x1[k] == x1[k - 1] + 0.5 * step * (dx1[k] + dx1[k - 1])
-            ∂x2[k=1:nh], x2[k] == x2[k - 1] + 0.5 * step * (dx2[k] + dx2[k - 1])
-            ∂x3[k=1:nh], x3[k] == x3[k - 1] + 0.5 * step * (dx3[k] + dx3[k - 1])
+            ∂x1[k = 1:nh], x1[k] == x1[k - 1] + 0.5 * step * (dx1[k] + dx1[k - 1])
+            ∂x2[k = 1:nh], x2[k] == x2[k - 1] + 0.5 * step * (dx2[k] + dx2[k - 1])
+            ∂x3[k = 1:nh], x3[k] == x3[k - 1] + 0.5 * step * (dx3[k] + dx3[k - 1])
         end
     )
 

ext/JuMPModels/dielectrophoretic_particle.jl

@@ -30,16 +30,16 @@ function OptimalControlProblems.dielectrophoretic_particle(::JuMPBackend; nh::In
         model,
         begin
             step, tf / nh
-            dx[k=0:nh], y[k] * u[k] + α * u[k]^2
-            dy[k=0:nh], -c * y[k] + u[k]
+            dx[k = 0:nh], y[k] * u[k] + α * u[k]^2
+            dy[k = 0:nh], -c * y[k] + u[k]
         end
     )
     # Collocation
     @constraints(
         model,
         begin
-            ∂x[k=1:nh], x[k] == x[k - 1] + 0.5 * step * (dx[k] + dx[k - 1])
-            ∂y[k=1:nh], y[k] == y[k - 1] + 0.5 * step * (dy[k] + dy[k - 1])
+            ∂x[k = 1:nh], x[k] == x[k - 1] + 0.5 * step * (dx[k] + dx[k - 1])
+            ∂y[k = 1:nh], y[k] == y[k - 1] + 0.5 * step * (dy[k] + dy[k - 1])
         end
     )
     # Boundary constraints

ext/JuMPModels/double_oscillator.jl

@@ -5,7 +5,7 @@ Double Oscillator Problem:
 Ref: [CLP2018] Coudurier, C., Lepreux, O., & Petit, N. (2018). Optimal bang-bang control of a mechanical double oscillator using averaging methods. IFAC-PapersOnLine, 51(2), 49-54.
 """
 function OptimalControlProblems.double_oscillator(::JuMPBackend; nh::Int=500)
-    
+
     # parameters
     m1 = 100    # [kg]
     m2 = 2      # [kg]
@@ -42,36 +42,35 @@ function OptimalControlProblems.double_oscillator(::JuMPBackend; nh::Int=500)
     @expressions(
         model,
         begin
-            
+
             #
             step, tf / nh
-            t[k=0:nh], k * tf / nh
-            F[k=0:nh], sin(t[k] * 2π / tf)
-            
+            t[k = 0:nh], k * tf / nh
+            F[k = 0:nh], sin(t[k] * 2π / tf)
+
             # dynamics
-            dx1[k=0:nh], x3[k]
-            dx2[k=0:nh], x4[k]
-            dx3[k=0:nh], -(k1 + k2) / m1 * x1[k] + k2 / m1 * x2[k] + 1 / m1 * F[k]
-            dx4[k=0:nh], k2 / m2 * x1[k] - k2 / m2 * x2[k] - c * (1 - u[k]) / m2 * x4[k]
+            dx1[k = 0:nh], x3[k]
+            dx2[k = 0:nh], x4[k]
+            dx3[k = 0:nh], -(k1 + k2) / m1 * x1[k] + k2 / m1 * x2[k] + 1 / m1 * F[k]
+            dx4[k = 0:nh], k2 / m2 * x1[k] - k2 / m2 * x2[k] - c * (1 - u[k]) / m2 * x4[k]
 
             # objective
-            dc[k=0:nh], 0.5 * (x1[k]^2 + x2[k]^2 + u[k]^2)
-
+            dc[k = 0:nh], 0.5 * (x1[k]^2 + x2[k]^2 + u[k]^2)
         end
     )
 
     @constraints(
         model,
         begin
-            ∂x1[k=1:nh], x1[k] == x1[k - 1] + 0.5 * step * (dx1[k] + dx1[k - 1])
-            ∂x2[k=1:nh], x2[k] == x2[k - 1] + 0.5 * step * (dx2[k] + dx2[k - 1])
-            ∂x3[k=1:nh], x3[k] == x3[k - 1] + 0.5 * step * (dx3[k] + dx3[k - 1])
-            ∂x4[k=1:nh], x4[k] == x4[k - 1] + 0.5 * step * (dx4[k] + dx4[k - 1])
+            ∂x1[k = 1:nh], x1[k] == x1[k - 1] + 0.5 * step * (dx1[k] + dx1[k - 1])
+            ∂x2[k = 1:nh], x2[k] == x2[k - 1] + 0.5 * step * (dx2[k] + dx2[k - 1])
+            ∂x3[k = 1:nh], x3[k] == x3[k - 1] + 0.5 * step * (dx3[k] + dx3[k - 1])
+            ∂x4[k = 1:nh], x4[k] == x4[k - 1] + 0.5 * step * (dx4[k] + dx4[k - 1])
         end
     )
 
     # objective: trapeze rule
-    @objective(model, Min, 0.5 * step * sum(dc[k] + dc[k-1] for k in 1:nh))
+    @objective(model, Min, 0.5 * step * sum(dc[k] + dc[k - 1] for k in 1:nh))
 
     return model
 end

ext/JuMPModels/ducted_fan.jl

@@ -48,7 +48,6 @@ function OptimalControlProblems.ducted_fan(::JuMPBackend; nh::Int=250)
             v₂[nh] == 0
             α[nh] == 0
             vα[nh] == 0
-
         end
     )
 
@@ -61,33 +60,34 @@ function OptimalControlProblems.ducted_fan(::JuMPBackend; nh::Int=250)
             step, tf / nh
 
             # dynamics
-            dx₁[k=0:nh], v₁[k]
-            dv₁[k=0:nh], (u₁[k] * cos(α[k]) - u₂[k] * sin(α[k])) / m
-            dx₂[k=0:nh], v₂[k]
-            dv₂[k=0:nh], (-mg + u₁[k] * sin(α[k]) + u₂[k] * cos(α[k])) / m
-            dα[k=0:nh], vα[k]
-            dvα[k=0:nh], r * u₁[k] / J
+            dx₁[k = 0:nh], v₁[k]
+            dv₁[k = 0:nh], (u₁[k] * cos(α[k]) - u₂[k] * sin(α[k])) / m
+            dx₂[k = 0:nh], v₂[k]
+            dv₂[k = 0:nh], (-mg + u₁[k] * sin(α[k]) + u₂[k] * cos(α[k])) / m
+            dα[k = 0:nh], vα[k]
+            dvα[k = 0:nh], r * u₁[k] / J
 
             # objective
-            dc[k=0:nh], 2 * u₁[k]^2 + u₂[k]^2
-
+            dc[k = 0:nh], 2 * u₁[k]^2 + u₂[k]^2
         end
     )
-    
+
     @constraints(
         model,
         begin
-            ∂x₁[k=1:nh], x₁[k] == x₁[k - 1] + 0.5 * step * (dx₁[k] + dx₁[k - 1])
-            ∂v₁[k=1:nh], v₁[k] == v₁[k - 1] + 0.5 * step * (dv₁[k] + dv₁[k - 1])
-            ∂x₂[k=1:nh], x₂[k] == x₂[k - 1] + 0.5 * step * (dx₂[k] + dx₂[k - 1])
-            ∂v₂[k=1:nh], v₂[k] == v₂[k - 1] + 0.5 * step * (dv₂[k] + dv₂[k - 1])
-            ∂α[k=1:nh],   α[k] ==  α[k - 1] + 0.5 * step * ( dα[k] +  dα[k - 1])
-            ∂vα[k=1:nh], vα[k] == vα[k - 1] + 0.5 * step * (dvα[k] + dvα[k - 1])
+            ∂x₁[k = 1:nh], x₁[k] == x₁[k - 1] + 0.5 * step * (dx₁[k] + dx₁[k - 1])
+            ∂v₁[k = 1:nh], v₁[k] == v₁[k - 1] + 0.5 * step * (dv₁[k] + dv₁[k - 1])
+            ∂x₂[k = 1:nh], x₂[k] == x₂[k - 1] + 0.5 * step * (dx₂[k] + dx₂[k - 1])
+            ∂v₂[k = 1:nh], v₂[k] == v₂[k - 1] + 0.5 * step * (dv₂[k] + dv₂[k - 1])
+            ∂α[k = 1:nh], α[k] == α[k - 1] + 0.5 * step * (dα[k] + dα[k - 1])
+            ∂vα[k = 1:nh], vα[k] == vα[k - 1] + 0.5 * step * (dvα[k] + dvα[k - 1])
         end
     )
 
     # objective
-    @objective(model, Min, (1 / tf) * 0.5 * step * sum(dc[k] + dc[k-1] for k in 1:nh) + (μ * tf))
+    @objective(
+        model, Min, (1 / tf) * 0.5 * step * sum(dc[k] + dc[k - 1] for k in 1:nh) + (μ * tf)
+    )
 
     return model
 end

ext/JuMPModels/electric_vehicle.jl

@@ -34,36 +34,35 @@ function OptimalControlProblems.electric_vehicle(::JuMPBackend; nh::Int=500)
             v[nh] == 0
         end
     )
-    
+
     # dynamics
     @expressions(
         model,
         begin
 
             #
             step, tf / nh
-            road[k=0:nh], α0 + α1 * x[k] + α2 * x[k]^2 + α3 * x[k]^3
+            road[k = 0:nh], α0 + α1 * x[k] + α2 * x[k]^2 + α3 * x[k]^3
 
             # dynamics
-            dx[k=0:nh], v[k]
-            dv[k=0:nh], h1 * u[k] - h2 * v[k]^2 - h0 - road[k]
-            
-            # objective
-            dc[k=0:nh], b1 * u[k] * v[k] + b2 * u[k]^2
+            dx[k = 0:nh], v[k]
+            dv[k = 0:nh], h1 * u[k] - h2 * v[k]^2 - h0 - road[k]
 
+            # objective
+            dc[k = 0:nh], b1 * u[k] * v[k] + b2 * u[k]^2
         end
     )
 
     @constraints(
         model,
         begin
-            ∂x[k=1:nh], x[k] == x[k - 1] + 0.5 * step * (dx[k - 1] + dx[k])
-            ∂v[k=1:nh], v[k] == v[k - 1] + 0.5 * step * (dv[k - 1] + dv[k])
+            ∂x[k = 1:nh], x[k] == x[k - 1] + 0.5 * step * (dx[k - 1] + dx[k])
+            ∂v[k = 1:nh], v[k] == v[k - 1] + 0.5 * step * (dv[k - 1] + dv[k])
         end
     )
 
     # objective
-    @objective(model, Min, 0.5 * step * sum(dc[k] + dc[k-1] for k in 1:nh))
+    @objective(model, Min, 0.5 * step * sum(dc[k] + dc[k - 1] for k in 1:nh))
 
     return model
 end