* Avi:
> I need to implement the following calculation:
> f = (a*b) + (c*d)
> where a,b,c,d are given double values and f is a double variable for
> the result
>
> I found out that using two different implementations gives two
> different results:
> 1) In the first implementation I compute the entire equation in memory
> 2) In the second implementation I store intermediate to variables, and
> then load them to compute the final result.
> The results differ by a tiny amount (1E-15). I suspect that the reason
> for the difference is from round off errors of the compiler.
> Nonetheless, I need to know the reason for the difference as I need to
> have an absolute reference for optimization work.
Most likely calculations are performed using higher precision (e.g.
80-bits IEEE) than 'double' (e.g. 64-bits IEEE). Thus, when you store
intermediate results in 'double' variables you lose a little
precision. It depends very much on the compiler, and also which
optimizations you select and whether and how the optimizations are
applied by the compiler.
Possibly you can retain the precision if you use 'long double', but on
some compilers 'long double' has the same precision as 'double'.
And note that unless your compiler gives strict guarantees, whatever
result you get is not necessarily the same as with other options or
perhaps with other surrounding code (which can affect optimizations).
Cheers, & hth.,
- Alf
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
|
