added function types

e-duar-do · e-duar-do · commit fc48b7cb754d · 2024-05-10T15:12:58.000+01:00
diff --git a/docs/make.jl b/docs/make.jl
@@ -6,9 +6,11 @@ DocMeta.setdocmeta!(DynOptInterface, :DocTestSetup, :(using DynOptInterface); re
 const _PAGES = [
     "Home" => "index.md",
     "API Reference" => [
-        "reference/domains.md",
-        "reference/algebraic.md",
-        "reference/differentiable.md",
+        "reference/dynamic_variables.md",
+        "reference/algebraic_functions.md",
+        "reference/differential_functions.md",
+        "reference/boundary_functions.md",
+        "reference/integral_functions.md",
     ],
 ]
 
diff --git a/docs/src/reference/algebraic_functions.md b/docs/src/reference/algebraic_functions.md
@@ -2,8 +2,8 @@
 CurrentModule = DynOptInterface
 ```
 
-# Algebraic Variables
+# Algebraic Functions
 
 ```@docs
-AlgebraicIndex
+NonlinearAlgebraicFunction
 ```
diff --git a/docs/src/reference/boundary_functions.md b/docs/src/reference/boundary_functions.md
@@ -0,0 +1,15 @@
+```@meta
+CurrentModule = DynOptInterface
+```
+
+# Boundary Functions
+
+```@docs
+AbstractBoundaryFunction
+DomainInitial
+DomainFinal
+DifferentialVariableInitial
+DifferentialVariableFinal
+NonlinearBoundaryFunction
+NonlinearLinkageFunction
+```
diff --git a/docs/src/reference/differential_functions.md b/docs/src/reference/differential_functions.md
@@ -0,0 +1,11 @@
+```@meta
+CurrentModule = DynOptInterface
+```
+
+# Differential Functions
+
+```@docs
+DifferentialVariableDerivative
+ExplicitDifferentialFunction
+NonlinearDifferentialFunction
+```
diff --git a/docs/src/reference/dynamic_variables.md b/docs/src/reference/dynamic_variables.md
@@ -2,8 +2,10 @@
 CurrentModule = DynOptInterface
 ```
 
-# Domains
+# Dynamic Variables
 
 ```@docs
 DomainIndex
+AlgebraicVariableIndex
+DifferentialVariableIndex
 ```
diff --git a/docs/src/reference/integral_functions.md b/docs/src/reference/integral_functions.md
@@ -2,8 +2,9 @@
 CurrentModule = DynOptInterface
 ```
 
-# Differentiable Variables
+# Integral Functions
 
 ```@docs
-DifferentiableIndex
+IntegralFunction
+BolzaFunction
 ```
diff --git a/src/DynOptInterface.jl b/src/DynOptInterface.jl
@@ -2,7 +2,11 @@ module DynOptInterface
 
 import MathOptInterface as MOI
 
-include("indices.jl")
+include("dynamic_variables.jl")
+include("algebraic_functions.jl")
+include("differential_functions.jl")
+include("boundary_functions.jl")
+include("integral_functions.jl")
 
 
 end
diff --git a/src/algebraic_functions.jl b/src/algebraic_functions.jl
@@ -0,0 +1,17 @@
+"""
+    NonlinearAlgebraicFunction <: AbstractAlgebraicFunction
+
+```math
+f(y(\\cdot), u(\\cdot), t, x)
+```
+Supports:
+* [`DifferentialVariableIndex`](@ref)
+* [`AlgebraicVariableIndex`](@ref)
+* [`DomainIndex`](@ref)
+* [`NonlinearAlgebraicFunction`](@ref)
+* `MOI.ScalarNonlinearFunction`
+"""
+struct NonlinearAlgebraicFunction <: AbstractAlgebraicFunction
+    head::Symbol
+    args::Vector{Any}
+end
diff --git a/src/boundary_functions.jl b/src/boundary_functions.jl
@@ -0,0 +1,71 @@
+"""
+    AbstractBoundaryFunction <: AbstractDynamicFunction
+
+Abstract supertype for dynamic functions evaluated at the domain boundaries.
+"""
+abstract type AbstractBoundaryFunction <: AbstractDynamicFunction end
+
+"""
+    DomainInitial <: AbstractBoundaryFunction
+
+Represents the initial point of a [`DomainIndex`](@ref).
+"""
+struct DomainInitial <: AbstractBoundaryFunction
+    index::DomainIndex
+end
+
+"""
+    DomainFinal <: AbstractBoundaryFunction
+
+Represents the final point of a [`DomainIndex`](@ref).
+"""
+struct DomainFinal <: AbstractBoundaryFunction
+    index::DomainIndex
+end
+
+"""
+    DifferentialVariableInitial <: AbstractBoundaryFunction
+
+Represents a [`DifferentialVariableIndex`](@ref) evaluated at the initial point of its [`DomainIndex`](@ref)
+"""
+struct DifferentialVariableInitial <: AbstractBoundaryFunction
+    index::DifferentialVariableIndex
+end
+
+"""
+    DifferentialVariableFinal <: AbstractBoundaryFunction
+
+Represents a [`DifferentialVariableIndex`](@ref) evaluated at the final point of its [`DomainIndex`](@ref)
+"""
+struct DifferentialVariableFinal <: AbstractBoundaryFunction
+    index::DifferentialVariableIndex
+end
+
+"""
+    NonlinearBoundaryFunction <: AbstractBoundaryFunction
+
+Represents a general 
+Supports:
+* [`DifferentialVariableInitial`](@ref)
+* [`DifferentialVariableFinal`](@ref)
+* [`DomainInitial`](@ref)
+* [`DomainFinal`](@ref)
+* [`NonlinearBoundaryFunction`](@ref)
+* `MOI.ScalarNonlinearFunction`
+"""
+struct NonlinearBoundaryFunction <: AbstractBoundaryFunction
+    head::Symbol
+    args::Vector{Any}
+    # Inner constructor to enforce rules
+end
+
+"""
+    NonlinearLinkageFunction
+
+Similar to [`NonlinearBoundaryFunction`](@ref) but with different domains allowed.
+"""
+struct NonlinearLinkageFunction <: AbstractDynamicFunction
+    head::Symbol
+    args::Vector{Any}
+    # Inner constructor to enforce rules
+end
diff --git a/src/differential_functions.jl b/src/differential_functions.jl
@@ -0,0 +1,34 @@
+abstract type AbstractDifferentialFunction <: AbstractDynamicFunction end
+
+"""
+    DifferentialVariableDerivative <: AbstractDifferentialFunction
+
+``\\dot{y}(\\cdot)``
+"""
+struct DifferentialVariableDerivative <: AbstractDifferentialFunction
+    variable_index::DifferentialVariableIndex
+end
+
+"""
+    ExplicitDifferentialFunction{AF<:AbstractAlgebraicFunction} <: AbstractDifferentialFunction
+
+``\\dot{y}(\\cdot) - f(y(\\cdot), u(\\cdot), t, x)``
+"""
+struct ExplicitDifferentialFunction{AF<:AbstractAlgebraicFunction} <: AbstractDifferentialFunction
+    derivative::DifferentialVariableDerivative
+    f::AF
+end
+
+"""
+    NonlinearDifferentialFunction <: AbstractDifferentialFunction
+
+``r(\\dot{y}(\\cdot), y(\\cdot), u(\\cdot), t, x)``
+Supports:
+* [`DifferentialVariableDerivative`](@ref)
+* [`NonlinearAlgebraicFunction`](@ref)
+"""
+struct NonlinearDifferentialFunction <: AbstractDifferentialFunction
+    head::Symbol
+    args::Vector{Any}
+    # Inner constructor to enforce rules
+end
diff --git a/src/dynamic_variables.jl b/src/dynamic_variables.jl
@@ -0,0 +1,30 @@
+abstract type AbstractDynamicFunction <: MOI.AbstractScalarFunction end
+
+abstract type AbstractAlgebraicFunction <: AbstractDynamicFunction end
+
+"""
+    DomainIndex <: AbstractDynamicFunction
+
+A type-safe wrapper for `Int64` for use in referencing domains.
+"""
+struct DomainIndex <: AbstractAlgebraicFunction
+    value::Int64
+end
+
+"""
+    AlgebraicVariableIndex <: AbstractDynamicFunction
+
+A type-safe wrapper for `Int64` for use in referencing algebraic variables.
+"""
+struct AlgebraicVariableIndex <: AbstractAlgebraicFunction
+    value::Int64
+end
+
+"""
+    DifferentialVariableIndex <: AbstractDynamicFunction
+
+A type-safe wrapper for `Int64` for use in referencing differential variables.
+"""
+struct DifferentialVariableIndex <: AbstractAlgebraicFunction
+    value::Int64
+end
diff --git a/src/functions.jl b/src/functions.jl
diff --git a/src/indices.jl b/src/indices.jl
diff --git a/src/integral_functions.jl b/src/integral_functions.jl
@@ -0,0 +1,24 @@
+"""
+    IntegralFunction{F<:AbstractAlgebraicFunction} <: AbstractDynamicFunction
+
+``\\int_{t_o}^{t_f} \\ell(y(t), u(t), t, x) \\mathrm{d}t``
+Represents the integral of an [`AbstractAlgebraicFunction`](@ref) over its domain.
+"""
+struct IntegralFunction{AF<:AbstractAlgebraicFunction} <: AbstractDynamicFunction
+    integrand::AF
+end
+
+"""
+    BolzaFunction{BF<:AbstractBoundaryFunction,AF<:AbstractAlgebraicFunction} <: AbstractDynamicFunction
+
+``b(y_0, y_f, t_0, t_f, x) + \\int_{t_0}^{t_f} \\ell(y(t), u(t), t, x) \\mathrm{d}t``
+Represents the sum of an [`AbstractBoundaryFunction`](@ref) with the integral of
+an [`AbstractAlgebraicFunction`](@ref). The functions must have the same [`DomainIndex`](@ref).
+"""
+struct BolzaFunction{BF<:AbstractBoundaryFunction,AF<:AbstractAlgebraicFunction} <: AbstractDynamicFunction
+    boundary::BF
+    integrand::AF
+    # Inner constructor to check same index
+end
+
+# Multi-Phase solvers may support: Vector{NonlinearBolzaFunction}
