Wrapping a number around a designated inclusive range

[sww1235]

Been bashing my head against a mathematical wall trying to implement a Wrapping type that accepts an inclusive upper and lower bound. ^[1]. I plan on releasing this as a library once I get the base logic functioning.

I have all the generic bits taken care of, but the actual wrapping math is frustrating.

I have found several answers on stackoverflow, but they all seem to either not wrap correctly at all when implemented in rust or act as an exclusive upper range rather than an inclusive range.

Here are some links I have tried and simplified playground examples (just implemented using integers):

• This one gets close but fails to wrap the top of the range correctly:

Clean, efficient algorithm for wrapping integers in C++

Rust Playground

• This one fails to wrap either the top or bottom of the range correctly, with the top of the range being an off by one error.

Wrap value into range [min,max] without division

Rust Playground

I can't tell if there is something different in the math implementation between C++/C# and rust, or that the algorithms are incorrect.

If the algorithms are incorrect, can someone point me to a correct algorithm for inclusive wrapping, my googlefoo is failing.

Thanks in advance!

---

1. I realize this will be checked and wrapped at runtime. Unfortunately, things like: Range types for integers (or refinement types?) · Issue #671 · rust-lang/rfcs · GitHub or Numerical Constrained Types · Issue #1621 · rust-lang/rfcs · GitHub haven't had any momentum ↩︎

[Schard]

I am unsure as to whether I understand your problem correctly.
Do you intend to write something like this?
Playground

Edit: After reading the SO post more carefully, I think this is what you want:

Rust Playground

As mentioned by another user, I also think that your first test cases is wrong.

[2e71828]

By applying the principles of modular arithmetic, you can get this slightly verbose version. As long as you only ever add or subtract integers that are in group 0 and you end up in the proper range, you will have the correct answer.

fn wrap_range(input: i64, max: i64, min: i64) -> i64 {
    let modulus = max - min + 1;
    let in_group = input % modulus;
    let min_group_0 = min - min % modulus;
    let mut out = min_group_0 + in_group;
    if out < min {
        out += modulus;
    }
    out
}

Rust Playground

---

As far as I can tell, the first version you posted is also producing correct results for your tests¹, but one of your expected values is incorrect— My playground link includes a corrected test and output table showing what I believe the correct outputs should be. The second version appears to be designed for half-open intervals instead of closed ones (based on its arguments to the % operator).

¹ I haven’t tried to follow the logic to see if it will always produce the correct results…

[tczajka]

fn wrap(x: i64, min: i64, max: i64) -> i64 {
    min + (x - min).rem_euclid(max - min + 1)
}

This will overflow in some cases, so if you want to handle all possible inputs you have to do some more work.

[2e71828]

@tczajka

if you want to handle all possible inputs you have to do some more work.

The simplest (but not necessarily most efficient) way to do this is to work with larger integers during the calculation:

fn wrap(x: i64, min: i64, max: i64) -> i64 {
    let (x, min, max)=(x as i128, min as i128, max as i128);
    (min + (x - min).rem_euclid(max - min + 1)) as i64
}

[sww1235]

Thank you. I was trusting my sleep deprived brain over actual math which is never a good time.

My tests were off, which was convincing me that my math was wrong.

I have to say, I like your solution a lot better from a rust/ergonomics perspective, with the extra trait etc. Mind if I borrow pieces of it?

Thanks again.

[sww1235]

You were correct, my tests were off. Thanks again.