Struct CollocationProblem 

pub struct CollocationProblem<S: Scalar> { /* private fields */ }

Builder for direct collocation optimal control problems.

Implementations

impl<S: Scalar> CollocationProblem<S>

pub fn new(n_states: usize, n_controls: usize) -> Self

Create a new collocation problem.

pub fn dynamics<F>(self, f: F) -> Self

where F: Fn(S, &[S], &[S], &[S], &mut [S]) + Send + Sync + 'static,

Set the dynamics: f(t, x, u, p, dxdt).

pub fn n_params(self, n: usize) -> Self

Set the number of free parameters.

pub fn x0(self, x0: &[S]) -> Self

Set the initial state.

pub fn time_span(self, t0: S, tf: S) -> Self

Set the time span [t0, tf].

pub fn free_final_time(self, tf_init: S, tf_bounds: (S, S)) -> Self

Enable free final time.

pub fn n_intervals(self, n: usize) -> Self

Set the number of collocation intervals.

pub fn scheme(self, scheme: CollocationScheme) -> Self

Set the collocation scheme.

pub fn terminal_cost<F>(self, f: F) -> Self

where F: Fn(&[S], S) -> S + Send + Sync + 'static,

Set the terminal cost phi(x(tf), tf).

pub fn running_cost<F>(self, f: F) -> Self

where F: Fn(S, &[S], &[S]) -> S + Send + Sync + 'static,

Set the running cost L(t, x, u).

pub fn terminal_constraint<F>(self, f: F) -> Self

where F: Fn(&[S]) -> Vec<S> + Send + Sync + 'static,

Set terminal equality constraints psi(x(tf)) = 0.

pub fn path_constraint<F>(self, f: F, bounds: &[(S, S)]) -> Self

where F: Fn(S, &[S], &[S]) -> Vec<S> + Send + Sync + 'static,

Set path constraints with bounds: lo <= c(t, x, u) <= hi.

pub fn control_bounds(self, bounds: &[(S, S)]) -> Self

Set bounds for each control variable (applied at every node).

pub fn state_bounds(self, bounds: &[(S, S)]) -> Self

Set bounds for each state variable (applied at every node).

pub fn params0(self, p0: &[S]) -> Self

Set initial guess for free parameters.

pub fn param_bound(self, idx: usize, lo: S, hi: S) -> Self

Set bounds for a specific parameter.

pub fn max_iter(self, n: usize) -> Self

Set maximum optimizer iterations.

pub fn solve(self) -> Result<CollocationResult<S>, OcpError>

where S: SimpleEntity + Conjugate<Canonical = S> + ComplexField,

Solve the collocation problem.