Kinematics and control · Lesson 4 of 12

Inverse kinematics and Jacobians for robot arms

Solve inverse kinematics for a 2-link arm in closed form, build the Jacobian, find singularities, and write damped least-squares IK and resolved-rate control.

intermediate50 minUpdated Fact-checked Free

What you will learn

  • Solve the planar 2-link inverse kinematics in closed form and pick the elbow-up or elbow-down solution
  • Build the Jacobian of a serial chain analytically or by finite differences and explain what its columns mean
  • Detect singularities from the determinant, the manipulability and the singular values of the Jacobian
  • Implement Jacobian-transpose, pseudo-inverse and damped least-squares IK and choose the damping factor
  • Command Cartesian tip velocities with resolved-rate control while respecting joint limits

Before you start

  • Spatial maths: rotations and homogeneous transforms (lesson 2)
  • Forward kinematics (lesson 3)
  • Matrix inverse and least squares from linear algebra

After this lesson you can compute the joint angles that put a robot arm’s tip at a given point, both in closed form for a 2-link arm and numerically for any serial chain. You will use the Jacobian to relate joint velocities to tip velocity, recognise singular configurations before they cause trouble, and drive the tip along a straight line with resolved-rate control.

The inverse problem

Forward kinematics maps joint angles qq to a tip pose x=f(q)x = f(q). It always has exactly one answer. Inverse kinematics (IK) asks for the qq that gives a wanted x∗x^*, and that question can have no solution, a finite number of solutions or infinitely many:

  • No solution: the target lies outside the workspace, or the arm lacks the joints to reach that orientation.
  • A finite number: a planar 2-link arm reaches most points in two ways, elbow up and elbow down.
  • Infinitely many: the arm is redundant, with more joints than task coordinates. A planar 3-link arm placing only its tip position has one spare degree of freedom.

The SO-101 follower arm has five arm joints (shoulder pan, shoulder lift, elbow flex, wrist flex, wrist roll) plus a gripper. A full pose in 3D has six numbers, so the SO-101 cannot reach an arbitrary position and orientation; a target pose must be chosen within what five joints can do. Its shoulder lift, elbow flex and wrist flex axes are parallel, so once the shoulder pan has turned the arm towards the target, the shoulder and elbow form a planar 2-link arm in a vertical plane. In the SO-101 URDF published in the SO-ARM100 repository, the elbow axis sits about 0.116 m from the shoulder-lift axis and the wrist-flex axis about 0.135 m from the elbow. That is why the planar case below is not only a textbook exercise.

Take two links of length l1l_1 and l2l_2, joint angles q1q_1 (from the x axis) and q2q_2 (relative to link 1). Forward kinematics is

x=l1cos⁡q1+l2cos⁡(q1+q2),y=l1sin⁡q1+l2sin⁡(q1+q2).x = l_1 \cos q_1 + l_2 \cos(q_1 + q_2), \qquad y = l_1 \sin q_1 + l_2 \sin(q_1 + q_2).

Elbow angle from the law of cosines

The base, elbow and tip form a triangle with sides l1l_1, l2l_2 and r=x2+y2r = \sqrt{x^2 + y^2}. The law of cosines gives the elbow angle directly:

cos⁡q2=x2+y2−l12−l222l1l2,q2=atan2⁡ ⁣(±1−cos⁡2q2, cos⁡q2).\cos q_2 = \frac{x^2 + y^2 - l_1^2 - l_2^2}{2 l_1 l_2}, \qquad q_2 = \operatorname{atan2}\!\left(\pm\sqrt{1 - \cos^2 q_2},\ \cos q_2\right).

The sign choice gives the two solutions. With the convention in the download, q2≥0q_2 \ge 0 is called elbow down and q2≤0q_2 \le 0 elbow up; for a target to the right of the base, q2>0q_2 > 0 puts the elbow below the line from base to tip. Use atan2 rather than acos: it keeps the sign and stays accurate near 00 and π\pi.

Shoulder angle

The shoulder angle is the direction to the target minus the angle that link 2 adds:

q1=atan2⁡(y,x)−atan2⁡ ⁣(l2sin⁡q2, l1+l2cos⁡q2).q_1 = \operatorname{atan2}(y, x) - \operatorname{atan2}\!\left(l_2 \sin q_2,\ l_1 + l_2 \cos q_2\right).

Reachability

A real q2q_2 exists only if ∣cos⁡q2∣≤1|\cos q_2| \le 1, which is the same as

∣l1−l2∣≤r≤l1+l2.|l_1 - l_2| \le r \le l_1 + l_2 .

The workspace is an annulus. On its outer circle the arm is fully stretched (q2=0q_2 = 0) and on the inner circle fully folded (q2=πq_2 = \pi); there the two solutions merge into one. Real joint limits cut further pieces out of the annulus, so check the limits after solving.

Worked example

Example values: l1=0.30l_1 = 0.30 m, l2=0.20l_2 = 0.20 m, target (0.35,0.20)(0.35, 0.20) m.

  1. r2=0.352+0.202=0.1625r^2 = 0.35^2 + 0.20^2 = 0.1625, so r=0.403r = 0.403 m, inside the annulus from 0.10 m to 0.50 m.
  2. cos⁡q2=(0.1625−0.09−0.04)/(2⋅0.30⋅0.20)=0.0325/0.12=0.2708\cos q_2 = (0.1625 - 0.09 - 0.04) / (2 \cdot 0.30 \cdot 0.20) = 0.0325 / 0.12 = 0.2708.
  3. Elbow down: sin⁡q2=+0.9626\sin q_2 = +0.9626, q2=74.29°q_2 = 74.29°.
  4. atan2⁡(0.20,0.35)=29.74°\operatorname{atan2}(0.20, 0.35) = 29.74° and atan2⁡(0.20⋅0.9626, 0.30+0.20⋅0.2708)=atan2⁡(0.1925,0.3542)=28.53°\operatorname{atan2}(0.20 \cdot 0.9626,\ 0.30 + 0.20 \cdot 0.2708) = \operatorname{atan2}(0.1925, 0.3542) = 28.53°, so q1=1.22°q_1 = 1.22°.
  5. Elbow up: q2=−74.29°q_2 = -74.29° and q1=29.74°+28.53°=58.27°q_1 = 29.74° + 28.53° = 58.27°.

Always check an IK result with forward kinematics. A condensed version of ik_2link from the download:

def ik_2link(x: float, y: float, l1: float, l2: float,
             elbow: Literal["up", "down"] = "down") -> tuple[float, float]:
    r2 = x * x + y * y
    c2 = (r2 - l1 * l1 - l2 * l2) / (2.0 * l1 * l2)
    if c2 > 1.0 + 1e-12 or c2 < -1.0 - 1e-12:
        raise ValueError("target is out of reach")
    c2 = float(np.clip(c2, -1.0, 1.0))
    s2 = np.sqrt(1.0 - c2 * c2) * (1.0 if elbow == "down" else -1.0)
    q2 = np.arctan2(s2, c2)
    q1 = np.arctan2(y, x) - np.arctan2(l2 * s2, l1 + l2 * c2)
    return float(q1), float(q2)
$ python ik.py
elbow down: q1 =    1.22 deg, q2 =   74.29 deg, FK -> (0.3500, 0.2000)
elbow up  : q1 =   58.27 deg, q2 =  -74.29 deg, FK -> (0.3500, 0.2000)

The np.clip matters: a target exactly on the boundary can give cos⁡q2=1.0000000000000002\cos q_2 = 1.0000000000000002 from rounding, and sqrt of a tiny negative number returns NaN.

The Jacobian

Closed-form IK exists only for simple geometries. For the general case you need the Jacobian, the matrix of partial derivatives of the forward kinematics:

x˙=J(q) q˙,Jij=∂fi∂qj.\dot{x} = J(q)\,\dot{q}, \qquad J_{ij} = \frac{\partial f_i}{\partial q_j}.

Column jj is the tip velocity you get when joint jj turns at 1 rad/s and all other joints are still. For a revolute joint with unit axis zjz_j through point pjp_j, the tip at pp moves with linear velocity zj×(p−pj)z_j \times (p - p_j), and the tip frame rotates with angular velocity zjz_j. Stacking both gives the 6-row geometric Jacobian of a spatial arm. When you only care about tip position, keep the top three rows.

For the planar 2-link arm every axis points out of the page, and the cross product reduces to a 90° rotation of the vector from joint to tip:

J=[−l1sin⁡q1−l2sin⁡(q1+q2)−l2sin⁡(q1+q2)−l1cos⁡q1+l2cos⁡(q1+q2)−l2cos⁡(q1+q2)].J = \begin{bmatrix} -l_1 \sin q_1 - l_2 \sin(q_1 + q_2) & -l_2 \sin(q_1 + q_2) \\ \phantom{-}l_1 \cos q_1 + l_2 \cos(q_1 + q_2) & \phantom{-}l_2 \cos(q_1 + q_2) \end{bmatrix}.

At the elbow-down solution of the worked example:

J=[−0.200−0.194−0.350−0.050] m/rad.J = \begin{bmatrix} -0.200 & -0.194 \\ \phantom{-}0.350 & \phantom{-}0.050 \end{bmatrix}\ \text{m/rad}.

The first column is (−y,x)(-y, x) of the tip, as expected for rotation about the base. Turning joint 1 at 0.1 rad/s moves the tip at (−0.020,0.035)(-0.020, 0.035) m/s.

Numerical Jacobian

If you have forward kinematics as code but no derivation, central differences give the Jacobian with error proportional to ε2\varepsilon^2:

J:,j≈f(q+εej)−f(q−εej)2ε.J_{:,j} \approx \frac{f(q + \varepsilon e_j) - f(q - \varepsilon e_j)}{2\varepsilon}.

With ε=10−6\varepsilon = 10^{-6} rad this costs 2n2n forward-kinematics calls and matches the analytic Jacobian to about 10−1010^{-10}. test_ik.py checks the match, to within 10−810^{-8}, for a 4-link chain. It is the easy way to get a Jacobian for an arm described by a chain of transforms from lesson 3.

Singularities

For a square Jacobian you can invert the velocity relation, q˙=J−1x˙\dot{q} = J^{-1}\dot{x}, as long as det⁡J≠0\det J \ne 0. For the 2-link arm,

det⁡J=l1l2sin⁡q2.\det J = l_1 l_2 \sin q_2 .

It is zero when the arm is straight (q2=0q_2 = 0) or folded back (q2=πq_2 = \pi). In those configurations the tip cannot move along the line through the base, whatever the joints do. Close to them, a modest tip velocity needs huge joint velocities. The table holds q1=0q_1 = 0 and asks for 0.1 m/s along x, the direction of link 1, with l1=0.30l_1 = 0.30 m and l2=0.20l_2 = 0.20 m:

Elbow angle q2q_2det⁡J\det J (m²)Joint speed ∥q˙∥\lVert\dot q\rVert (rad/s)
90°0.06000.50
30°0.03001.68
5°0.005210.3
1°0.001051.4

No hobby servo turns at 50 rad/s. A controller that inverts JJ blindly near a singularity either saturates the motors or makes the arm jump.

Manipulability and singular values

For non-square Jacobians (a redundant arm, or a 5-joint arm with a 6-row Jacobian) the determinant is undefined. Two measures work for any shape:

  • Manipulability w=det⁡(JJT)w = \sqrt{\det(J J^\mathsf{T})}. It equals ∣det⁡J∣|\det J| for a square JJ and is zero at a singularity. It is a convenient scalar for “how far from singular” and is often maximised with spare degrees of freedom.
  • Singular values σ1≥⋯≥σm\sigma_1 \ge \dots \ge \sigma_m from the SVD J=UΣVTJ = U \Sigma V^\mathsf{T}. Each σi\sigma_i is the tip speed along uiu_i that a unit joint velocity along viv_i produces. The smallest one says how weak the worst direction is, and σ1/σm\sigma_1 / \sigma_m is the condition number.

At the worked-example configuration the singular values are 0.429 and 0.134, so the arm is far from singular. At q2=1°q_2 = 1° they are 0.538 and 0.0019.

Singularities are not only at the workspace boundary. A spatial arm with a spherical wrist has a wrist singularity when two wrist axes line up, which can happen in the middle of the workspace.

Numerical IK as optimisation

For a general chain, write IK as a least-squares problem:

min⁡q 12∥e(q)∥2,e(q)=x∗−f(q).\min_q \ \tfrac{1}{2}\lVert e(q) \rVert^2, \qquad e(q) = x^* - f(q).

Linearise around the current guess, f(q+Δq)≈f(q)+JΔqf(q + \Delta q) \approx f(q) + J\Delta q, take a step, and repeat until ∥e∥\lVert e \rVert is below a tolerance. The methods differ only in how they compute Δq\Delta q from JJ and ee.

Jacobian transpose

Δq=α JTe.\Delta q = \alpha\, J^\mathsf{T} e .

JTeJ^\mathsf{T} e is the negative gradient of 12∥e∥2\tfrac{1}{2}\lVert e\rVert^2, so this is gradient descent. It needs no matrix inverse and never blows up, but convergence along each singular direction scales with ασi2\alpha\sigma_i^2, so it is slow when the singular values differ, and too large an α\alpha makes it oscillate.

Pseudo-inverse

Δq=J+e,J+=VΣ+UT,Σii+=1/σi.\Delta q = J^{+} e, \qquad J^{+} = V \Sigma^{+} U^\mathsf{T}, \quad \Sigma^{+}_{ii} = 1/\sigma_i .

This is the Gauss-Newton step. For a redundant arm it gives the smallest joint step that removes the linearised error. It converges in a few iterations when the arm is well away from singularities. Near one, 1/σm1/\sigma_m explodes.

Damped least squares

Damped least squares (DLS), also called the Levenberg-Marquardt step, adds a penalty on the step size:

min⁡Δq ∥e−JΔq∥2+λ2∥Δq∥2⟹Δq=JT(JJT+λ2I)−1e.\min_{\Delta q}\ \lVert e - J\Delta q\rVert^2 + \lambda^2 \lVert \Delta q \rVert^2 \quad\Longrightarrow\quad \Delta q = J^\mathsf{T}\left(J J^\mathsf{T} + \lambda^2 I\right)^{-1} e .

In terms of the SVD, DLS replaces 1/σi1/\sigma_i with

σiσi2+λ2.\frac{\sigma_i}{\sigma_i^2 + \lambda^2}.

For σi≫λ\sigma_i \gg \lambda this is almost 1/σi1/\sigma_i, so DLS behaves like the pseudo-inverse. For σi≪λ\sigma_i \ll \lambda it is about σi/λ2\sigma_i / \lambda^2, which goes to zero: DLS stops pushing in directions the arm cannot move. The largest gain, 1/(2λ)1/(2\lambda), occurs at σi=λ\sigma_i = \lambda, so a single step can never exceed ∥e∥/(2λ)\lVert e\rVert / (2\lambda).

The price is accuracy. With λ>0\lambda > 0 a step does not remove the full linearised error, so the solver needs more iterations, and in resolved-rate control the tip lags the commanded velocity. A common choice is λ\lambda a little below the smallest singular value you expect in normal operation, in the same units as JJ (metres per radian here). Some implementations raise λ\lambda only when σm\sigma_m or ww drops below a threshold.

The core of ik_solve in the download:

for k in range(max_iter):
    err = target - fk(q)
    if np.linalg.norm(err) < tol:
        break
    jmat = jac_fn(q)                       # analytic, or central differences
    if method == "transpose":
        dq = alpha * jmat.T @ err
    elif method == "pinv":
        dq = np.linalg.pinv(jmat) @ err
    else:                                  # "dls"
        dq = jmat.T @ np.linalg.solve(jmat @ jmat.T + lam**2 * np.eye(len(err)), err)
    q = np.clip(q + dq, q_min, q_max)      # joint limits

Use np.linalg.solve rather than forming an inverse. JJT+λ2IJ J^\mathsf{T} + \lambda^2 I is m×mm \times m (2×2 or 6×6), so the solve is cheap even for a long chain.

Comparing the three methods

The figure runs all three methods from the same start, q=(0.3,1.2)q = (0.3, 1.2) rad, on the 0.30 m / 0.20 m arm.

Two log-scale plots against iteration number. Left, position error for a reachable target: the pseudo-inverse reaches 1e-12 m in four iterations, damped least squares with lambda 0.05 reaches 1e-9 m in nine, and the Jacobian transpose with gain 10 falls in a straight line to about 1e-7 m after 80 iterations. Right, joint step size for an unreachable target: the pseudo-inverse jumps between 1 and 30 rad per step without settling, damped least squares with lambda 0.01 stays near 1 rad per step, and with lambda 0.05 the step falls steadily below 1e-9 rad within 17 iterations.
Convergence of three IK methods on a planar 2-link arm with 0.30 m and 0.20 m links. Left: position error for the reachable target (0.35, 0.20) m. Right: joint step size for the target (0.52, 0.10) m, which lies 0.03 m outside the 0.50 m reach.

On the reachable target the pseudo-inverse converges to below 1 µm in 3 iterations, DLS with λ=0.05\lambda = 0.05 in 6, and the transpose method in 70.

The unreachable target is where the methods separate. The best the arm can do is to stretch out and point at the target, which is exactly the singular configuration. The pseudo-inverse keeps trying to remove an error it cannot remove; its steps reach 30 rad and the joints spin. DLS with λ=0.05\lambda = 0.05 settles at the straight arm pointing at the target, 0.0295 m short, which is the closest reachable point. With λ=0.01\lambda = 0.01 the damping is too weak for this case and the steps stay near 1 rad. In a real arm you would also cap the step size (max_step in the download) and report that the target is out of reach.

Joint limits

Every real joint has limits, and the SO-101 servos store a minimum and maximum position limit in their own registers. Three ways to respect limits in numerical IK, in order of effort:

  1. Clip qq to the limits after each step, as ik_solve does. Simple and often enough. It can stall when the solution needs a joint to stay at its limit while others move, because the clipped joint keeps asking for the same step.
  2. Remove a joint from the problem once it sits at a limit (set its Jacobian column to zero) and solve with the rest.
  3. Add a cost that grows near the limits, or use a constrained solver such as a small quadratic program per step.

For a redundant arm there is a fourth option: use the spare degrees of freedom, through the null space of JJ, to move joints away from their limits without moving the tip.

Resolved-rate control

The same linearisation gives a velocity controller. To move the tip with velocity x˙∗\dot{x}^*, command

q˙=J#(q) x˙∗,qk+1=qk+q˙ Δt,\dot{q} = J^{\#}(q)\,\dot{x}^*, \qquad q_{k+1} = q_k + \dot{q}\,\Delta t ,

where J#J^{\#} is the pseudo-inverse or the DLS inverse. This is resolved-rate control: the Cartesian rate is resolved into joint rates at every control period. Drawing a straight line, inserting a peg or following a camera target all use it.

Two details make it work on hardware:

  • Close the loop on position. Integrating q˙\dot q drifts, because the linearisation is only exact for an infinitesimal step. Add a correction towards the desired tip position: x˙=x˙∗+Kp (x∗(t)−f(q))\dot{x} = \dot{x}^* + K_p\,(x^*(t) - f(q)).
  • Send positions to position-controlled servos. Bus servos such as the SO-101’s STS3215 run their own position loop, so the usual pattern is to compute qk+1q_{k+1} in Python and write it as the goal position at a fixed rate. Actuators, joint control and trajectories covers what happens inside the servo.

In the download, resolved_rate_step performs one step. The test moves the tip of the 2-link arm 0.1 m upwards at 0.1 m/s with a 2 ms period, and the tip ends 0.03 mm from the straight-line target without any position correction (the test allows 2 mm).

Download ik.py Download test_ik.py
python ik.py
python -m pytest -q
# 16 passed

The tests cover FK(IK(x)) = x for 200 random targets per elbow branch, the analytic Jacobian against finite differences, DLS with a finite-difference Jacobian on a 3-joint spatial arm (base yaw, shoulder pitch, elbow pitch), the bounded DLS step at an exact singularity, joint limits, and the pseudo-inverse blow-up on the unreachable target.

Exercise

Both IK solutions by hand

Use l1=0.30l_1 = 0.30 m and l2=0.20l_2 = 0.20 m.

  1. Is the target (0.10,0.40)(0.10, 0.40) m reachable?
  2. Compute q1q_1 and q2q_2 in degrees for both elbow solutions.
  3. Compute det⁡J\det J for the elbow-down solution. Is it closer to or further from a singularity than the worked example?
Show solution
  1. r=0.01+0.16=0.412r = \sqrt{0.01 + 0.16} = 0.412 m, which is between 0.10 m and 0.50 m. Reachable.
  2. cos⁡q2=(0.17−0.09−0.04)/0.12=0.3333\cos q_2 = (0.17 - 0.09 - 0.04) / 0.12 = 0.3333, so q2=±70.53°q_2 = \pm 70.53° and sin⁡q2=±0.9428\sin q_2 = \pm 0.9428. atan2⁡(0.40,0.10)=75.96°\operatorname{atan2}(0.40, 0.10) = 75.96° and atan2⁡(0.20⋅0.9428, 0.30+0.20⋅0.3333)=atan2⁡(0.1886,0.3667)=27.22°\operatorname{atan2}(0.20 \cdot 0.9428,\ 0.30 + 0.20 \cdot 0.3333) = \operatorname{atan2}(0.1886, 0.3667) = 27.22°. Elbow down: q1=75.964°−27.215°=48.75°q_1 = 75.964° - 27.215° = 48.75°, q2=70.53°q_2 = 70.53°. Elbow up: q1=75.964°+27.215°=103.18°q_1 = 75.964° + 27.215° = 103.18°, q2=−70.53°q_2 = -70.53°.
  3. det⁡J=0.30⋅0.20⋅sin⁡70.53°=0.0566\det J = 0.30 \cdot 0.20 \cdot \sin 70.53° = 0.0566 m². The worked example had 0.0578 m², so both are close to the maximum of 0.06 m² at q2=90°q_2 = 90° and far from singular.

Check: ik_2link(0.10, 0.40, 0.30, 0.20, "down") returns (48.75°, 70.53°) after conversion to degrees.

Exercise

Choose the damping factor

A resolved-rate controller uses DLS. The largest tip error it ever sees in one control period is 5 mm, and you want no single step to move a joint by more than 0.05 rad.

  1. Using the bound on the DLS gain, find the smallest λ\lambda that guarantees this.
  2. In normal operation the smallest singular value of your arm’s position Jacobian is about 0.10 m/rad. What fraction of the commanded motion along that direction does one DLS step achieve with your λ\lambda?
Show solution
  1. The step is at most ∥e∥/(2λ)\lVert e\rVert / (2\lambda). Require 0.005/(2λ)≤0.050.005 / (2\lambda) \le 0.05, so λ≥0.05\lambda \ge 0.05 m/rad.
  2. Along a direction with singular value σ\sigma, DLS achieves σ2/(σ2+λ2)\sigma^2 / (\sigma^2 + \lambda^2) of the requested motion. With σ=0.10\sigma = 0.10 and λ=0.05\lambda = 0.05: 0.01/(0.01+0.0025)=0.800.01 / (0.01 + 0.0025) = 0.80. One step removes 80 % of the error in that direction, and the next steps remove most of the rest. If that lag is too large, use a smaller λ\lambda away from singularities and raise it only when σm\sigma_m falls, together with a step cap.

Summary

  • The planar 2-link arm has a closed-form IK: the law of cosines gives q2q_2 (two signs for elbow up and down), and q1q_1 follows from two atan2 calls. The workspace is the annulus ∣l1−l2∣≤r≤l1+l2|l_1 - l_2| \le r \le l_1 + l_2.
  • The Jacobian maps joint velocities to tip velocity. Each column is the tip velocity from one joint; build it analytically or with central differences.
  • Singularities are configurations where the Jacobian loses rank. det⁡J\det J, the manipulability det⁡(JJT)\sqrt{\det(J J^\mathsf{T})} and the smallest singular value all measure how close you are, and joint speeds grow as 1/σm1/\sigma_m near them.
  • Numerical IK minimises the squared tip error. The transpose method is gradient descent, the pseudo-inverse is Gauss-Newton, and damped least squares Δq=JT(JJT+λ2I)−1e\Delta q = J^\mathsf{T}(J J^\mathsf{T} + \lambda^2 I)^{-1} e bounds every step by ∥e∥/(2λ)\lVert e\rVert / (2\lambda) at the cost of slower convergence.
  • Resolved-rate control applies the same inverse to velocities every control period, with a position correction and, on servo arms, goal positions sent at a fixed rate.

Check your understanding

Pick an answer for each question, then check. Answers stay hidden until you submit.

1. A planar 2-link arm has l1 = 0.30 m and l2 = 0.20 m. Which target can it reach?
2. For the planar 2-link arm, det J = l1 l2 sin(q2). What does det J = 0 mean physically?
3. In damped least squares, the gain applied along a direction with singular value sigma is sigma / (sigma^2 + lambda^2). What happens as sigma goes to zero?
4. You increase the DLS damping factor lambda from 0.01 to 0.1. What do you expect?
5. Why does the Jacobian-transpose method need many more iterations than the pseudo-inverse on a well-conditioned problem?

Further reading

Found a mistake or something unclear?Report a correction.