Exercises — Implementing root-finding from scratch — Newton-Raphson, bisection
5.4.25 · D4· Coding › Scientific Computing (Python) › Implementing root-finding from scratch — Newton-Raphson, bis
Level 1 — Recognition
Exercise 1.1
Tumhe diya gaya hai aur bisection se ek root dhundhna hai. Koi tumhe teen candidate intervals deta hai: , , . Kaun sa valid bracket hai, aur kaun si method requirement yeh decide karti hai?
Recall Solution
Humein kya chahiye: ek bracket tabhi valid hai jab — function sign change karta hai, toh Intermediate Value Theorem ke hisaab se ek continuous curve ko andar zero cross karna hi padega.
Endpoints evaluate karo:
- , → product . Valid nahi (dono negative — curve yahan zero tak dip nahi bhi kar sakti).
- , → product . Valid ✓ (negative → positive, ek guaranteed crossing).
- , → product . Valid nahi.
Answer: sirf ek root bracket karta hai.
Neeche di gayi figure curve ko is valid bracket ke saath dikhati hai, iske pehle bisection midpoint (plum color mein), aur Exercise 2.2 ka Newton tangent (orange) — abhi ek baar dekho ki dono methods ek hi crossing ko kaise alag tarike se approach karte hain.

Dekho ki plum midpoint par pehle se zero ke kaafi kareeb hai (kyunki curve yahan almost seedhi hai), jabki orange tangent ka x-intercept se ek hi jump mein true root ke almost upar aa jaata hai.
Exercise 1.2
Har situation ko better first choice se match karo — bisection ya Newton-Raphson:
- (a) Tumhare paas hai par ka formula nahi, aur ek known sign change hai.
- (b) Tumhare paas , hai, aur starting guess root ke bahut kareeb hai.
- (c) almost zero hai theek wahan jahan se tum start karoge.
Recall Solution
- (a) Bisection. Newton ko derivative chahiye; bisection ko sirf aur ek sign change chahiye.
- (b) Newton. Close start + derivative = quadratic convergence, kam steps.
- (c) Bisection. Tiny Newton step ko explode kara deta hai — tangent almost flat hai aur iska x-intercept bahut door ud jaata hai.
Level 2 — Application
Exercise 2.1
par ke upar do bisection steps karo. Har step ke baad bracket report karo aur woh midpoint jo tum return karte agar tum rok dete.
Recall Solution
Store karo (negative), (positive).
Step 1: midpoint . Compute karo (negative). Stored se compare karo: → left side par same sign, toh crossing right half mein hai. Naya bracket: , aur ab .
Step 2: midpoint . Compute karo (positive). → left par sign change, left half rakho. Naya bracket: .
Agar tum abhi rokte to midpoint return karte. (True root hai.)
Exercise 2.2
Usi par do Newton steps karo, ke saath, se start karke.
Recall Solution
Update rule: .
Step 1 (): , .
Step 2 (): ; .
Do Newton steps ne humein tak pahuncha diya (true root ); do bisection steps sirf tak pahunche. Newton fast aage nikal jaata hai jab guess kareeb ho.
Level 3 — Analysis
Exercise 3.1
par Bisection (width ). Kitne steps guarantee karte hain ki returned midpoint true root se ke andar hai? Pehle geometrically error bound derive karo, phir step count ke liye solve karo.
Recall Solution
Bound derive karna (geometric "kyun"): Interval width se shuru karo. Har bisection step live interval ko exactly aadha kar deta hai, kyunki hum midpoint par split karte hain aur ek side rakhte hain. Toh steps ke baad width hai: Ab — us final interval ke andar true root kahan hai? Hum surviving interval ka midpoint return karte hain. Root kahi bhi interval mein ho sakta hai, aur midpoint dead-centre baitha hai, toh root midpoint se sabse zyada interval width ka aadha ho sakta hai (root ek end par, midpoint beech mein). Isliye error mein extra factor of two hai: koi magic constant nahi hai: halvings count karta hai, aur extra hai "midpoint half-width se zyada door nahi" geometry.
Step count ke liye solve karna. Humein chahiye: lo: . Toh , matlab steps kaafi hain. (Har step ek bit buy karta hai; .)
Exercise 3.2
par Newton se start karke error hai. Taylor Series se quadratic-convergence estimate derive karo, phir predict karo aur actual next error se compare karo.
Recall Solution
Taylor's theorem se derive karna. Maano error hai, jahan true root hai (). aur ko ke aaspaas Taylor-expand karo, tak terms rakhte hue: ( term vanish ho jaata hai kyunki root hai), aur Agla Newton error hai . Dono expansions substitute karo: Numerator se aur denominator se factor out karo: Ab chhote ke liye use karo (denominator ka geometric-series approximation). aur ke saath: Aur . Toh constant hai: Isliye ka exactly wahi form hai — yeh leading curvature term aur slope ka ratio hai, seedha Taylor remainder se nikla hua.
Yahan apply karna. ke liye: toh ; toh . Predicted .
Actual: , toh .
Predicted vs actual — same order, ~ apart (difference hai woh higher-order terms jo humne expansion mein drop kiye). Prediction squaring behaviour confirm karta hai: se ho gaya, roughly scaled — accuracy ke digits double ho gaye.
Level 4 — Synthesis
Exercise 4.1
Ek safeguarded Newton step function likho: diye gaye current bracket ke saath sign change aur current guess ke saath, ek Newton step lo; agar woh ke bahar land kare (ya zero ho), toh bisection midpoint par fall back karo. Har guard explain karo. (Pseudocode + ek hand trace.)
Recall Solution
def safe_step(f, df, a, b, x, fa):
dfx = df(x)
if dfx != 0:
xn = x - f(x) / dfx # try Newton
if a < xn < b: # accept only if it stays inside the bracket
x_new = xn
else:
x_new = (a + b) / 2 # Newton escaped -> bisect
else:
x_new = (a + b) / 2 # flat tangent -> bisect
# shrink the bracket using the new point's sign
fx = f(x_new)
if fa * fx < 0:
b = x_new # sign change on the left half
else:
a, fa = x_new, fx # sign change on the right half
return a, b, x_new, faHar guard kyun hai:
dfx != 0: flat tangent infinite/undefined step deta hai — Newton ka exact failure mode. Bisection par fall back karo, jo kabhi slope se divide nahi karta.a < xn < b: agar Newton ka tangent trapped region ke bahar point kare, toh root wahan ho nahi sakta — guess ek blind midpoint se bhi worse hai. Reject karo.- Sign test se
a/bupdate karna valid bracket hamesha maintain karta hai, toh hum bisection ki guarantee inherit karte hain aur Newton ki speed bhi enjoy karte hain jab woh behave kare.
Hand trace par, , start , :
- , Newton , jo ke andar hai → accept. ; → right end shrink karo: bracket ho jaata hai.
Yahi philosophy hai scipy.optimize.brentq ke peeche: bracket rakho, andar fast interpolation use karo, jab fast step misbehave kare toh bisect karo.
Exercise 4.2
Parent note Secant method ko Newton ka derivative-free cousin batata hai. Iska update Newton ke update se derive karo ko do most recent points use karke finite difference se replace karke. Batao ki Newton ke mukable iska kya cost aur kya gain hai — aur woh edge case identify karo jo update break kar sakta hai, guard ke saath.
Recall Solution
Newton hai . Jab ka formula na ho, slope ko last do points ke through line se approximate karo (ek finite difference, derivative ki definition se closely related): Substitute karo: Gain: koi derivative nahi chahiye, aur sirf ek new -evaluation per step (Newton ko aur dono chahiye). Cost: convergence order se golden ratio tak drop ho jaata hai — phir bhi superlinear, bisection se faster, true Newton se slower. Yeh Newton ki fragility bhi inherit karta hai (koi bracket guarantee nahi).
Edge case — vanishing denominator. Formula se divide karta hai. Agar do most recent function values equal (ya nearly so) hon, toh yeh denominator zero (ya tiny) hai aur step blow up karta hai ya division error ke saath crash karta hai. Geometrically yeh ek horizontal secant line hai: ek flat line kabhi x-axis cross nahi karti, toh "secant zero kahan hit karta hai?" ka koi finite answer nahi — Newton ke flat-tangent failure ka exact analogue. Yeh ek local extremum ke kareeb hota hai, ya jab do iterates accidentally same height par land kar jaate hain.
Guard:
def secant_step(f, x_prev, x_cur, f_prev, f_cur, a, b):
denom = f_cur - f_prev
if denom == 0: # horizontal secant -> no intercept
return (a + b) / 2 # fall back to a bracketed bisection
return x_cur - f_cur * (x_cur - x_prev) / denomMastery level par Exercise 4.1 ka wahi lesson apply hota hai: raw secant fragile hai, toh production code ise safeguard karta hai — denominator check karo, aur bracket rakho jab secant point escape kare ya denominator collapse kare. Yahi denominator guard plus bracket fallback exactly wajah hai ki real solvers jaise scipy.optimize.brentq kabhi degenerate slope se divide nahi karte.
Level 5 — Mastery
Exercise 5.1 (Newton's runaway)
ke liye (cube root, with root ), algebraically dikhao ki Newton kisi bhi nonzero start se diverge karta hai, aur geometrically explain karo kyun. Phir batao ki tum instead kaun si method use karte.
Recall Solution
Yahan hai toh . Newton step: Toh har iteration deta hai: guess magnitude mein double ho jaata hai aur sign flip karta hai har step par. se: — woh se hamesha door bhaag jaata hai.
Geometry: ka root par infinitely steep tangent hai (vertical inflection). se door tangent itna shallow hai ki iska x-intercept jahan tum shuru hue wahan se zyada door land karta hai. Neeche di gayi figure yeh runaway sketch karti hai — teen dashed tangents (orange, plum, teal) follow karo: har ek ka x-intercept (triangle marker) us point se zyada door baitha hai jahan se woh aaya.

Figure ko left-to-right padho: se par intercept milta hai, jiske tangent se par intercept milta hai, aur aise hi — markers dono directions mein baahir jaate hain, kabhi central star ki taraf nahi.
Fix: Bisection use karo. Kisi bhi bracket jaise (signs aur ) ke saath, yeh inexorably ki taraf march karta hai. Yahi parent note ki headline warning hai: bisection guaranteed hai, Newton nahi.
Exercise 5.2 (Degenerate bracket)
Ek caller bisection(f, a, b) run karta hai jahan bad luck se exactly ho. Parent ke code ko trace karo, aur explain karo ki endpoint check sign-product test se pehle kyun aana chahiye.
Recall Solution
Parent code yaad karo:
if fa == 0:
return a
...
if fa * fb > 0:
raise ValueError(...) ke saath: pehla guard fa == 0 fire karta hai aur a immediately return karta hai — correct, yeh exact root hai.
Order kyun matter karta hai: agar humne pehle fa * fb > 0 check kiya hota, note karo , jo na hai na . Yeh strict bracket test fail karta hai (> 0 False hai, toh koi error raise nahi hota) lekin loop ka termination (b-a)/2 < tol true root ka return kabhi trigger nahi kar sakta, aur isse bhi bura, sign-update logic genuine strict sign change assume karta hai. Ek zero endpoint us assumption ko break karta hai. Endpoints pehle check karna poore degenerate case ko cleanly sidestep karta hai. Yeh exactly parent note mein second steel-man hai.
Exercise 5.3 (Floating-point stopping)
Newton on reaches with while the step . Tumhara tolerance hai. Kya loop rokna chahiye? Floating point arithmetic humein tak tolerance push karne ke baare mein kya batata hai?
Recall Solution
Step bada hai se, toh abs(step) < tol test False hai → loop ek aur iteration continue karta hai. (Agla step ke baad yeh almost certainly tol se neeche aa jaayega aur ruk jaayega.)
push karne par: reliably meet karna impossible. Double-precision floats lagbhag – significant decimal digits carry karte hain; ke kareeb representable numbers ke beech spacing (machine epsilon scale, value ka times) roughly hai. Tum us gap se chhota step resolve nahi kar sakte — loop maxit tak spin karta rahega bina kabhi satisfy kiye. Tolerances machine epsilon ke kuch times ya usse upar set karo; number system se zyada precision maangna ek guaranteed non-termination bug hai.