Rust signed modulo unsigned -> unsigned

Question

In (stable) Rust, is there a relatively straightforward method of implementing the following function?

fn mod_euclid(val: i128, modulo: u128) -> u128;

Note the types, That is, 'standard' euclidean modulus (result is always in the range of [0, mod) ), avoiding spurious overflow/underflow in the intermediate calculation . Some test cases:

// don't-care, just no panic or UB.
// Mild preference for treating this as though it was mod=1<<128 instead of 0.
assert_dc!(mod_euclid(i128::MAX,         0)); 
assert_dc!(mod_euclid(        0,         0)); 
assert_dc!(mod_euclid(i128::MIN,         0)); 

assert_eq!(mod_euclid(        1,        10),                  1);
assert_eq!(mod_euclid(       -1,        10),                  9);
assert_eq!(mod_euclid(       11,        10),                  1);
assert_eq!(mod_euclid(      -11,        10),                  9);
assert_eq!(mod_euclid(i128::MAX,         1),                  0);
assert_eq!(mod_euclid(        0,         1),                  0);
assert_eq!(mod_euclid(i128::MIN,         1),                  0);
assert_eq!(mod_euclid(i128::MAX, u128::MAX),  i128::MAX as u128);
assert_eq!(mod_euclid(        0, u128::MAX),                  0);
assert_eq!(mod_euclid(i128::MIN, u128::MAX),  i128::MAX as u128);

For signed%signed->signed, or unsigned%unsigned->unsigned, this is relatively straightforward. However, I can't find a good way of calculating signed % unsigned -> unsigned without converting one of the arguments - and as the last example illustrates, this may overflow or underflow no matter which direction you choose.

Answer 1

As far as I can tell, there is no such function in the standard library, but it's not very difficult to write one yourself:

fn mod_euclid(a: i128, b: u128) -> u128 {
    if a >= 0 {
        (a as u128) % b
    } else {
        let r = (!a as u128) % b;
        b - r - 1
    }
}

Playground link

How it works:

• If a is non-negative then it's straightforward - just use the unsigned remainder operator.
• Otherwise, the bitwise complement !a is non-negative (because the sign bit is flipped), and numerically equal to -a - 1 . This means r is equivalent to b - a - 1 modulo b , and hence b - r - 1 is equivalent to a modulo b . Conveniently, b - r - 1 is in the expected range 0..b .

Answer 2

Maybe a little bit more straight forward, use rem_euclid where possible and return if a >= 0 {a} else {u128::MAX + a} else:

pub fn mod_euclid(a: i128, b: u128) -> u128 {
    const UPPER: u128 = i128::MAX as u128;
    match b {
        1..=UPPER => a.rem_euclid(b as i128) as u128,
        _ => a as u128 - (a < 0) as u128,
    }
}

(The parser didn't like my casting in the match hence UPPER )

Playground

Results in a little fewer instructions & jumps on x86_64 as well.