Enum LinearizationModeTopp3 

pub enum LinearizationModeTopp3<'a> {
    Direct,
    GivenFeasibleAdaptive(&'a [f64]),
}

Where the third-order rows of a station take their linearization point.

The tangent of 1/sqrt(a) lies below 1/sqrt(a) for every positive anchor, so both variants keep the linearized rows an inner approximation of the nonlinear ones; they differ only in how tight that approximation is and in which a the rows still admit.

Typical usage:

• Default to LinearizationModeTopp3::Direct, which reproduces the historical behaviour.
• LinearizationModeTopp3::GivenFeasibleAdaptive requires a_linearization to be the a of a previously solved third-order profile and that profile’s b to be at hand; a lower-order profile discretizes b as (a[k+1] - a[k]) / (2 * ds[k]) rather than through a[k+1] = a[k] + (b[k] + b[k+1]) * ds[k], so its state cannot be used here.
• Given those, prefer it whenever a spans a wide range over the window, and especially when a can reach the 1e-10 scale of EPS_ZERO. The upper and lower row of one axis differ only by an overall sign, so anchoring both at the same small a_linearization[k] cancels b and c and leaves a[k] <= 3 * a_linearization[k] – a cap set by the anchor rather than by the jerk limit, and one that no b or c can offset. Adapting each row separately breaks the cancellation.
• On a profile that stays well away from zero the two agree closely, and LinearizationModeTopp3::Direct is the cheaper of the two.

Variants

Direct

Direct: every row of a station is linearized at a_linearization[k].

GivenFeasibleAdaptive(&'a [f64])

GivenFeasibleAdaptive(b_linearization): each row is anchored where that row is nearly active at the feasible state (a_linearization, b_linearization), so a slack row is anchored high and a tight one stays near the state. b_linearization must be the path acceleration of the same profile as a_linearization, with the same length; it is normally taken from a previously computed feasible third-order profile.

Trait Implementations

impl<'a> Clone for LinearizationModeTopp3<'a>

fn clone(&self) -> LinearizationModeTopp3<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for LinearizationModeTopp3<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for LinearizationModeTopp3<'a>

fn default() -> LinearizationModeTopp3<'a>

Returns the “default value” for a type.

impl<'a> PartialEq for LinearizationModeTopp3<'a>

fn eq(&self, other: &LinearizationModeTopp3<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Copy for LinearizationModeTopp3<'a>

impl<'a> StructuralPartialEq for LinearizationModeTopp3<'a>