rust - ¿Hay una función/operación de módulo(no resto)?

modulo

Question

En Rust (como la mayoría de los lenguajes de programación), el operador % realiza la operación de resto , no la operación de módulo . Estas operaciones tienen diferentes resultados para números negativos :

-21 modulus 4 => 3
-21 remainder 4 => -1

println!("{}", -21 % 4); // -1

Sin embargo, quiero el resto.

Encontré una solución ((a % b) + b) % b , ¡pero no quiero reinventar la rueda si ya hay una función para eso!

Answer 1

¿Hay una función / operación de módulo (¡no resto!) En Rust?

Por lo que puedo decir, no hay una función aritmética modular .

Esto también sucede en C, por ejemplo, y es común usar una solución como mencionó: (a % b) + b .

En general, para lenguajes como C, C ++, D, C #, F # o Java: % es el resto. Mientras que en lenguajes de script como Perl, Python o Ruby: % es el módulo.

Desde el punto de vista matemático estricto, los desarrolladores de lenguajes no siempre siguen el "camino matemático correcto", por lo que los lenguajes informáticos podrían ser raros al principio. La cosa es que ambos, módulo y resto, son correctos para diferentes usos. El módulo es más matemático si lo desea, mientras que el resto (en la familia C) es consistente con la división entera común que satisface: (a/b)*b + a%b = a (y esto se adopta del antiguo Fortran). Así que mejor se llama % al resto, y supongo que Rust está siendo consistente con C.

Y, obviamente, no es la primera vez que observa esto, verifique estos problemas en Rust git-hub:

• No modulo operador?
• El resto no es módulo, pero int :: rem () usa el operador mod. .

Answer 2

No, Rust no tiene un módulo incorporado, vea esta discusión por algunas razones.

Aquí hay un ejemplo que podría ser útil para cualquiera que se encuentre en esta página.

///
/// Modulo that handles negative numbers, works the same as Python''s `%`.
///
/// eg: `(a + b).modulo(c)`
///
pub trait ModuloSignedExt {
    fn modulo(&self, n: Self) -> Self;
}
macro_rules! modulo_signed_ext_impl {
    ($($t:ty)*) => ($(
        impl ModuloSignedExt for $t {
            #[inline]
            fn modulo(&self, n: Self) -> Self {
                (self % n + n) % n
            }
        }
    )*)
}
modulo_signed_ext_impl! { i8 i16 i32 i64 }