Efficient wrap around of doubles in C on unit axis

Question

Consider an axis like so:

Now consider an atom placed on the axis at position: double pos; with 0.0 < pos < 1.0. The position may be displaced by double dt; which can be any (+ve/-ve) double thus double newPos = pos + dt; could possibly not lie within the range 0.0 < newPos < 1.0.

Is there any way to implement a wrap around eg. if atom leaves on the right side re-insert on the left without resulting to fmod (which may be too slow for my case)?

I have a feeling there should be a straight-forward way since when dt is an integer (in the sense that there is no fractional part) the position remains unchanged (with wraparound) ie. adding 0.2 + 1.0 is still 0.2 (or 2.0,3.0...) and I can extract the fractional part quickly enough using double frac = myDouble - ((long) myDouble); but anything I try doesn't really work on all cases.

Any ideas on this?

If you're storing values in floating point format then you must accept and handle rounding errors. — 2501, Nov 14 '16 at 12:51
Sounds like `ouble frac = myDouble - ((long)myDouble)` is good enough not only for integers, but also for all other values. What do you expect from `0.2+1.4`, for example? Is it `0.6`? — barak manos, Nov 14 '16 at 12:52
I rest my case then, you just need to treat negative value in a slightly different way, that's all. — barak manos, Nov 14 '16 at 12:54
@2501 `pos` and `dt` will 99% of the time be of similar magnitude so the floating point error should be acceptable — ᴘᴀɴᴀʏɪᴏᴛɪs, Nov 14 '16 at 13:00

barak manos · Accepted Answer · 2016-11-14T13:09:15.483

1

Try this:

newPos = pos + dt;
if (newPos == (long)newPos)
    newPos = 0;
else if (newPos > 0)
    newPos -= (long)newPos;
else
    newPos -= (long)newPos-1;

Or alternatively:

newPos = pos + dt;
newPos -= (long)newPos;
if (newPos < 0)
    newPos += 1;

edited Nov 14 '16 at 13:09

answered Nov 14 '16 at 12:59

barak manos

29,648
10
62
114

Thanks that seems to work. I'll give it a few tries in a real scenario and let you know – ᴘᴀɴᴀʏɪᴏᴛɪs Nov 14 '16 at 13:07
@ᴘᴀɴᴀʏɪᴏᴛɪs: No problem. Allow me to change the `>= 0` to `> 0` (though it won't make much of a difference). – barak manos Nov 14 '16 at 13:09
@ᴘᴀɴᴀʏɪᴏᴛɪs: And please see an alternative solution added to the answer. – barak manos Nov 14 '16 at 13:11
@ᴘᴀɴᴀʏɪᴏᴛɪs: In addition, in order to ensure consistency across different platforms, I would recommend to use `long long` instead of `long`. – barak manos Nov 14 '16 at 13:23

score 1 · Answer 2 · edited May 23 '17 at 10:30

You shouldn't muddle with conversions to integers and possible undefined behavior. Rather use the completely portable floating point version of remainder:

const double raw = pos + dt;
const double wrap = raw >= 1.0 ? fmod( raw , 1.0 ) : raw;

Since you mentioned that the results rarely exceeds 1.0, this function shouldn't cause any performance problems. Even if it does, the implementation of fmod is fast. It should also be as accurate as possible.

Efficient wrap around of doubles in C on unit axis

2 Answers2