The Jacobian and Velocity Kinematics

FK gives a static map $q \mapsto x$. Differentiate with respect to time and you get the velocity kinematics relation:

$\dot{x} = J(q) \, \dot{q}$

Here $\dot{q} \in \mathbb{R}^n$ is the vector of joint velocities, $\dot{x} \in \mathbb{R}^m$ is the end-effector velocity (linear + angular), and $J(q) \in \mathbb{R}^{m \times n}$ is the Jacobian — a matrix that depends on the current configuration $q$. For a 6-DOF arm, $m = 6$ (three linear, three angular) and $J$ is $6 \times 6$. For the 2-link planar arm computing only position, $m = 2$, $n = 2$, and $J$ is $2 \times 2$. The Jacobian is the local, linearized version of FK.

For the 2-link planar arm with FK

$x = l_1 c_1 + l_2 c_{12}, \qquad y = l_1 s_1 + l_2 s_{12}$

take partial derivatives:

$J(q) = \frac{\partial(x,y)}{\partial(q_1,q_2)} = \begin{bmatrix} -l_1 s_1 - l_2 s_{12} & -l_2 s_{12} \\ l_1 c_1 + l_2 c_{12} & l_2 c_{12} \end{bmatrix}$

where $c_{12} = \cos(q_1+q_2)$, $s_{12} = \sin(q_1+q_2)$. Each column $j$ of $J$ is the rate of change of the end-effector position when only joint $j$ moves, with all other joints fixed. Column 1 depends on both $q_1$ and $q_2$; column 2 depends only on $q_2$.

The determinant of $J$ measures how much end-effector velocity you get per unit joint velocity:

$\det J_{2\text{-link}} = l_1 l_2 \sin q_2$

When $\sin q_2 = 0$ — i.e., $q_2 = 0$ or $q_2 = \pi$ (fully extended or fully folded) — the Jacobian is singular. Physically: in this configuration the arm cannot instantaneously move the end-effector in a certain direction no matter how fast the joints spin. Three consequences:

1. The inverse $J^{-1}$ does not exist — you cannot directly compute joint velocities from Cartesian velocities.
2. Nearby, $J^{-1}$ has large eigenvalues — tiny Cartesian velocity demands enormous joint velocities.
3. Manipulability $w = \sqrt{\det(JJ^\top)} \to 0$ — the arm is in a mechanically disadvantaged posture.

When $J$ is square and invertible, joint velocities for a desired Cartesian velocity are:

$\dot{q} = J^{-1}(q) \, \dot{x}$

When $J$ is not square (redundant arm, $n > m$) or near-singular, use the Moore-Penrose pseudoinverse $J^+$:

$J^+ = J^\top (J J^\top)^{-1} \quad (\text{right pseudoinverse, for } n > m)$

The pseudoinverse solution $\dot{q} = J^+ \dot{x}$ gives the minimum-norm joint velocity achieving the desired Cartesian velocity — it distributes the motion across joints as evenly as possible. Near singularities add damped least squares (DLS) regularization:

$J^+ \approx J^\top (J J^\top + \lambda^2 I)^{-1}$

The damping factor $\lambda$ limits joint velocity spikes at the cost of a small tracking error.

import numpy as np

def jacobian_2link(q1, q2, l1=1.0, l2=0.8):
    """Analytic 2x2 Jacobian for the 2-link planar arm."""
    s1   = np.sin(q1)
    c1   = np.cos(q1)
    s12  = np.sin(q1 + q2)
    c12  = np.cos(q1 + q2)
    return np.array([
        [-(l1*s1 + l2*s12), -l2*s12],
        [ (l1*c1 + l2*c12),  l2*c12]
    ])

def dls_inverse(J, lam=0.05):
    """Damped least-squares pseudoinverse."""
    return J.T @ np.linalg.inv(J @ J.T + lam**2 * np.eye(J.shape[0]))

# Desired end-effector velocity [vx, vy]
q = np.array([np.pi/4, np.pi/3])
xdot_desired = np.array([0.1, 0.0])  # move at 0.1 m/s in x

J = jacobian_2link(*q)
qdot = dls_inverse(J) @ xdot_desired
print("det(J):", np.linalg.det(J))
print("Joint velocities:", np.degrees(qdot), "deg/s")

Always check np.linalg.det(J) before applying $J^{-1}$ directly; switch to DLS when the determinant is below a threshold (e.g., 1e-3).

Yoshikawa's manipulability measure quantifies how far the arm is from a singularity:

$w(q) = \sqrt{\det\bigl(J(q)\,J(q)^\top\bigr)}$

For a square $J$ this simplifies to $|\det J|$. Interpretation:

• $w = 0$: singular configuration — one or more directions are unreachable.
• Large $w$: the arm can move freely in all directions; joint effort is well-distributed.

The manipulability ellipsoid $\{\dot{x} : \|\dot{q}\| \le 1\}$ has semi-axes equal to the singular values of $J$. A round ellipsoid (all singular values equal) is ideal; a very flat ellipsoid signals near-singularity in one direction.

def manipulability(J):
    return np.sqrt(max(np.linalg.det(J @ J.T), 0.0))

Path planners and posture optimizers use $w(q)$ as a cost function — stay away from singularities to maintain control authority.

How joint velocities become Cartesian velocities and back:

For 6-DOF arms the Jacobian becomes $6 \times 6$ and encodes both linear and angular velocity. The geometric Jacobian columns are built joint by joint:

• Revolute joint $i$: column $= \begin{bmatrix} z_{i-1} \times (p_n - p_{i-1}) \\ z_{i-1} \end{bmatrix}$ (linear and angular parts)
• Prismatic joint $i$: column $= \begin{bmatrix} z_{i-1} \\ 0 \end{bmatrix}$

where $z_{i-1}$ is the $z$-axis of frame $\{i-1\}$ in the world, and $p_n - p_{i-1}$ is the vector from joint $i$'s origin to the end-effector.

A simple alternative to pseudoinverse for force control is the Jacobian transpose: $\tau = J^\top F$, which maps Cartesian forces to joint torques without any matrix inversion — numerically safe even at singularities. These relationships are the bridge from kinematics to dynamics and control.