BrowserUk has asked for the wisdom of the Perl Monks concerning the following question:

Can anyone figure out why, given all the additions and subtractions involving doubles, going on in the following method; the only one wrapped in double( ) is the last one?

BTW: members lo & hi are both doubles. And the full source code is here. 

inline doubledouble operator +(const doubledouble& x, const doubledoub
+le& y) {
  double H, h, T, t, S, s, e, f;

  S = x.hi + y.hi; 
  T = x.lo + y.lo; 
  e = S - x.hi; 
  f = T - x.lo; 
  s = S - e; 
  t = T - f; 
  s = ( y.hi - e ) + ( x.hi - s); 
  t = ( y.lo - f ) + ( x.lo - t ); 
  e = s + T; 
  H = S + e; 
  h = e + ( S - H ); 
  e = t + h;

  doubledouble z; 
  z.hi = H + e; 
  z.lo = e + double( H - z.hi ); 

  return z;
}

[download]
With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'
Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
"Science is about questioning the status quo. Questioning authority".
In the absence of evidence, opinion is indistinguishable from prejudice.
I'm with torvalds on this Agile (and TDD) debunked I told'em LLVM was the way to go. But did they listen!

Replies are listed 'Best First'.
Re: [OT] C++ mystery.
by roboticus (Chancellor) on Jun 19, 2015 at 19:00 UTC

    BrowserUk:

    It looks like it's just ensuring that the return value is coerced into a double. I don't know anything about doubledouble, so perhaps it's using an extended floating point type (like long double)?

    ...roboticus

    When your only tool is a hammer, all problems look like your thumb.

[reply]
      It looks like it's just ensuring that the return value is coerced into a double

      But every variable in the entire subroutine is already a double?

      I don't know anything about doubledouble, so perhaps it's using an extended floating point type (like long double)?

      No. The doubledouble class provides greater precision by using pairs of doubles (hi & lo) to hold different parts of the higher precision value.

      This routine adds two doubledoubles together, by extracting any 'carry' from the lo+lo and adding it into the hi+hi calculation.

      I'm beginning (after reading a dozen or so papers and banging my head till it hurts) to understand how it achieves that; but the one bit that has me baffled is:

      why does it need to cast the subtraction of one double from another double; to a double, before adding it to another double?

      That; along with a couple of the other calculations don't appear to make any difference to the outcome no matter what values I've tried.

      Normally, I might just conclude they were artifacts of time; or minor over-engineering; but the routine is attributed (copyrighted) by W. Kahan

      And is (apparently) an implementation of the Kahan summation algorithm.

      So, I'm loathed to simplify; but I'm bugged that I cannot find any reason why they are there :(

      With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'
      Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
      "Science is about questioning the status quo. Questioning authority".
      In the absence of evidence, opinion is indistinguishable from prejudice.
      I'm with torvalds on this Agile (and TDD) debunked I told'em LLVM was the way to go. But did they listen!
[reply]

        to that point, why...

        z.hi = H + e
z.lo = e + H - z.hi
z.lo = e + H - ( H + e )
z.lo = e - e

        [download]

        ...my math may be rusty ;) ...

[reply]
[d/l]

Back to Seekers of Perl Wisdom