Featherstone Algorithm

The algorithm's primary innovation is its linear computational complexity relative to the number of joints, n. It achieves this by performing a single forward recursion from the base to the tip to compute velocities and a backward recursion to compute forces, avoiding the O(n³) cost of naively inverting the mass matrix. This makes it exceptionally efficient for robots with many degrees of freedom, such as humanoid or snake-like manipulators.

A core concept is the Articulated Body Inertia (ABI), which represents the effective inertia of a subtree of the robot as felt at a specific joint. The algorithm recursively computes the ABI for each link, propagating it from the end-effector back to the base. This abstraction allows the dynamics of the entire chain to be solved locally at each joint without global matrix operations.

• Key Insight: The ABI captures how the motion of one link is dynamically coupled to all the links further out the chain.

The algorithm is built upon a recursive Newton-Euler framework. It decomposes the dynamics calculation into two sweeps:

• Forward Recursion: Starting from the base (assumed fixed or moving), propagates link velocities and accelerations outward.
• Backward Recursion: Starting from the end-effector, uses the Articulated Body Inertia to compute joint forces/torques and propagates them inward.

This recursive structure is naturally suited for the serial topology of most robot arms and legs.

While optimal for serial chains, the algorithm elegantly extends to branching kinematic trees, which describe robots with multiple limbs (e.g., a torso with two arms and two legs). The recursion logic is applied to each branch, with the ABI computation properly aggregating inertias at branching links. This makes it a foundational algorithm for full-body dynamics of legged robots and complex manipulators.

For inverse dynamics (calculating torques from desired motion), the algorithm is particularly straightforward. The forward recursion computes the accelerations of each link resulting from the desired joint accelerations and known external forces (like gravity). The backward recursion then directly computes the required joint torques. This O(n) inverse dynamics is used extensively for model-based control techniques like computed-torque control.

The Featherstone algorithm forms the computational core of high-performance physics engines used in robotics simulation and research. Its efficiency and numerical stability are critical for real-time and faster-than-real-time simulation.

• Example Implementations: It is the underlying dynamics solver in engines like MuJoCo and Simbody, where its speed enables massive parallelization for reinforcement learning and trajectory optimization.

Forward dynamics is the computational process of calculating the resulting motion (accelerations, velocities, positions) of a robotic system given the applied forces and torques at its joints and links. It answers the question: "What motion results from these forces?"

• Core Calculation: Solves for joint accelerations given applied torques and the current state.
• Featherstone's Role: The Featherstone Algorithm provides an O(n) solution for forward dynamics on serial chains, far more efficient than the O(n³) naive matrix inversion approach.
• Application: Essential for simulating how a robot will move under its own control signals within a physics engine like MuJoCo or Bullet.

Inverse dynamics is the computational process of calculating the forces and torques required at a robot's joints to produce a desired motion trajectory, given the robot's kinematic and inertial parameters. It answers: "What forces are needed to create this motion?"

• Core Calculation: Computes required joint torques given desired positions, velocities, and accelerations.
• Featherstone's Role: The Articulated Body Algorithm (ABA) variant of Featherstone's method efficiently computes inverse dynamics, which is critical for model-based control techniques like computed-torque control.
• Application: Used in trajectory optimization, controller design, and verifying that planned motions are dynamically feasible.

Rigid-body dynamics is the branch of mechanics that models the motion of non-deformable objects under the influence of forces and torques. It forms the core computational model for physics-based robotic simulation.

• Foundational Assumption: Bodies do not deform; all points on a body maintain fixed relative distances.
• Governing Equations: Motion is described by Newton-Euler equations, combining translational and rotational dynamics.
• Connection to Featherstone: The Featherstone Algorithm is a specialized, recursive formulation of rigid-body dynamics equations optimized for articulated systems (robots) with a tree-like structure. It avoids dealing with the full system mass matrix directly.

The Articulated Body Algorithm is the specific name for the O(n) forward dynamics algorithm developed by Roy Featherstone. It is the direct implementation of his method for calculating joint accelerations.

• Key Innovation: Treats each link in the kinematic chain as an "articulated body"—a rigid body connected to others via joints—and uses a recursive propagation of inertia and forces.
• Two-Pass Process:
  • Outward Pass: Recursively computes velocities and composite rigid-body inertias.
  • Inward Pass: Recursively computes accelerations and constraint forces.
• Efficiency: Its linear O(n) complexity in the number of joints (n) makes it the standard for real-time simulation of complex robotic manipulators.

The Recursive Newton-Euler Algorithm is the O(n) inverse dynamics algorithm often paired with the Featherstone ABA. It is the inverse dynamics counterpart to the Articulated Body Algorithm.

• Two-Pass Structure:
  • Forward Recursion: Propagates kinematics (velocities, accelerations) from the base to the end-effector.
  • Backward Recursion: Propagates forces and torques from the end-effector back to the base, calculating the required joint torques.
• Computational Role: While the ABA solves forward dynamics, the RNEA solves inverse dynamics. Both are recursive O(n) algorithms that exploit the serial chain structure, making them vastly more efficient than global matrix methods for robots with many degrees of freedom.

Spatial vector algebra is the 6D mathematical framework (combining 3D linear and 3D angular components) that the Featherstone Algorithm uses for its recursive formulations. It is the notational and conceptual key to its elegance and efficiency.

• Unified Representation: Represents velocity, acceleration, force, and inertia in a compact 6D vector, simplifying the Newton-Euler equations.
• Featherstone's Contribution: His algorithm and its associated spatial notation provide a compact way to express and compute the dynamics of rigid-body systems. The recursive formulas for articulated body inertia and bias forces are expressed cleanly in this algebra.
• Impact: This framework is now standard in advanced robotics textbooks and software libraries for dynamics computation, separating it from more cumbersome 3D vector approaches.