fusion ControlToolboxTools

Author: ocots

Project.toml

@@ -1,10 +1,9 @@
 name = "CTBase"
 uuid = "54762871-cc72-4466-b8e8-f6c8b58076cd"
 authors = ["Olivier Cots <[email protected]>"]
-version = "0.1.0"
+version = "0.2.0"
 
 [deps]
-ControlToolboxTools = "3a0bcf43-9180-47f3-913c-e71e0d69f39f"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 Interpolations = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
 Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a"

src/CTBase.jl

@@ -1,14 +1,11 @@
 module CTBase
 
-# this should be in ControlToolboxTools, which should be renamed CTBase
-
 # using
 using ForwardDiff: jacobian, gradient, ForwardDiff # automatic differentiation
 using Parameters # @with_kw: permit to have default values in struct
 using Interpolations: linear_interpolation, Line, Interpolations # for default interpolation
-#import Base: show # to print an OptimalControlModel
 using Printf # to print a OptimalControlModel
-using ControlToolboxTools # tools: callbacks, exceptions, functions and more
+import Base: \, Base
 
 # --------------------------------------------------------------------------------------------------
 # Aliases for types
@@ -29,8 +26,24 @@ const Adjoint = MyVector # todo: ajouter type adjoint pour faire par exemple p*f
 const Dimension = Integer
 
 #
-types() = MyNumber, MyVector, Time, Times, TimesDisc, States, Adjoints, Controls, State, Adjoint, Dimension
+#num_types() = MyNumber, MyVector, Time, Times, TimesDisc, States, Adjoints, Controls, State, Adjoint, Dimension
+
+# General abstract type for callbacks
+abstract type CTCallback end
+const CTCallbacks = Tuple{Vararg{CTCallback}}
+
+# A desription is a tuple of symbols
+const DescVarArg = Vararg{Symbol} # or Symbol...
+const Description = Tuple{DescVarArg}
+
+#tools_types() = CTCallbacks, Description
 
+#
+include("exceptions.jl")
+include("descriptions.jl")
+include("callbacks.jl")
+include("macros.jl")
+include("functions.jl")
 #
 include("utils.jl")
 #include("algorithms.jl")
@@ -39,33 +52,43 @@ include("print.jl")
 include("solutions.jl")
 include("default.jl")
 
-#function solve(ocp::OptimalControlModel, algo::AbstractControlAlgorithm, method::Description; kwargs...)
-#    error("solve not implemented")
-#end
-
 #
-# export only for users
+# Numeric types
+export MyNumber, MyVector, Time, Times, TimesDisc
+export States, Adjoints, Controls, State, Adjoint, Dimension
+
+# callback
+export CTCallback, CTCallbacks, PrintCallback, StopCallback
+export get_priority_print_callbacks, get_priority_stop_callbacks
+
+# exceptions
+export CTException, AmbiguousDescription, InconsistentArgument, IncorrectMethod
+
+# description
+export Description, makeDescription, add, getFullDescription
 
 # utils
 export Ad, Poisson
 
 # model
+export AbstractOptimalControlModel, OptimalControlModel
 export Model, time!, constraint!, objective!, state!, control!, remove_constraint!, constraint
 export ismin, dynamics, lagrange, criterion, initial_time, final_time
 export control_dimension, state_dimension, constraints, initial_condition, final_constraint
 
 # solution
+export AbstractOptimalControlSolution, DirectSolution, DirectShootingSolution
 export time_steps_length, state_dimension, control_dimension
 export time_steps, state, control, adjoint, objective
 export iterations, success, message, stopping
 export constraints_violation
 
-# export structs
-export AbstractOptimalControlModel, OptimalControlModel
-export AbstractOptimalControlSolution, DirectSolution, DirectShootingSolution
-#export AbstractControlAlgorithm, DirectAlgorithm, DirectShootingAlgorithm
+# macros
+export @callable, @time_dependence_function
 
-# solve
-#export solve
+# functions
+export Hamiltonian, HamiltonianVectorField, VectorField
+export LagrangeFunction, DynamicsFunction, ControlFunction, MultiplierFunction
+export StateConstraintFunction, ControlConstraintFunction, MixedConstraintFunction
 
 end

src/callbacks.jl

@@ -0,0 +1,71 @@
+# --------------------------------------------------------------------------------------------------
+# Print callback
+mutable struct PrintCallback <: CTCallback
+    callback::Function
+    priority::Integer
+    function PrintCallback(cb::Function; priority::Integer=1)
+        new(cb, priority)
+    end
+end
+# todo: essayer de mettre args... pour éviter de fixer ici les arguments
+function (cb::PrintCallback)(i, sᵢ, dᵢ, xᵢ, gᵢ, fᵢ)
+    return cb.callback(i, sᵢ, dᵢ, xᵢ, gᵢ, fᵢ)
+end
+const PrintCallbacks = Tuple{Vararg{PrintCallback}}
+
+#
+function get_priority_print_callbacks(cbs::CTCallbacks)
+    callbacks_print = ()
+    priority = -Inf
+
+    # search highest priority
+    for cb in cbs
+        if typeof(cb) === PrintCallback && cb.priority ≥ priority
+            priority = cb.priority
+        end
+    end
+
+    # add callbacks
+    for cb in cbs
+        if typeof(cb) === PrintCallback && cb.priority == priority
+            callbacks_print = (callbacks_print..., cb)
+        end
+    end
+    return callbacks_print
+end
+
+# Stop callback
+mutable struct StopCallback <: CTCallback
+    callback::Function
+    priority::Integer
+    function StopCallback(cb::Function; priority::Integer=1)
+        new(cb, priority)
+    end
+end
+function (cb::StopCallback)(i, sᵢ, dᵢ, xᵢ, gᵢ, fᵢ, ng₀, optimalityTolerance, absoluteTolerance, 
+            stagnationTolerance, iterations)
+    return cb.callback(i, sᵢ, dᵢ, xᵢ, gᵢ, fᵢ, ng₀, optimalityTolerance, absoluteTolerance, 
+            stagnationTolerance, iterations)
+end
+const StopCallbacks = Tuple{Vararg{StopCallback}}
+
+#
+function get_priority_stop_callbacks(cbs::CTCallbacks)
+    callbacks_stop = ()
+    priority = -Inf
+
+    # search highest priority
+    for cb in cbs
+        if typeof(cb) === StopCallback && cb.priority ≥ priority
+            priority = cb.priority
+        end
+    end
+
+    # add callbacks
+    for cb in cbs
+        if typeof(cb) === StopCallback && cb.priority == priority
+            callbacks_stop = (callbacks_stop..., cb)
+        end
+    end
+    return callbacks_stop
+end

src/descriptions.jl

@@ -0,0 +1,29 @@
+# -------------------------------------------------------------------------------------------------- 
+# the description may be given as a tuple or a list of symbols (Vararg{Symbol})
+makeDescription(desc::DescVarArg) = Tuple(desc) # create a description from Vararg{Symbol}
+makeDescription(desc::Description) = desc
+
+# -------------------------------------------------------------------------------------------------- 
+# Possible algorithms
+add(x::Tuple{}, y::Description) = (y,)
+add(x::Tuple{Vararg{Description}}, y::Description) = (x..., y)
+
+# this function transform an incomplete description to a complete one
+function getFullDescription(desc::Description, desc_list)::Description
+    n = length(desc_list)
+    table = zeros(Int8, n, 2)
+    for i in range(1, n)
+        table[i, 1] = length(desc ∩ desc_list[i])
+        table[i, 2] = desc ⊆ desc_list[i] ? 1 : 0
+    end
+    if maximum(table[:, 2]) == 0
+        throw(AmbiguousDescription(desc))
+    end
+    # argmax : Return the index or key of the maximal element in a collection.
+    # If there are multiple maximal elements, then the first one will be returned.
+    # This means that the first has the priority
+    return desc_list[argmax(table[:, 1])]
+end
+
+diff(x::Description, y::Description) = Tuple(setdiff(x, y))
+\(x::Description, y::Description) = diff(x, y)

src/exceptions.jl

@@ -0,0 +1,39 @@
+# --------------------------------------------------------------------------------------------------
+# General abstract type for exceptions
+abstract type CTException <: Exception end
+
+# ambiguous description
+struct AmbiguousDescription <: CTException
+    var::Description
+end
+
+"""
+	Base.showerror(io::IO, e::AmbiguousDescription)
+
+TBW
+"""
+Base.showerror(io::IO, e::AmbiguousDescription) = print(io, "the description ", e.var, " is ambiguous / incorrect")
+
+# inconsistent argument
+struct InconsistentArgument <: CTException
+    var::String
+end
+
+"""
+	Base.showerror(io::IO, e::InconsistentArgument)
+
+TBW
+"""
+Base.showerror(io::IO, e::InconsistentArgument) = print(io, e.var)
+
+# incorrect method
+struct IncorrectMethod <: CTException
+    var::Symbol
+end
+
+"""
+	Base.showerror(io::IO, e::IncorrectMethod)
+
+TBW
+"""
+Base.showerror(io::IO, e::IncorrectMethod) = print(io, e.var, " is not an existing method")

src/functions.jl

@@ -0,0 +1,12 @@
+abstract type AbstractCTFunction{time_dependence} <: Function end
+
+@time_dependence_function Hamiltonian, AbstractCTFunction
+@time_dependence_function HamiltonianVectorField, AbstractCTFunction
+@time_dependence_function VectorField, AbstractCTFunction
+@time_dependence_function LagrangeFunction, AbstractCTFunction
+@time_dependence_function DynamicsFunction, AbstractCTFunction
+@time_dependence_function StateConstraintFunction, AbstractCTFunction
+@time_dependence_function ControlConstraintFunction, AbstractCTFunction
+@time_dependence_function MixedConstraintFunction, AbstractCTFunction
+@time_dependence_function ControlFunction, AbstractCTFunction
+@time_dependence_function MultiplierFunction, AbstractCTFunction

src/macros.jl

@@ -0,0 +1,116 @@
+# exception thrower
+function throw_callable_error( msg = nothing )
+    if isnothing(msg)
+        throw(error("@callable input is incorrect, expected a struct"))
+    else
+        throw(error("@callable input is incorrect: ", msg))
+    end
+end
+
+macro callable(expr)
+
+#=      @show(expr)
+    println("---")
+    println(expr)
+    println("---")
+    println(typeof(expr))
+    println("---")
+    println(Meta.show_sexpr(expr))
+    println("---")
+    println(expr.head)
+    println("---")
+    println(expr.args[1])
+    println("---")
+    println(expr.args[2])
+    println("---")
+    println(expr.args[3])
+    println("==================================================") =#
+
+    #dump(expr)
+
+    # first elements must be :struct
+    if !hasproperty(expr, :head) || expr.head != Symbol(:struct)
+        return :(throw_callable_error())
+    end
+
+    #
+    corps = expr.args[3]
+
+    # parametric struct or not
+    curly=false
+    if hasproperty(expr.args[2], :head) && expr.args[2].head == Symbol(:curly)
+        struct_name = expr.args[2].args[1]
+        struct_params = expr.args[2].args[2:end]
+        curly=true
+    else
+        struct_name = expr.args[2]
+        struct_params = ""
+    end
+    #println(struct_name)
+    #println(struct_params)
+
+    fun = gensym("fun")
+
+    if curly
+        esc(quote
+            struct $struct_name{$(struct_params...)}
+                $fun::Function
+                $corps
+                #function $struct_name{$(struct_params...)}(caller::Function, args...) where {$(struct_params...)}
+                #    new{$(struct_params...)}(caller, args...)
+                #end
+                #function $struct_name{$(struct_params...)}(args...; caller::Function) where {$(struct_params...)}
+                #    new{$(struct_params...)}(caller, args...)
+                #end
+            end
+            (s::$struct_name{$(struct_params...)})(args...; kwargs...) where {$(struct_params...)} = s.$fun(args...; kwargs...)
+        end)
+    else
+        esc(quote
+            struct $struct_name
+                $fun::Function
+                $corps
+                #function $struct_name(caller::Function, args...)
+                #    new(caller, args...)
+                #end
+                #function $struct_name(args...; caller::Function)
+                #    new(caller, args...)
+                #end
+            end
+            (s::$struct_name)(args...; kwargs...) = s.$fun(args...; kwargs...)
+        end)
+    end
+end
+
+
+# generate callable structure with the managing of autonomous vs nonautonomous cases
+macro time_dependence_function(expr)
+
+    #dump(expr)
+
+    if !hasproperty(expr, :head) || expr.head != Symbol(:tuple)
+        return :(throw_callable_error())
+    end
+
+    function_name = expr.args[1]
+    abstract_name = Symbol(:Abstract, function_name)
+    abstract_heritance = expr.args[2]
+
+    esc(quote
+        struct $(function_name){time_dependence} <: $(abstract_heritance){time_dependence}
+            f::Function
+            function $(function_name){time_dependence}(f::Function) where {time_dependence}
+                if !(time_dependence ∈ [:autonomous, :nonautonomous])
+                    error("the function must be :autonomous or :nonautonomous")
+                else
+                    new{time_dependence}(f)
+                end
+            end
+            $(function_name)(f::Function) = new{:autonomous}(f)
+        end
+        function (F::$(function_name){time_dependence})(t, args...; kwargs...) where {time_dependence}
+            return time_dependence==:autonomous ? F.f(args...; kwargs...) : F.f(t, args...; kwargs...)
+        end
+    end)
+
+end