The fine print on a beautiful formula
The previous guide left you dazzled: Newton's method doubles your correct digits every step near a simple root, the quadratic convergence that makes it the workhorse of numerical computing. But that promise came wrapped in three quiet conditions that are easy to forget the moment they hold: the root must be simple (f'(root) is nonzero), you must start close enough, and f must be smooth there. Newton is a local marvel. Pull any one of those conditions and the marvel can curdle into divergence, an endless cycle, or a confident march to the wrong answer.
It helps to remember what Newton actually does geometrically. At your current guess x_n it draws the tangent line to f and jumps to where that line crosses zero: x_{n+1} = x_n - f(x_n)/f'(x_n). When the tangent points roughly at the root, the jump is brilliant. But a tangent is a local approximation — it knows only the slope at one point, nothing about what the function does elsewhere. The moment that local picture disagrees with the global shape of f, the tangent can fling you somewhere absurd. Every failure mode below is just a story about a tangent that lied.
The four ways Newton lies to you
The textbook catalogue of Newton's failure modes is worth meeting concretely, because each one is something you will eventually trip over. Flat-spot overshoot: if f'(x_n) is tiny, you divide by a near-zero slope and the next iterate is hurled far away — a nearly horizontal tangent crosses zero a continent from where you stood. Cycling: for some functions Newton bounces between two points forever, A -> B -> A -> B; the classic toy is f(x) = x^3 - 2x + 2 started at x_0 = 0, which oscillates between 0 and 1 and never converges at all.
Wrong-root capture: Newton has no allegiance to the root you care about. If your start sits in the wrong basin of attraction it will dutifully converge — fast, even — to some other root entirely, or shoot off toward an asymptote. Multiple roots: when the root is a multiple root, so f'(root) is also zero, the tangent flattens out right where you most need it. Newton still converges, but the famous quadratic speed collapses to merely linear, crawling along while halving the distance each step instead of squaring it. The cruel irony: the case where you most want speed is exactly the one that takes it away.
The secant method: Newton without the derivative
Newton has one more cost we have ignored: it demands f'(x), an actual derivative you must derive by hand or compute. For a messy f — a long expression, or a black-box simulation that only returns numbers — that derivative may be painful or simply unavailable. The secant method asks a wonderfully lazy question: what if I just estimate the slope from two points I already have? Replace the true tangent slope f'(x_n) with the slope of the secant line through the last two iterates, (f(x_n) - f(x_{n-1}))/(x_n - x_{n-1}). That single substitution turns Newton into a method that never needs a derivative at all.
Newton (needs the derivative f'):
x_{n+1} = x_n - f(x_n) / f'(x_n)
Secant (estimates the slope from two past points):
x_n - x_{n-1}
x_{n+1} = x_n - f(x_n) * -----------------------
f(x_n) - f(x_{n-1})
needs two starting guesses x_0, x_1
keeps only the two most recent points; one new f-evaluation per stepGeometrically the picture is gentle and intuitive. Instead of drawing the tangent at one point, you draw the straight line through two points on the curve and jump to where that line hits zero. As the iterates close in, those two points get nearer and nearer together, the secant line snuggles up against the true tangent, and the method starts behaving almost exactly like Newton — but you paid no derivative for it. That word almost is the whole story of how fast it goes.
Slightly slower per step, often faster overall
Because the secant uses an approximate slope, its order of convergence is not the 2 of Newton but the golden ratio, about 1.618 — superlinear, gloriously better than the linear 1 of bisection, yet a notch below quadratic. So per step it makes a little less progress than Newton. But here is the twist that often flips the verdict: each Newton step costs two function calls (one for f, one for f'), while each secant step costs only one (it reuses last step's f value). Measured per function evaluation — the honest currency when f is expensive — the secant's effective order is about 1.618 against Newton's effective 2^(1/2) which is about 1.414. For a costly f, the lazy method can finish first.
The secant inherits Newton's gifts and most of its sins. It is still only locally convergent — bad starts can still send it diverging or cycling — and like Newton it can hand you a point where f is small without ever guaranteeing you sit in a true bracket around the root. One extra hazard is its own: when x_n and x_{n-1} drift close, the denominator f(x_n) - f(x_{n-1}) becomes a difference of two nearly equal numbers, the textbook setup for catastrophic cancellation in floating point. The slope estimate then goes noisy exactly as you approach the root, so a sane stopping rule is essential rather than running the formula one step too far.
Bracketing the wild: regula falsi and Brent
Notice the trade we keep circling. Bisection is slow but guaranteed: it keeps a bracket [a, b] with f changing sign across it, so a root is always trapped inside and the interval can only shrink. Newton and secant are fast but unguarded: nothing stops them from leaping clean out of the region. The natural dream is a hybrid that keeps a bracket like bisection yet steps fast like secant. The first attempt is regula falsi (false position): use the secant formula, but always between the two ends of a sign-change bracket, so the root stays trapped. It never diverges — but it can stall, lazily holding one endpoint fixed while the other inches in, decaying to linear speed on lopsided functions.
The grown-up answer, and the default you will meet inside real software (MATLAB's fzero, SciPy's brentq), is Brent's method. It is a careful referee that keeps a guaranteed sign-change bracket at all times, but on each step it tries the fast move — inverse quadratic interpolation through three points, or a secant step — and accepts it only if the result lands safely inside the bracket and is actually shrinking it. If the fast step misbehaves, Brent quietly falls back to a guaranteed bisection step. You get bisection's ironclad convergence guarantee with secant-like speed whenever the function is well-behaved. That is the engineering ideal: never slower than the safe method, usually as fast as the bold one.