Question bank — Floating point gotchas — catastrophic cancellation, associativity failure

True. Machine $\text{fl}(a+b)$ compute karta hai — exact sum ko round karo — aur $a+b=b+a$ rounding se pehle hota hai, isliye dono orders ek hi dot par snap hoti hain.

False. Har + apne intermediate result par $\text{fl}$ apply karta hai us partial sum ki magnitude par set spacing ke saath, isliye alag grouping alag jagah round karti hai — e.g. $1+10^{16}-10^{16}$ ek taraf $0$ deta hai aur doosri taraf $1$.

False. Sterbenz's lemma ke anusaar near-equal values ka subtraction bilkul exactly compute hota hai (koi rounding hi nahi); bada relative error pehle se hi un dono stored operands mein baka hua tha — subtraction sirf use reveal karta hai.

False. Yeh $1.0$ aur next double ke beech ki gap hai (${\epsilon }_{\text{mach}}=2^{-52}$). Sabse chhota positive subnormal double kaafi zyada chhota hota hai ($\sim 5\times 10^{-324}$); ye bilkul alag quantities hain.

False. $u=\frac{1}{2}{\epsilon }_{\text{mach}}$. Machine epsilon $1$ ke paas adjacent doubles ke beech ka poora step hai; round-to-nearest sirf aadhe step se chuk sakta hai, isliye error bound $u$ use karta hai, ${\epsilon }_{\text{mach}}$ nahi.

False. Yeh round half to even use karta hai: woh neighbour choose karta hai jiska $0$ final mantissa bit ho, taaki ties lambi computations ko systematically upar bias na karein.

False. Algebraic identity rounding se survive nahi karti: ek mathematically exact formula (e.g. $\frac{1-\cos x}{x^2}$) Catastrophic cancellation se saari accuracy kho sakta hai, chahe symbols perfect hon.

False. $0.1,0.2,0.3$ mein se koi bhi binary mein exactly representable nahi hai; $\text{fl}(0.1)+\text{fl}(0.2)$, $\text{fl}(0.3)$ se $\sim 10^{-17}$ se alag hota hai, isliye == False return karta hai.

False. Higher precision sirf kuch digits ke liye disaster ko delay karta hai; agar expression ill-conditioned hai, amplification factor $\frac{|a|+|b|}{|a-b|}$ phir bhi blow up karta hai. Tumhe type widen nahi karna, balki reformulate karna hoga.

False. Bound relative hai: $|\text{fl}(x)-x|\le u|x|$ (jahan $u=\frac{1}{2}{\epsilon }_{\text{mach}}$), isliye absolute error number ki magnitude ke saath badhti hai. Yahi relativity exactly woh reason hai kyun big-minus-big dangerous hai.

False. Smallest normal aur true zero ke beech subnormals hote hain (gradual underflow): leading mantissa bit $0$ ho jaata hai, precision ki jagah reach milti hai taaki tiny results smoothly degrade hon instead of $0$ par snap karne ke. Sirf smallest subnormal se neeche hi tum truly $0$ par underflow karte ho.

False. Yeh total error ko $\sim u$ tak reduce karta hai (roughly $n$ se independent) lost low-order bits ko carry karke, lekin har individual add phir bhi $\text{fl}$ apply karta hai — yeh compensate karta hai, eliminate nahi.

False. Yeh usually worst order hai: small terms bade running sum ke neeche absorb ho jaate hain. Smallest magnitudes pehle add karna (ya Kahan compensated summation use karna) safer hai.

$\overline{x^2}-{\bar{x}}^2$ se compute ki gayi variance cancellation se ek tiny negative ya tiny positive number par round ho sakti hai, isliye == 0.0 dono true zeros ko miss karta hai aur mis-fire bhi karta hai. variance <= tol test karo jahan tol ek absolute threshold ho jo data ke anusaar scale ho, e.g. tol = 1e-12 * mean_x**2 (numbers ki size ke relative, kyunki variance ki units value² hain).

Bade $x$ ke liye dono roots nearly equal hain, isliye unka difference catastrophic cancellation suffer karta hai. Ise $\frac{1}{\sqrt{x+1}+\sqrt{x}}$ ke roop mein rewrite karo — yahan dono roots add hoti hain; kyunki dono positive hain isliye denominator mein near-total cancellation nahi hoti, aur relative error $\sim u$ rehta hai.

$b<0$ ke saath, $-b$ aur $\sqrt{\dots }$ dono $\approx 200000$ hain aur nearly equal hain, isliye subtraction catastrophic hai. Same-sign root $x_{+}$ pehle compute karo, phir $x_{-}=c/(a{x}_{+})$ lo — Quadratic formula numerical issues dekho.

$f(x+h)-f(x)$ phir near-equals subtract karta hai, isliye cancellation dominate karta hai aur accuracy collapse ho jaati hai. Ek optimal $h\approx \sqrt{u}\approx 10^{-8}$ hota hai jo truncation vs round-off error ko balance karta hai.

Naive summation har small price ko bade running total mein absorb hone deta hai, isliye cents silently gayab ho jaate hain (absorption). Small-to-large sum karo, ya Kahan use karo; Round-off error propagation dekho.

$\text{fl}(1+x)$ tiny x ko round kar ke hataa deta hai (absorption), isliye uska log $0$ ho jaata hai $\approx x$ ki jagah. math.log1p(x) use karo, jo $1$ se addition avoid karne ke liye built hai.

Floating error rarely bilkul $0$ tak pahunchti hai; yeh round-off level ke paas hamesha wobble karti rehti hai, isliye loop kabhi nahi rukti. while error > tol: use karo, tol ko atol + rtol*scale choose karo (ek absolute floor plus ek relative part) rather than ek akele magic number ki jagah.

Alternating terms enormous grow karte hain phir ek tiny result tak cancel ho jaate hain — sum mein catastrophic cancellation. $e^x$ compute karo (all-positive terms) aur uska reciprocal lo — lekin sirf moderate $x$ ke liye: bade $x$ ke liye, $e^x$ inf par overflow karta hai aur $1/\text{inf}=0$ answer ko swallow kar leta hai, isliye sidhe math.exp(-x) (ya range-reduction) use karo.

Dono operands absolute error $\sim u|a|$ carry karte hain; true difference tiny hai, isliye un fixed absolute errors ko near-zero result se divide karna relative error, $\frac{|a|+|b|}{|a-b|}u$, ko explode karta hai. Koi naye bits lose nahi hote — chhota answer sirf purani error ko chhupa nahi sakta.

$a,b>0$ ke saath $a+b$ ka result $\approx 2a$ hai jo inputs jitna bada hai, isliye fixed absolute errors $\sim u|a|$ us relative mein chhoti rehti hain — amplifier $\frac{|a|+|b|}{|a+b|}\approx 1$. Subtraction result ko $0$ ke paas shrink kar deti hai jabki errors wahi rehti hain, isliye wahi errors answer ke relative huge ho jaati hain.

$x=a\cdot b$ mein relative errors simply add ho jaate hain (${\delta }_a+{\delta }_b\lesssim 2u$) aur kisi bhi near-zero cheez se divide kabhi nahi hote, isliye amplification factor $\sim 1$ rehta hai. Subtraction near-zero difference se divide kar sakti hai, factor ko unbounded bana deta hai.

$10^{16}$ magnitude ke paas representable doubles ke beech spacing $\approx 2$ hai, jo $1$ se badi hai; added $1$ ek gap se neeche padta hai, isliye $\text{fl}(1+10^{16})$ wapas $10^{16}$ par snap ho jaata hai — yeh absorb ho jaata hai.

Chhote values pehle ek saath accumulate hokar ek aise magnitude mein grow kar jaate hain jo bade terms ke comparable ho, isliye jab finally ek bade number se milte hain toh woh representable bits occupy karte hain instead of uski gap ke neeche girne ke — unhe kam absorb kiya jaata hai.

(t - s) woh part hai y ka jo rounding ke baad actually sum mein landa; poora y subtract karna negated dropped part ko isolate karta hai, jo phir next iteration mein feed hota hai taaki koi bits permanently lost na hon.

Hamesha-upar ek tiny upward bias add kar deta har baar jab tie hoti, aur ek lambe sum mein woh biases systematic drift mein accumulate ho jaate. Round-to-even ties ko evenly split karta hai taaki woh average par cancel hon, $|\delta |\le u$ bound ko unbiased rakhte hue.

Dono exact arithmetic mein equal hain lekin alag conditioning hai: ek near-equals ki subtraction ke aas-paas computation route kar sakti hai jabki doosri seedha usme walk kar jaati hai. Reformulating error behaviour change karta hai, math nahi — Numerical stability and conditioning dekho.

Floating point numbers ko logarithmically space karta hai — gap magnitude ke saath scale hoti hai — isliye ek bound jo $|x|$ ke saath scale ho (relative) accuracy ka honest, magnitude-independent description hai.

Tolerance abs(x-y) <= atol + rtol*max(|x|,|y|) float error ki relative nature ko respect karta hai aur magnitude ke saath adapt karta hai, jabki fixed-digit rounding ya toh large numbers ko over-reject karta hai ya chhote numbers ko over-accept karta hai.

Yeh $\frac{2|a|}{0}$ hai — formally infinite — lekin agar $a$ aur $b$ same stored value hain, toh result exactly $0$ hai zero relative error ke saath. Blow-up tab apply hota hai jab woh nearly lekin identically equal nahi hote.

Ek root exactly $0$ hai; phir $x_{-}=0/(a{x}_{+})=0$ correctly hai, lekin tumhe $x_{+}=0$ se bhi guard karna hoga (dono roots zero, yaani $b=c=0$) division by zero avoid karne ke liye.

$x$ around $10^{-8}$ ke liye, $\cos x$ exactly $1$ par round ho jaata hai, isliye $1-\cos x=0$ aur ratio $0$ ho jaata hai — true limit $\frac{1}{2}$ ke muqable mein total loss. Identity $1-\cos x=2{\sin }^2(x/2)$ ise restore karti hai.

Nahi — yeh worst case hai. Same-sign well-scaled data ke liye actual error kaafi chhoti hoti hai; badly ordered ya cancelling data ke liye yeh bound ke paas pahunch sakti hai. Yeh signal karta hai ki error $n$ ke saath badhti hai, jo Kahan remove karta hai.

Yeh True hai — positive aur negative zero equal compare karte hain — lekin woh downstream alag behave kar sakte hain (e.g. 1/0.0 $+\infty$ deta hai, 1/-0.0 $-\infty$ deta hai), isliye zero ka sign division aur branch cuts mein ek real edge case hai.

Smallest normal double se neeche ke results subnormals ke roop mein chalte rehte hain (gradual underflow) — tum seedha $0$ par jump nahi karte — lekin har subnormal ke paas fewer mantissa bits hote hain, isliye relative precision degrade hoti hai aur, kuch hardware par, subnormal arithmetic kaafi slow chalti hai (ya trap karta hai). Smallest subnormal se neeche tum $0$ par outright underflow karte ho.

Yeh ek rounding artifact hai, real negative nahi; ise $0$ par clamp karo (max(v, 0.0)) sqrt ko feed karne se pehle, warna sqrt nan return karega aur baad ki saari cheez poison ho jaayegi.