Contributor: BOB SWART { From: bobs@dragons.nest.nl (Bob Swart) On the BPASCAL forum on CompuServe, DJ Murdoch [71631,122] reported something that isn't a Borland bug, but looks as though it'll affect BP programs when they run on a Pentium: 64. For certain very rare pairs x and y, a $N+ division x/y will only be accurate to about 4 decimal digits when calculated on a Pentium produced before Fall 1994. Dr. Bob's further detailed analysis resulted in the following function which will generate 11 series of infinite "buggy" numbers for which the following does not hold on a Pentium chip (a reciprocal of a reciprocal): x = 1/1/x Try it on a Pentium with for example the magic number... 357914069 I also found that a power of 2 times any number that goes wrong also goes wrong (i.e. X, 2*X, 4*X, 8*X, etc). Also, once you've found a "wrong number" (and the serie), you can start a new serie by multiplying with 4 and adding 383 (= 256 + 128 - 1). Below follows a general function that is able to produce 11 series of (just about infinite) numbers that generate incorrect results. Note that the initial difference (for the first digit in a serie) is 21 1/3, and the difference increases with the same power of two as the original number... } {$N+,E-} program DrBob5; { Digits found in one night (source for analysis): 357914069, 715828138, 1431656276, 1431655893 (new series = 4 * X - 383 ) } function PentiumBug(Const Serie,Index: Word): Extended; { Serie max = 11 } Const Magic = 357914069; Factor= 256 + 128 - 1; var tmp: Extended; i: Integer; begin tmp := Magic; for i:=2 to Serie do tmp := 4.0 * tmp - Factor; for i:=2 to Index do tmp := tmp + tmp; PentiumBug := tmp end {PentiumBug}; var i,j: Integer; x,y,z: Double; begin for i:=1 to 11 do begin for j:=1 to 16 do begin x := PentiumBug(i,j); y := 1 / x; z := 1 / y; { z should be x, but isn't... } writeln('x = ',x:12:0,' 1/x =',y,' 1/1/x = ',z:12:0,' diff ',x-z:5:0) end; writeln end end. { The bug is in the FDIV instruction, which for about 1 in 10^10 pairs of randomly chosen divisors suffers a catastrophic loss of precision, ending up accurate to 4 to 6 digits instead of the usual 18. Apparently Intel chose a division algorithm which is fast but which isn't 100% guaranteed to work. I still don't know why the difference is 0 again starting with the 12th serie, but I'm sure given enough time I can reproduce the exact buggy FDIV algorithm Intel uses... }