Struct Topp3ProblemBuilder 

pub struct Topp3ProblemBuilder<'a> {
    pub constraints: &'a mut Constraints,
    pub idx_s_start: usize,
    pub a_linearization: &'a [f64],
    pub a_boundary: (f64, f64),
    pub b_boundary: (f64, f64),
    pub num_stationary_max: (usize, usize),
    pub a_linearization_floor: f64,
}

Builder for Topp3Problem, including optional in-build linearization.

Side effect notice

build_with_linearization updates cached affine linearization data inside Constraints. Raw jerk constraints remain unchanged.

Why mutable?

Third-order jerk rows are stored in nonconvex form after Robot::with_axial_jerk or Constraints::with_constraint_3order. build_with_linearization evaluates an affine approximation around a_linearization and writes the generated coefficients into the constraint cache. Rebuild the problem whenever the linearization profile changes.

Example

The example below builds a TOPP3 problem and lets the builder linearize the third-order constraints.

use copp::robot::Robot;
use copp::solver::topp3_lp::Topp3ProblemBuilder;

let mut robot = Robot::with_capacity(2usize, 3);
let s = [0.0, 0.5, 1.0];
robot.with_s(s.as_slice())?;

let a_linearization = [0.0, 0.25, 0.0];
let _problem = Topp3ProblemBuilder::new(
    &mut robot,
    0,
    &a_linearization,
    (0.0, 0.0),
    (0.0, 0.0),
)
.build_with_linearization()?;

Fields

constraints: &'a mut Constraints

Mutable constraint storage used to build linearized TOPP3 problem data.

idx_s_start: usize

Start station index of the optimization interval.

a_linearization: &'a [f64]

Reference profile a[k] used to linearize third-order constraints.

a_boundary: (f64, f64)

Boundary values of a=(a_start, a_final).

b_boundary: (f64, f64)

Boundary values of b=(b_start, b_final).

num_stationary_max: (usize, usize)

User-input upper bound of stationary intervals at (start, end).

a_linearization_floor: f64

Denominator floor for stable evaluation of 1/sqrt(a_linearization) near a=0.

Effective usage in linearization is: $$ \frac{1}{\sqrt{\max(a_{lin}, a_{floor})}}. $$ Discrete code form: 1.0 / max(a_linearization, a_linearization_floor).sqrt().

More details are available in the Topp3Problem documentation.

Implementations

impl<'a> Topp3ProblemBuilder<'a>

pub fn new<M: RobotBasic>( robot: &'a mut Robot<M>, idx_s_start: usize, a_linearization: &'a [f64], a_boundary: (f64, f64), b_boundary: (f64, f64), ) -> Self

Create a TOPP3 builder with required fields.

Defaults:

• num_stationary_max = (1, 1)
• a_linearization_floor = 1E-10

pub fn with_constraint( constraints: &'a mut Constraints, idx_s_start: usize, a_linearization: &'a [f64], a_boundary: (f64, f64), b_boundary: (f64, f64), ) -> Self

Create a TOPP3 builder with required fields.

Defaults:

• num_stationary_max = (1, 1)
• a_linearization_floor = 1E-10

pub fn with_num_stationary_max(self, num_stationary_max: usize) -> Self

Set symmetric stationary upper bound: num_stationary_max=(n,n).

See module-level Stationary-boundary modeling note for guidance.

pub fn with_num_stationary_max_pair( self, num_stationary_max: (usize, usize), ) -> Self

Set asymmetric stationary upper bound: num_stationary_max=(start,end).

See module-level Stationary-boundary modeling note for guidance.

pub fn with_a_linearization_floor(self, floor: f64) -> Self

Set denominator floor used in third-order linearization near a = 0.

build_with_linearization applies 1.0 / max(a_linearization[k], floor).sqrt() when converting nonlinear jerk rows into affine rows.

pub fn build_with_linearization(self) -> Result<Topp3Problem<'a>, CoppError>

Build a TOPP3 problem and linearize third-order constraints in one step.

This validates boundaries/interval/floor first, then writes linearized jerk buffers inside Constraints. The generated rows can be inspected with Constraints::get_jerk_linear_constraints.

Rebuilding rule

If a later solver result is used as a new a_linearization, create a new builder and call build_with_linearization again before solving.