Dynamic optimization problems include optimal control, state estimation, and system identification. Our newly developed integrated residual methods generalize the state-of-the-art direct collocation method.
Interesso.jl implements a selection of Lagrange polynomial and Gauss quadrature node distributions. The iterative
Progradio.jl optimizer allows for efficient mesh refinement. We include an example of optimizing the trajectory of a space-shuttle landing.
Optimal control, state estimation, and system identification are examples of dynamic optimization problems (DOPs). In general, these need to be discretized in time into finite-dimensional problems, suitable for optimization solvers.
Transcribing DOPs into (nonlinear) optimization problems can be done in various ways. The state-of-the-art are direct collocation methods, where the differential equations are enforced at each of the discretized time nodes and the number of collocation points do not exceed the degrees of freedom. Integrated residual methods (IRMs) are a generalization of collocation, where errors in the differential equation violations are penalized instead. This generalization robustifies the method against certain DOPs for which the collocation method fails.
We parameterize the continuous trajectories using Lagrange polynomials in the barycentric form. This representation allows for fast and numerically stable interpolations. The user can choose the degree of polynomials, as well as the node distribution (e.g. Chebyshev, Legendre) to be used.
A central part of IRMs is the integration of the dynamic constraints violation. The numerical integration is done using Gauss quadrature methods. The user can choose the degree of quadrature, as well as the distribution (e.g. Gauss-Legendre, Clenshaw-Curtis) to be used.
The transcribed optimization problem is solved with
Progradio.jl, our projected gradient solver. Because the package implements Julia's
Iterator interface, the optimization can be arbitrarily terminated by Interesso. This is a key feature which allows efficient mesh refinement.
The Julia language and community have been crucial in allowing programming abstractions. Parameterizing types with
AbstractFloat optimizes the code to a user-specified floating point precision, and
AbstractDifferentiation.jl allows us to easily support many AD engines, dependence-free.
We demonstrate our code with an example optimal control problem: optimizing the trajectory of a space-shuttle landing.