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

[AUTO] JuliaFormatter.jl run

benchmark/benchmark.jl

@@ -21,7 +21,7 @@ function bench(;
     precompile = true,
     display = false,
     verbose = true,
-    discretization = :trapeze
+    discretization = :trapeze,
 )
 
     #######################################################
@@ -67,7 +67,7 @@ function bench(;
                 linear_solver = linear_solver,
                 max_iter = 0,
                 display = display,
-                discretization = discretization
+                discretization = discretization,
             )
             t_precomp += t
         end
@@ -86,7 +86,7 @@ function bench(;
             linear_solver = linear_solver,
             grid_size = grid_size,
             tol = tol,
-            discretization = discretization
+            discretization = discretization,
         )
         if !isnothing(problem[:obj]) && !isapprox(sol.objective, problem[:obj], rtol = 5e-2)
             error(

benchmark/prof.jl

@@ -39,7 +39,11 @@ if precompile
         CTDirect.DOCP_objective(CTDirect.DOCP_initial_guess(docp), docp)
     end
     if test_constraints
-        CTDirect.DOCP_constraints!(zeros(docp.dim_NLP_constraints), CTDirect.DOCP_initial_guess(docp), docp)
+        CTDirect.DOCP_constraints!(
+            zeros(docp.dim_NLP_constraints),
+            CTDirect.DOCP_initial_guess(docp),
+            docp,
+        )
     end
 end
 
@@ -49,8 +53,12 @@ if test_objective
     @btime CTDirect.DOCP_objective(CTDirect.DOCP_initial_guess(docp), docp)
 end
 if test_constraints
-    println("Timed constraints")   
-    @btime CTDirect.DOCP_constraints!(zeros(docp.dim_NLP_constraints), CTDirect.DOCP_initial_guess(docp), docp)
+    println("Timed constraints")
+    @btime CTDirect.DOCP_constraints!(
+        zeros(docp.dim_NLP_constraints),
+        CTDirect.DOCP_initial_guess(docp),
+        docp,
+    )
 end
 
 # transcription
@@ -62,10 +70,9 @@ end
 # full solve
 if test_solve
     println("Timed full solve")
-    @btime sol = direct_solve(ocp, grid_size = grid_size, display=false)
+    @btime sol = direct_solve(ocp, grid_size = grid_size, display = false)
 end
 
-
 if test_code_warntype
     if test_objective
         # NB. Pb with the mayer part: obj is type unstable (Any) because ocp.mayer is Union(Mayer,nothing), even for mayer problems (also, we should not even enter this code part for lagrange problems since has_mayer us defined as const in DOCP oO ...).

src/gauss.jl

@@ -18,5 +18,11 @@ struct GaussLegendre2 <: Discretization
     butcher_a::Matrix{Float64}
     butcher_b::Vector{Float64}
     butcher_c::Vector{Float64}
-    GaussLegendre2() = new(2, 0, [0.25 (0.25 - sqrt(3)/6); (0.25 + sqrt(3)/6) 0.25], [0.5, 0.5], [(0.5 - sqrt(3)/6), (0.5 + sqrt(3)/6)])
+    GaussLegendre2() = new(
+        2,
+        0,
+        [0.25 (0.25-sqrt(3) / 6); (0.25+sqrt(3) / 6) 0.25],
+        [0.5, 0.5],
+        [(0.5 - sqrt(3) / 6), (0.5 + sqrt(3) / 6)],
+    )
 end

src/midpoint.jl

@@ -12,19 +12,17 @@ struct Midpoint <: Discretization
     Midpoint() = new(1, 0)
 end
 
-
 """
 $(TYPEDSIGNATURES)
 
 Retrieve state and control variables at given time step from the NLP variables.
 """
 function get_variables_at_time_step(xu, docp::DOCP{Midpoint}, i)
-
     nx = docp.dim_NLP_x
     n = docp.dim_OCP_x
     m = docp.dim_NLP_u
     N = docp.dim_NLP_steps
-    offset = (nx*(1+docp.discretization.stage) + m) * i
+    offset = (nx * (1 + docp.discretization.stage) + m) * i
 
     # retrieve scalar/vector OCP state (w/o lagrange state) 
     if n == 1
@@ -42,7 +40,7 @@ function get_variables_at_time_step(xu, docp::DOCP{Midpoint}, i)
     if i < N
         offset_u = offset
     else
-        offset_u = (nx*2 + m) * (i-1)
+        offset_u = (nx * 2 + m) * (i - 1)
     end
     if m == 1
         ui = xu[offset_u + nx + 1]
@@ -52,53 +50,49 @@ function get_variables_at_time_step(xu, docp::DOCP{Midpoint}, i)
 
     # retrieve vector stage variable (except at final time)
     if i < N
-        ki = xu[(offset + nx + m + 1):(offset + nx + m + nx) ]
+        ki = xu[(offset + nx + m + 1):(offset + nx + m + nx)]
     else
         ki = nothing
     end
 
     return xi, ui, xli, ki
 end
 
-
 # internal NLP version for solution parsing
 # could be fused with one above if 
 # - using extended dynamics that include lagrange cost
 # - scalar case is handled at OCP level
 function get_NLP_variables_at_time_step(xu, docp, i, disc::Midpoint)
-
     nx = docp.dim_NLP_x
     m = docp.dim_NLP_u
     N = docp.dim_NLP_steps
-    offset = (nx*2 + m) * i
+    offset = (nx * 2 + m) * i
 
     # state
     xi = xu[(offset + 1):(offset + nx)]
     # control
     if i < N
         offset_u = offset
     else
-        offset_u = (nx*2 + m) * (i-1)
-    end 
+        offset_u = (nx * 2 + m) * (i - 1)
+    end
     ui = xu[(offset_u + nx + 1):(offset_u + nx + m)]
     # stage
     if i < N
-        ki = xu[(offset + nx + m + 1):(offset + nx + m + nx) ]
+        ki = xu[(offset + nx + m + 1):(offset + nx + m + nx)]
     else
         ki = nothing
     end
 
     return xi, ui, ki
 end
 
-
 function set_variables_at_time_step!(xu, x_init, u_init, docp, i, disc::Midpoint)
-
     nx = docp.dim_NLP_x
     n = docp.dim_OCP_x
     m = docp.dim_NLP_u
     N = docp.dim_NLP_steps
-    offset = (nx*2 + m) * i
+    offset = (nx * 2 + m) * i
 
     # NB. only set the actual state variables from the OCP 
     # - skip the possible additional state for lagrange cost
@@ -111,7 +105,6 @@ function set_variables_at_time_step!(xu, x_init, u_init, docp, i, disc::Midpoint
     end
 end
 
-
 # trivial version for now...
 # +++multiple dispatch here seems to cause more allocations !
 # +++? use abstract type for all Args ?
@@ -129,20 +122,19 @@ struct ArgsAtTimeStep_Midpoint
     next_time::Any
     next_state::Any
     next_lagrange_state::Any
-
-    function ArgsAtTimeStep_Midpoint(xu, docp::DOCP{Midpoint}, v, time_grid, i::Int)
 
+    function ArgsAtTimeStep_Midpoint(xu, docp::DOCP{Midpoint}, v, time_grid, i::Int)
         disc = docp.discretization
 
         # variables
-        ti = time_grid[i+1]
+        ti = time_grid[i + 1]
         xi, ui, xli, ki = get_variables_at_time_step(xu, docp, i)
-        
+
         if i == docp.dim_NLP_steps
             return new(ti, xi, ui, xli, ki, disc)
         else
-            tip1 = time_grid[i+2]
-            xip1, uip1, xlip1 = get_variables_at_time_step(xu, docp, i+1)
+            tip1 = time_grid[i + 2]
+            xip1, uip1, xlip1 = get_variables_at_time_step(xu, docp, i + 1)
             return new(ti, xi, ui, xli, ki, tip1, xip1, xlip1)
         end
     end
@@ -151,20 +143,18 @@ function initArgs(xu, docp::DOCP{Midpoint}, time_grid)
     v = Float64[]
     docp.has_variable && (v = get_optim_variable(xu, docp))
     args = ArgsAtTimeStep_Midpoint(xu, docp, v, time_grid, 0)
-    return args, v 
+    return args, v
 end
 function updateArgs(args, xu, docp::DOCP{Midpoint}, v, time_grid, i::Int)
-    return ArgsAtTimeStep_Midpoint(xu, docp, v, time_grid, i+1)
+    return ArgsAtTimeStep_Midpoint(xu, docp, v, time_grid, i + 1)
 end
 
-
 """
 $(TYPEDSIGNATURES)
 
 Set the constraints corresponding to the state equation
 """
 function setStateEquation!(docp::DOCP{Midpoint}, c, index::Int, args, v, i)
-
     ocp = docp.ocp
 
     # +++ later use butcher table in struct ?
@@ -181,36 +171,32 @@ function setStateEquation!(docp::DOCP{Midpoint}, c, index::Int, args, v, i)
     hi = tip1 - ti
 
     # midpoint rule
-    @. c[index:(index + docp.dim_OCP_x - 1)] =
-        xip1 - (xi + hi * ki[1:docp.dim_OCP_x])
+    @. c[index:(index + docp.dim_OCP_x - 1)] = xip1 - (xi + hi * ki[1:(docp.dim_OCP_x)])
     # +++ just define extended dynamics !
     if docp.has_lagrange
         c[index + docp.dim_OCP_x] = xlip1 - (xli + hi * ki[end])
     end
     index += docp.dim_NLP_x
-    
+
     # stage equation at mid-step
     t_s = 0.5 * (ti + tip1)
     x_s = 0.5 * (xi + xip1)
-    c[index:(index + docp.dim_OCP_x - 1)] .=
-        ki[1:docp.dim_OCP_x] .- ocp.dynamics(t_s, x_s, ui, v)
+    c[index:(index + docp.dim_OCP_x - 1)] .= ki[1:(docp.dim_OCP_x)] .- ocp.dynamics(t_s, x_s, ui, v)
     # +++ just define extended dynamics !
     if docp.has_lagrange
-        c[index + docp.dim_OCP_x] = ki[end] - ocp.lagrange(t_s, x_s, ui, v) 
+        c[index + docp.dim_OCP_x] = ki[end] - ocp.lagrange(t_s, x_s, ui, v)
     end
     index += docp.dim_NLP_x
 
     return index
 end
 
-
 """
 $(TYPEDSIGNATURES)
 
 Set the path constraints at given time step
 """
 function setPathConstraints!(docp::DOCP{Midpoint}, c, index::Int, args, v, i::Int)
-
     ocp = docp.ocp
     ti = args.time
     xi = args.state