🤖 Format .jl files

Author: ocots

ext/CTFlowsODE.jl

@@ -18,7 +18,7 @@ Alias for `CTFlows.ctVector`, representing cotangent vectors in continuous-time
 
 Used for denoting adjoint states or costates in optimal control formulations.
 """
-const CoTangent  = CTFlows.ctVector
+const CoTangent = CTFlows.ctVector
 
 """
 Alias for `CTFlows.ctVector`, representing derivative cotangent vectors.

ext/concatenation.jl

@@ -125,7 +125,9 @@ function __concat_feedback_control(F::AbstractFlow, G::AbstractFlow, t_switch::T
             G.feedback_control(t, x, u, v)
         end
     end
-    feedback_control = CTFlows.ControlLaw(_feedback_control, CTFlows.NonAutonomous, CTFlows.NonFixed)
+    feedback_control = CTFlows.ControlLaw(
+        _feedback_control, CTFlows.NonAutonomous, CTFlows.NonFixed
+    )
     return feedback_control
 end
 

ext/ext_default.jl

@@ -27,13 +27,15 @@ function __thevariable(t0, x0, p0, tf, ocp)
     CTModels.has_free_final_time(ocp) && CTModels.variable_dimension(ocp) == 1 && return tf
 
     # if t0 is free and ocp has only one variable, then return t0
-    CTModels.has_free_initial_time(ocp) && CTModels.variable_dimension(ocp) == 1 && return t0
+    CTModels.has_free_initial_time(ocp) &&
+        CTModels.variable_dimension(ocp) == 1 &&
+        return t0
 
     # if t0 and tf are free and ocp has only two variables, then return [t0, tf]
     CTModels.has_free_final_time(ocp) &&
-    CTModels.has_free_initial_time(ocp) &&
-    CTModels.variable_dimension(ocp) == 2 &&
-    return [t0, tf]
+        CTModels.has_free_initial_time(ocp) &&
+        CTModels.variable_dimension(ocp) == 2 &&
+        return [t0, tf]
 
     # otherwise return an empty vector of right type to avoid warning performance message from OrdinaryDiffEq
     z0 = [x0; p0]

ext/ext_types.jl

@@ -1,12 +1,12 @@
 const ctNumber = CTModels.ctNumber
 const ctVector = Union{ctNumber,CTModels.ctVector}
-const Time     = ctNumber
-const Times    = AbstractVector{<:Time}
-const State    = ctVector
-const Costate  = ctVector
-const Control  = ctVector
+const Time = ctNumber
+const Times = AbstractVector{<:Time}
+const State = ctVector
+const Costate = ctVector
+const Control = ctVector
 const Variable = ctVector
-const DState   = ctVector
+const DState = ctVector
 const DCostate = ctVector
 
 # ---------------------------------------------------------------------------------------------------
@@ -239,7 +239,7 @@ function CTModels.Solution(ocfs::OptimalControlFlowSolution; kwargs...)
         message="Solution obtained from flow",
         status=:nostatusmessage,
         successful=true,
-        kwargs_OCS...
+        kwargs_OCS...,
     )
 
     return sol

ext/optimal_control_problem.jl

@@ -131,7 +131,9 @@ julia> f = Flow(ocp, (t, x, p) -> t + p, (t, x, u) -> x - 1, (t, x, p) -> x+p)
 function CTFlows.Flow(
     ocp::CTModels.Model,
     u::Union{CTFlows.ControlLaw{<:Function,T,V},CTFlows.FeedbackControl{<:Function,T,V}},
-    g::Union{CTFlows.MixedConstraint{<:Function,T,V},CTFlows.StateConstraint{<:Function,T,V}},
+    g::Union{
+        CTFlows.MixedConstraint{<:Function,T,V},CTFlows.StateConstraint{<:Function,T,V}
+    },
     μ::Union{CTFlows.Multiplier{<:Function,T,V}};
     alg=__alg(),
     abstol=__abstol(),
@@ -222,6 +224,13 @@ function __ocp_Flow(
 )
     rhs! = rhs(h)
     f = hamiltonian_usage(alg, abstol, reltol, saveat, internalnorm; kwargs_Flow...)
-    kwargs_Flow = (kwargs_Flow..., alg=alg, abstol=abstol, reltol=reltol, saveat=saveat, internalnorm=internalnorm)
+    kwargs_Flow = (
+        kwargs_Flow...,
+        alg=alg,
+        abstol=abstol,
+        reltol=reltol,
+        saveat=saveat,
+        internalnorm=internalnorm,
+    )
     return OptimalControlFlow(f, rhs!, u, ocp, kwargs_Flow)
 end

src/differential_geometry.jl

@@ -32,7 +32,6 @@ function Lift(X::VectorField)::HamiltonianLift
     return HamiltonianLift(X)
 end
 
-
 """
 $(TYPEDSIGNATURES)
 
@@ -63,7 +62,9 @@ julia> H2 = Lift((t, x, v) -> 2x + t - v, autonomous=false, variable=true)
 julia> H2(1, 1, 1, 1)  # returns 2
 ```
 """
-function Lift(X::Function; autonomous::Bool=__autonomous(), variable::Bool=__variable())::Function
+function Lift(
+    X::Function; autonomous::Bool=__autonomous(), variable::Bool=__variable()
+)::Function
     return @match (autonomous, variable) begin
         (true, false) => (x, p) -> p' * X(x)
         (true, true) => (x, p, v) -> p' * X(x, v)
@@ -205,9 +206,7 @@ function ⅋(
             ctgradient(y -> Y(y, args...), x) * X(x, args...)
         else
             ctjacobian(y -> Y(y, args...), x) * X(x, args...)
-        end,
-        Autonomous,
-        V,
+        end, Autonomous, V
     )
 end
 
@@ -313,13 +312,13 @@ function Poisson(
         ff, gg = @match n begin
             1 => (z -> f(z[1], z[2], args...), z -> g(z[1], z[2], args...))
             _ => (
-                z -> f(z[1:n], z[n+1:2n], args...),
-                z -> g(z[1:n], z[n+1:2n], args...),
+                z -> f(z[1:n], z[(n + 1):2n], args...),
+                z -> g(z[1:n], z[(n + 1):2n], args...),
             )
         end
         df = ctgradient(ff, [x; p])
         dg = ctgradient(gg, [x; p])
-        return df[n+1:2n]' * dg[1:n] - df[1:n]' * dg[n+1:2n]
+        return df[(n + 1):2n]' * dg[1:n] - df[1:n]' * dg[(n + 1):2n]
     end
     return Hamiltonian(fg, Autonomous, V)
 end
@@ -349,13 +348,13 @@ function Poisson(
         ff, gg = @match n begin
             1 => (z -> f(t, z[1], z[2], args...), z -> g(t, z[1], z[2], args...))
             _ => (
-                z -> f(t, z[1:n], z[n+1:2n], args...),
-                z -> g(t, z[1:n], z[n+1:2n], args...),
+                z -> f(t, z[1:n], z[(n + 1):2n], args...),
+                z -> g(t, z[1:n], z[(n + 1):2n], args...),
             )
         end
         df = ctgradient(ff, [x; p])
         dg = ctgradient(gg, [x; p])
-        return df[n+1:2n]' * dg[1:n] - df[1:n]' * dg[n+1:2n]
+        return df[(n + 1):2n]' * dg[1:n] - df[1:n]' * dg[(n + 1):2n]
     end
     return Hamiltonian(fg, NonAutonomous, V)
 end
@@ -618,7 +617,7 @@ macro Lie(expr::Expr, args...)
     for arg in args
         @match arg begin
             :(autonomous = $a) => (autonomous = a)
-            :(variable = $a)   => (variable = a)
+            :(variable = $a) => (variable = a)
             _ => throw(ArgumentError("Invalid argument: $arg"))
         end
     end
@@ -639,7 +638,9 @@ macro Lie(expr::Expr, args...)
         postwalk(walker, x)
 
         if has_lie[] && has_poisson[]
-            throw(ArgumentError("Cannot mix Lie and Poisson brackets in the same expression."))
+            throw(
+                ArgumentError("Cannot mix Lie and Poisson brackets in the same expression.")
+            )
         end
         return nothing
     end
@@ -658,8 +659,8 @@ macro Lie(expr::Expr, args...)
             return quote
                 if isa($c, Function) && isa($d, Function)
                     Poisson(
-                        Hamiltonian($c; autonomous=$(autonomous), variable=$(variable)),
-                        Hamiltonian($d; autonomous=$(autonomous), variable=$(variable))
+                        Hamiltonian($c; autonomous=($(autonomous)), variable=($(variable))),
+                        Hamiltonian($d; autonomous=($(autonomous)), variable=($(variable))),
                     )
                 else
                     Poisson($c, $d)

src/optimal_control_problem_utils.jl

@@ -17,7 +17,9 @@ wrapped to return either a scalar or vector depending on the model's state dimen
 """
 function __dynamics(ocp::CTModels.Model)
     n = CTModels.state_dimension(ocp)
-    dyn = (t, x, u, v) -> (r = zeros(eltype(x), n); CTModels.dynamics(ocp)(r, t, x, u, v); n==1 ? r[1] : r)
+    dyn =
+        (t, x, u, v) ->
+            (r=zeros(eltype(x), n); CTModels.dynamics(ocp)(r, t, x, u, v); n==1 ? r[1] : r)
     return Dynamics(dyn, NonAutonomous, NonFixed)
 end
 
@@ -55,10 +57,14 @@ The Hamiltonian is built using model dynamics (and possibly a running cost) and
 
 Returns a tuple `(H, u)` where `H` is the Hamiltonian function and `u` is the control law.
 """
-function __create_hamiltonian(ocp::CTModels.Model, u::ControlLaw{<:Function,T,V}) where {T,V}
+function __create_hamiltonian(
+    ocp::CTModels.Model, u::ControlLaw{<:Function,T,V}
+) where {T,V}
     f, f⁰, p⁰, s = __get_data_for_ocp_flow(ocp) # data
     @assert f ≠ nothing "no dynamics in ocp"
-    h = Hamiltonian(f⁰ ≠ nothing ? makeH(f, u, f⁰, p⁰, s) : makeH(f, u), NonAutonomous, NonFixed)
+    h = Hamiltonian(
+        f⁰ ≠ nothing ? makeH(f, u, f⁰, p⁰, s) : makeH(f, u), NonAutonomous, NonFixed
+    )
     return h, u
 end
 
@@ -69,12 +75,14 @@ Helper method to construct the Hamiltonian when control is given as a plain func
 
 The function is wrapped in a `ControlLaw`, and the flags `autonomous` and `variable` define its behavior type.
 """
-function __create_hamiltonian(ocp::CTModels.Model, u::Function; autonomous::Bool, variable::Bool)
+function __create_hamiltonian(
+    ocp::CTModels.Model, u::Function; autonomous::Bool, variable::Bool
+)
     T, V = @match (autonomous, variable) begin
-        (true, false)   => (Autonomous, Fixed)
-        (true, true)    => (Autonomous, NonFixed)
-        (false, false)  => (NonAutonomous, Fixed)
-        _               => (NonAutonomous, NonFixed)
+        (true, false) => (Autonomous, Fixed)
+        (true, true) => (Autonomous, NonFixed)
+        (false, false) => (NonAutonomous, Fixed)
+        _ => (NonAutonomous, NonFixed)
     end
     return __create_hamiltonian(ocp, ControlLaw(u, T, V))
 end
@@ -147,12 +155,14 @@ $(TYPEDSIGNATURES)
 
 Overload for control law as a raw function with autonomous and variable flags.
 """
-function __create_hamiltonian(ocp::CTModels.Model, u::Function, g, μ; autonomous::Bool, variable::Bool)
+function __create_hamiltonian(
+    ocp::CTModels.Model, u::Function, g, μ; autonomous::Bool, variable::Bool
+)
     T, V = @match (autonomous, variable) begin
-        (true, false)   => (Autonomous, Fixed)
-        (true, true)    => (Autonomous, NonFixed)
-        (false, false)  => (NonAutonomous, Fixed)
-        _               => (NonAutonomous, NonFixed)
+        (true, false) => (Autonomous, Fixed)
+        (true, true) => (Autonomous, NonFixed)
+        (false, false) => (NonAutonomous, Fixed)
+        _ => (NonAutonomous, NonFixed)
     end
     return __create_hamiltonian(ocp, ControlLaw(u, T, V), g, μ)
 end
@@ -191,7 +201,10 @@ $(TYPEDSIGNATURES)
 Overload that converts StateConstraint objects into MixedConstraint with appropriate signature adaptation.
 """
 function __create_hamiltonian(
-    ocp::CTModels.Model, u::ControlLaw{<:Function,T,V}, g_::StateConstraint{<:Function,T,V}, μ
+    ocp::CTModels.Model,
+    u::ControlLaw{<:Function,T,V},
+    g_::StateConstraint{<:Function,T,V},
+    μ,
 ) where {T,V}
     g = @match (T, V) begin
         (Autonomous, Fixed) => MixedConstraint((x, u) -> g_(x), T, V)
@@ -208,7 +221,10 @@ $(TYPEDSIGNATURES)
 Overload that wraps multiplier functions into Multiplier objects.
 """
 function __create_hamiltonian(
-    ocp::CTModels.Model, u::ControlLaw{<:Function,T,V}, g::MixedConstraint{<:Function,T,V}, μ::Function
+    ocp::CTModels.Model,
+    u::ControlLaw{<:Function,T,V},
+    g::MixedConstraint{<:Function,T,V},
+    μ::Function,
 ) where {T,V}
     return __create_hamiltonian(ocp, u, g, Multiplier(μ, T, V))
 end