Piecewise Jerk Speed Optimization

• PJSO is a trajectory optimization method that constructs time-parameterizations using piecewise constant jerk segments to ensure smoothness and feasibility.
• It leverages convex programming techniques such as QP, LP, and SOCP alongside closed-form S-curve decompositions for efficient and real-time trajectory planning.
• The approach achieves near time-optimal trajectories while maintaining continuity in velocity, acceleration, and jerk, crucial for autonomous driving, robotics, and CNC applications.

Piece-wise Jerk Speed Optimization (PJSO) refers to a class of trajectory optimization methods that construct time-parameterizations of a reference path under explicit third-order (jerk) constraints, in addition to velocity and acceleration bounds. PJSO yields speed profiles—frequently in closed form or via efficient convex programming—that are composed of segments with constant (or piecewise-constant) jerk, which ensures feasibility with respect to actuation and comfort, makes the profiles physically smooth, and enables robust real-time implementation. PJSO is foundational in applications requiring strict dynamic feasibility under stringent comfort or mechanical-stress limits, such as autonomous driving, robotic manipulation, and high-speed machine tools.

1. Mathematical Foundations and Problem Statement

The central optimization problem underlying PJSO asks, given a reference path $\{P(s)\}$ of total arc-length $s_f$ and precomputed curvature $\kappa(s)$, to find a time-law $s(t)$ or speed law $v(s) = ds/dt$ that minimizes total traversal time $T = \int_0^{s_f} v(s)^{-1} ds$, subject to

• box or path-dependent speed limits: $0 \leq v(s) \leq v_{\max}(s)$, typically $$v_{\max}(s) = \min\{\bar v, \sqrt{A_N / |\kappa(s)|}\}$$,
• bounds on tangential acceleration: $|a_T(s)| = |v'(s)v(s)| \leq A$,
• bounds on jerk (third derivative): $|j(s)| \leq J$,
• boundary conditions (e.g. rest-to-rest: $s_f$0).

This leads to a nonconvex optimal control or nonlinear programming problem due to the product structures in the jerk constraints, e.g., $s_f$1. For many practical path-following and trajectory-generation modalities, the reference path may include direction reversals (e.g., in parallel parking), so speed profiles may be required to be monotonic within identified segments (Zhou et al., 2020, Consolini et al., 2023, Consolini et al., 2021).

2. Discrete-Time and Piece-wise Jerk Parameterization

PJSO exploits the fact that on sufficiently small intervals, jerk can be assumed constant. Using time discretization with step $s_f$2 and $s_f$3 intervals, the decision variables at each step $s_f$4 are $s_f$5, $s_f$6, and $s_f$7. On each interval $s_f$8, $s_f$9 is taken constant, yielding cubic-in-time interpolation for $\kappa(s)$0:

$\kappa(s)$1

This structure enables elimination of explicit jerk variables in favor of linear equality constraints between adjacent samples, reducing high-dimensional trajectory optimization to finite-dimensional convex or quasi-convex QP/SOCP/LP subproblems within each monotonic segment (Zhou et al., 2020, Consolini et al., 2023, Consolini et al., 2021, Shimizu et al., 2022).

3. Optimization Formulations: QP, LP, SOCP, and S-curve Decomposition

The PJSO methodology admits several instantiations depending on the system architecture and computational requirements:

• Convex Quadratic Program (QP): For the path/speed decoupled setting in autonomous driving, each segment solves a QP minimizing a weighted sum of squared time-to-goal, acceleration, and squared discrete jerk, subject to boundary, dynamics, box, and curvature-induced constraints. These QPs are structurally sparse (banded matrices), enabling rapid solution by first-order or interior-point methods (e.g., OSQP) (Zhou et al., 2020).
• Linear Programming (LP): By linearizing the nonconvex jerk constraints via a forward-backward pass (estimate $\kappa(s)$2 and use it as a surrogate), the problem reduces to an LP with explicit box, acceleration, and (linear) jerk constraints (Shimizu et al., 2022).
• Second-Order Cone Programming (SOCP): By epigraph reformulation, particularly for $\kappa(s)$3 constraints, PJSO can be cast as an SOCP, enabling provable convexity and efficient solution for large-scale problems, with relaxation being exact under mild assumptions (Consolini et al., 2023).
• Piece-wise Analytical S-curve or Bang–Bang Structure: For high-speed manufacturing and CNC, feedrate scheduling is handled by partitioning the overall path into sub-curves, within which a seven-phase S-curve (piecewise-constant jerk) profile is computed in closed form, with bidirectional scanning to saturate end speeds. The approach guarantees $\kappa(s)$4 continuity at all sub-curve boundaries, and allows additional post-processing (e.g., round-off elimination to align with controller sampling) (Hu et al., 2021, Auer et al., 2024, Auer et al., 2024).

A commonality across these approaches is the “bang–bang” structure of the optimal control: the jerk is always at one of its bounds except for singular arcs or under regularization (Pham et al., 2016, Whitehair et al., 2020).

4. Solving, Theoretical Properties, and Performance

The discrete PJSO QP is strictly convex, featuring affine equality constraints (for cubic and jerk dynamics) and affine or second-order cone constraints for box and jerk limits. This guarantees a unique global minimizer for each segment (Zhou et al., 2020, Consolini et al., 2023). When linearization or convex relaxation is used (LP/SOCP), empirical and theoretical studies show that the relaxation is generically exact—i.e., the optimal LP/SOCP solution coincides with the global optimum of the original nonconvex problem as long as the active set includes only the box constraints or the jerk constraint is not saturated at the speed-bound “ceiling” (Consolini et al., 2023, Consolini et al., 2021).

PJSO formulations have been observed to achieve real-time performance on modest hardware. For example, in parallel parking tasks with $\kappa(s)$5 and $\kappa(s)$6, each QP solve completes in 21–70 ms, and full pipelines (path smoothing + PJSO) in under 70 ms, suitable for autonomous driving (Zhou et al., 2020). In industrial robot and CNC contexts, closed-form S-curve primitives and sequence assembly enable sub-millisecond planning per move on embedded PLC or microcontroller targets, while maintaining trajectory feasibility and continuity (Hu et al., 2021, Auer et al., 2024, Auer et al., 2024).

5. Structural and Algorithmic Insights

Table: Representative PJSO Algorithmic Structures

Domain	Problem Discretization	Solution Class
Autonomous Driving	QP per monotonic path segment	Convex QP
Velocity Planning	Discretized b,a LP (linearized)	Sparse LP
Path-parameterization	$\kappa(s)$7, SOCP relaxation	SOCP (exact/approx.)
CNC/NURBS Feedrate	Analytic S-curve decomposition	Seven-phase, ODE
Oscillatory systems	Bang–bang jerk primitive stacking	Closed-form O(1)

• In path/speed decoupling architectures, PJSO segments are concatenated by identifying zero-velocity "gear shift" points; each QP/LP/SOCP can be independently warm-started and solved in parallel per segment (Zhou et al., 2020).
• Multiple works demonstrate that in very high-dimensional settings (e.g., n=1000), SOCP relaxations solve in $\kappa(s)$8 s, and LP or QP approaches, exploiting problem sparsity (banded or tridiagonal matrices), scale near linearly with number of samples (Consolini et al., 2023, Shimizu et al., 2022).
• For jerk-limited feedrate scheduling, the use of bidirectional scanning modules ensures that boundary continuity is enforced—not only for speed but also acceleration and jerk—unlike pure “bang–bang” strategies which can result in discontinuous jerk at segment joins (Hu et al., 2021).
• Theoretical results affirm that, under certain regularity conditions, negative-jerk constraints are never saturated at optimality, and positive-jerk violations only occur at indices where the speed is at its upper bound, supporting the widespread empirical exactness of the relaxed SOCP (Consolini et al., 2023).

6. Applications, Extensions, and Empirical Impact

PJSO is deployed at scale in:

• Autonomous driving, robotaxi motion planning: The DL-IAPS+PJSO system achieves high control feasibility, passenger comfort, and adherence to curvature and collision avoidance in both simulation and 400h real-world test runs, with <70 ms pipeline runtime per planning cycle (Zhou et al., 2020).
• Velocity planning for AVs: LP-based PJSO meets all dynamic and safety limits with sub-10 ms runtime and outperforms pseudo-jerk QP and nonconvex NLP in efficiency and constraint satisfaction (Shimizu et al., 2022).
• CNC machining, NURBS interpolation: Piecewise S-curve PJSO, with error elimination modules, reduces chord error by 10–15% and achieves full jerk and acceleration continuity, at less than 1% increase in cycle time compared to unconstrained “bang–bang” (Hu et al., 2021).
• Industrial robotics, flexible manipulators: Multiple shooting and primal-assembly approaches (e.g., TOPP3) allow for globally feasible, near time-optimal trajectories in presence of third-order constraints and dynamic couplings (Pham et al., 2016, Auer et al., 2024, Auer et al., 2024, Kiemel et al., 2024).
• Pulse-and-glide eco-driving: Pontryagin-based PJSO frameworks yield explicit thresholds characterizing when “bang–bang” jerk is optimal versus smooth profiles, enabling real-time synthesis for consumption-optimized vehicle control (Whitehair et al., 2020).

Systematic empirical validation demonstrates the reliability and real-time performance of PJSO in large-scale, safety-critical deployments, with solution times consistently within deterministic bounds for practical task sizes (Zhou et al., 2020, Shimizu et al., 2022, Consolini et al., 2021, Hu et al., 2021, Kiemel et al., 2024, Auer et al., 2024).

7. Extensions and Theoretical Developments

Recent PJSO research addresses:

• Convex relaxation and global optimality: SOCP formulations provide strong certificate-based heuristics for the underlying nonconvex OCP, with empirical evidence for exactness in thousands of randomized configurations (Consolini et al., 2023).
• Handling singularities and multiple-shooting stitching: For time-optimal path-parameterization with third-order constraints, singular surfaces (where jerk control is ill-defined) are addressed by bridging “max-jerk” phases with multiple shooting across the singular curve (Pham et al., 2016).
• Multi-dimensional path tracking under jerk-constrained parametrizations: Iterative schemes leverage the envelope of feasible progress along each axis to tightly track high-DOF reference paths, outperforming RL-based and naive S-curve planners while controlling deviation and mechanical stress (Kiemel et al., 2024).
• Implementation on systems with internal oscillatory dynamics: Closed-form primitives, assembled via binary search and case logic on a small number of jerk segments, enable PJSO to match or outperform vibration shapers and direct OCP at a fraction of CPU cost (Auer et al., 2024, Auer et al., 2024).

In sum, PJSO constitutes a grounding paradigm for real-time, constraint-feasible, comfort-aware, and nearly time-optimal trajectory generation under third-order dynamic constraints across a spectrum of robotics, automation, and autonomous vehicle domains.