Module 11 · Lesson 11.2

Newton–Raphson and the residual

Guess, measure the out-of-balance, divide by the tangent, correct, repeat — and what each of those four words is doing.

Why this matters

Nonlinear solvers are usually presented as a formula and an animation. Both miss the thing worth understanding, which is that the method is a measurement followed by a correction, and that the quantity being measured — the residual — is a physical force with a physical meaning.

Once the residual is clear, everything else follows: why convergence is a choice, why the tolerance matters, why the method sometimes diverges, and why the modified version is worth using despite taking longer.

By the end of this lesson you should be able to

Define the residual and say what it physically is
Follow one Newton–Raphson iteration through its four steps
Explain quadratic convergence and when it does not apply
Say when the modified method is the better choice
Explain why load increments help even though the final answer is the same

The residual

Apply a load. Guess a displacement. Ask the structure what force it develops at that displacement — that is the internal force, and for a nonlinear structure it is not proportional to the displacement.

The difference between what you applied and what the structure is carrying is the residual:

R = F_applied − F_internal

It is a real force, in kilonewtons. It is the load the structure has not taken up yet. When it reaches zero, the structure is in equilibrium at that displacement, and the analysis is finished.

It never reaches zero exactly. It reaches small enough, and how small is a tolerance you set. That is the sense in which convergence is a decision rather than an event.

One iteration

1.Measure the residual at the current displacement.
2.Form the tangent — the slope of the force–displacement curve at that point, not the initial slope.
3.Correct: du = R / k_tangent. This is a linear extrapolation, which is why it is only approximately right.
4.Move and repeat.

Step 3 is the only approximation in the method, and it is what makes the process iterative rather than direct. The tangent is the structure's current stiffness, so the correction would be exact if the structure were linear from here on. It is not, so you overshoot or undershoot, and go round again.

Quadratic convergence, and where it stops

Near the answer, Newton–Raphson roughly squares the error each iteration. A residual of 10⁻² becomes 10⁻⁴, then 10⁻⁸. Three or four iterations is typical.

That behaviour depends on the tangent being a good local predictor. It fails when:

the tangent is nearly zero, so the correction is enormous;
the tangent is negative, so the correction goes the wrong way;
the starting guess is far from the answer, so the local slope says nothing useful about the destination.

All three are structural conditions, not solver settings. A structure approaching a limit point has a tangent tending to zero — and the solver's difficulty is telling you something about the structure.

The modified method

Use the initial tangent for every iteration instead of re-forming it each time.

That sounds worse and often is not. Forming and factorising a tangent stiffness matrix for a large model is expensive; doing it once and reusing it can be cheaper overall even though it takes three times as many iterations. The convergence becomes linear rather than quadratic — the error falls by a constant factor rather than squaring — but each step costs a fraction as much.

Full Newton: fewer, more expensive iterations. Modified Newton: more, cheaper ones. Which wins depends on the cost of factorising your particular matrix, and the honest answer is that you find out by trying.

Why increment the load

Applying the whole load in one go and applying it in twenty steps reach the same answer for a well-behaved structure. So why increment?

Because each increment starts from the converged answer of the last one, so the guess is close and the tangent is a good predictor. The iteration converges in two or three passes instead of struggling. Increments buy reliability, not accuracy.

And where the path has a limit point, no number of increments saves load control. That is the next lesson.

Newton–Raphson iteration

R_{i} = F_{applied} - F_{internal} (u_{i}), Δ u_{i} = \frac{R _{i}}{k _{T} ( u _{i} )}, u_{i + 1} = u_{i} + Δ u_{i}

What it calculates: The next estimate of the displacement that balances the applied load

R: Residual — the out-of-balance force (kN)
F_internal: Force the structure develops at the current displacement (kN)
k_T: Tangent stiffness at the current displacement (kN/m)
Δu: Correction applied this iteration (m)

This assumes

The tangent is a usable local predictor — false near a limit point
The tangent is non-zero; a zero tangent makes the correction infinite
Convergence is declared when |R| falls below a tolerance you chose

In plain terms: Every term is a physical quantity. The residual is a force you could measure; the tangent is a stiffness you could measure; the correction is the displacement that force would cause at that stiffness. Nothing in the method is abstract, which is why watching one iteration is worth more than reading three derivations of it.

Try it

Newton–Raphson explorer

Three nonlinear springs. Watch the residual, the tangent and the correction at every iteration.

System

Applied loadkN

Method

Modified holds the first tangent throughout: more iterations, each much cheaper.

Tension stiffening. The tangent only ever increases, so Newton–Raphson converges from any starting point and load control never fails.

Iteration trace. R is the residual; k_T the tangent used; Δu the correction.
#	u (m)	R (kN)	k_T (kN/m)	Δu (m)
1	0.0000	500.00	100.0	5.0000
2	5.0000	-5000.00	3100.0	-1.6129
3	3.3871	-1393.04	1476.7	-0.9434
4	2.4437	-328.13	816.6	-0.4018
5	2.0419	-44.75	600.3	-0.0745
6	1.9674	-1.34	564.5	-0.0024
7	1.9650	-0.00	563.4	-0.0000

Result: converged
Iterations: 7
Displacement: 1.9650 m
Check: internal force: 500.00 kN

Things worth trying

Hardening at 500 kN: the first correction is the LINEAR answer, and it overshoots by nearly three times. That is what nonlinearity means in practice.
Switch to modified Newton and every row shows the same tangent. It takes many more iterations and each is far cheaper.
Yielding at 200 kN: above the plateau of 150 kN there is no displacement that balances the load, and no number of iterations finds one.
Snap-through at 25 kN: above the limit point of 24.1 kN, load control either fails or lands on the far branch — a completely different state of the structure.

What this shows: The residual is a force in kilonewtons — the load the structure is not yet carrying — and convergence is a tolerance you chose.

Worked example

Three iterations on a hardening spring

Given

A cable-like spring: F = 100u + 40u³, so k_T = 100 + 120u²
Applied load 500 kN
Starting from u = 0
Tolerance on the residual: 10⁻⁶ kN

Find

The first three iterations, and how the residual falls

Predict first

A nonlinear analysis is taking 40 iterations per load step instead of the usual three or four, but it does converge. What is the most likely explanation?

Practice

A nonlinear spring carries F = 150(1 − e^(−u/1.2)). At u = 0 the applied load is 100 kN. What is the residual at the first iteration, in kN?

Practice

The same spring has tangent stiffness k_T = 125e^(−u/1.2). At u = 0, what correction does the first Newton–Raphson iteration apply under a 100 kN load, in metres?

Check yourself

What is the residual in a Newton–Raphson iteration?

Check yourself

A nonlinear analysis converges in every increment and reports a final answer. What has that established?

Summary

The residual is the load the structure is not yet carrying, in kilonewtons
Convergence is a tolerance you chose, not an event that happens
The correction is R divided by the current tangent — the method's only approximation
Near the answer the error roughly squares each pass; far from it, nothing is guaranteed
The modified method trades more iterations for cheaper ones
Increments buy reliability, not accuracy — and cannot pass a limit point

Progress is kept in this browser only.

This is educational material. It uses simplified examples to teach principles, and must not be relied on for real design or safety-critical decisions. Module overview and checkpoint