Newton-Euler Equations

This component governs the translational motion of a rigid body's center of mass. It states that the net external force applied to a body equals the product of its mass and the linear acceleration of its center of mass. The equation is: F = m * a_cm. Here, F is the net force vector, m is the scalar mass, and a_cm is the linear acceleration vector of the center of mass. This law is applied in the world frame or an inertial frame.

This component governs the rotational motion about the center of mass. It states that the net external torque about the center of mass equals the rate of change of the angular momentum. In the body-fixed frame, it is expressed as: τ = I * α + ω × (I * ω). Key terms are:

• τ: Net torque vector about the center of mass.
• I: The 3x3 inertia tensor in the body frame.
• α: Angular acceleration vector.
• ω: Angular velocity vector. The term ω × (I * ω) is the gyroscopic term or centrifugal torque, a consequence of expressing the equation in a rotating frame.

The inertia tensor (I) is a 3x3 symmetric matrix that encodes the mass distribution of a rigid body relative to its center of mass. It determines how the body resists angular acceleration in different directions. Its components are:

• Diagonal elements (I_xx, I_yy, I_zz): Moments of inertia about the principal axes.
• Off-diagonal elements: Products of inertia, which are zero if the axes align with the body's principal axes. For simulation, it is constant when expressed in a body-fixed frame aligned with the principal axes, simplifying Euler's equation.

Correct application requires careful tracking of coordinate frames. Key frames are:

• Inertial Frame (World Frame): A fixed, non-accelerating reference. Newton's law is valid here.
• Body-Fixed Frame: A frame attached to and moving with the body. Euler's equation is most naturally expressed here. Forces and torques from actuators or contacts are often computed in world coordinates and must be transformed into the appropriate frame. The rotation matrix or quaternion representing the body's orientation is a critical state variable.

The Newton-Euler formulation is used to solve two fundamental problems:

• Forward Dynamics: Given the applied forces and torques (F, τ), compute the resulting linear acceleration (a) and angular acceleration (α). This is used for simulation.
• Inverse Dynamics: Given a desired motion (trajectory of a and α), compute the required forces and torques (F, τ). This is essential for model-based control, such as computing joint torques for a robotic manipulator to follow a path.

For multi-link systems like robot arms, the basic Newton-Euler equations are applied recursively. The Recursive Newton-Euler Algorithm (RNEA) is an O(n) method that performs two passes:

1. Forward Pass: Propagates kinematics (velocities, accelerations) from the base to the end-effector.
2. Backward Pass: Computes forces and torques by propagating from the end-effector back to the base, using the Newton-Euler equations for each link. This is the workhorse algorithm for efficient inverse dynamics in robotics.

Every modern physics engine (e.g., NVIDIA PhysX, Bullet, MuJoCo) implements the Newton-Euler equations at its core to compute realistic motion. They are solved numerically each time step to:

• Update the linear velocity and position of a body's center of mass.
• Update the angular velocity and orientation.
• This deterministic calculation forms the forward dynamics backbone for Sim-to-Real Transfer Learning, creating a high-fidelity training environment.

For precise robotic manipulation and locomotion, controllers use the equations in their inverse dynamics form. Given a desired acceleration for a robot's end-effector (from a high-level planner), the controller calculates the required joint torques. This is critical for:

• Operational Space Control frameworks.
• Computing gravity compensation torques.
• The Featherstone Algorithm, an O(n) recursive method for computing dynamics of complex articulated chains, is derived from the Newton-Euler recursive formulation.

Simulating robots walking or grasping requires modeling contact forces. The Newton-Euler equations are integrated with constraint solvers that compute these forces. The solver's job is to find contact impulses that, when applied, satisfy two conditions derived from the equations:

1. Non-penetration: Bodies do not intersect.
2. Coulomb friction: Tangential forces lie within the friction cone. This is often formulated as a Linear Complementarity Problem (LCP).

To bridge the reality gap, simulation parameters (like mass, inertia, friction) must be calibrated to real hardware. This system identification process uses the Newton-Euler equations as the forward model. By comparing simulated motion from the equations to real sensor data (e.g., from IMUs), engineers can iteratively tune parameters, increasing simulation fidelity for more robust policy transfer.

In both simulation and real-time control, the equations are used to predict motion and enforce safety. Velocity and torque limits at robot joints are constraints applied during the dynamics calculation. This predictive capability allows for:

• Pre-collision detection and avoidance.
• Simulating failure modes safely in a digital twin.
• Ensuring dynamic consistency in warm-started constraint solvers for stable, real-time performance.

While deep Reinforcement Learning can learn dynamics implicitly, the Newton-Euler equations provide a strong inductive bias. They are used in:

• Physics-informed neural networks (PINNs), where the equations act as a regularization loss.
• Differentiable physics simulators, where gradients flow through the dynamics equations to optimize control policies or design parameters directly.
• Providing interpretable feature spaces (e.g., forces, inertias) for model-based RL algorithms.

A rigid body is an idealized solid object where the distance between any two points remains constant, regardless of applied forces. This simplification allows its complete state to be described by:

• Position and orientation of its center of mass.
• Linear velocity and angular velocity.
• Its mass and inertia tensor. This abstraction is fundamental to physics engines, as it reduces the complex dynamics of deformable objects to the six degrees of freedom described by the Newton-Euler equations.

The inertia tensor is a 3x3 symmetric matrix that quantifies a rigid body's resistance to rotational acceleration. It encapsulates how mass is distributed relative to the body's center of mass.

• It is the rotational analog of mass in Newton's second law.
• The diagonal elements are the moments of inertia about the principal axes.
• The off-diagonal elements are the products of inertia, which are zero if the axes align with the body's principal axes of rotation. In the Euler equation (τ = Iα + ω × Iω), the inertia tensor I is crucial for calculating the angular acceleration α resulting from an applied torque τ.

Forward dynamics is the process of computing a system's acceleration (linear and angular) given the known forces and torques acting upon it. This is the direct application of the Newton-Euler equations.

• Input: Mass properties, current state (position, velocity), and applied wrenches (force-torque pairs).
• Output: Linear acceleration a and angular acceleration α.
• Process: Integrate accelerations to update velocities, then integrate velocities to update positions for the next simulation time step. It is the core computation in physics simulation for predicting motion.

Inverse dynamics solves the opposite problem: calculating the forces and torques required to produce a desired motion or acceleration trajectory.

• Input: Desired kinematic trajectory (position, velocity, acceleration).
• Output: The necessary joint torques or applied forces.
• Application: Essential for model-based control of robotic manipulators, motion planning, and biomechanics analysis. It relies on rearranging the Newton-Euler equations to solve for the unknown inputs, often using recursive algorithms like the Featherstone algorithm for efficiency.

The Featherstone Algorithm (Articulated Body Algorithm) is an O(n) recursive method for efficiently computing the forward dynamics of complex, articulated rigid body systems, like robotic arms or humanoid robots.

• It avoids the computational cost of formulating and inverting the large, system-wide mass matrix.
• It propagates calculations through the kinematic chain using spatial vector algebra, which compactly represents 6D motions and forces.
• This efficiency makes it the standard in robotics simulation and real-time control, directly implementing the Newton-Euler equations in a recursive form.

Spatial vector algebra is a 6D mathematical framework that unifies the linear and angular components of rigid body motion and force into single vector entities.

• A spatial velocity combines linear (v) and angular (ω) velocity: V = [ω; v].
• A spatial force (wrench) combines torque (τ) and force (f): F = [τ; f].
• This notation dramatically simplifies the formulation of multi-body dynamics algorithms, including the recursive Newton-Euler equations and the Featherstone algorithm, by treating complex cross-coupling terms more elegantly.