Module en Rust : ne le confondez pas avec le reste de la division

Introduction : pourquoi la question du module est-elle si populaire ?

Si vous avez déjà écrit du code en Rust et rencontré des nombres négatifs, vous vous êtes sûrement demandé : « Mais où est la fonction module ? ». Sur Stack Overflow, cette question a recueilli des milliers de vues, et ce n'est pas pour rien. En effet, l'opérateur % en Rust n'est pas un module (modulus), mais un reste de division (remainder). La différence est subtile, mais cruciale, surtout dans les algorithmes, la cryptographie ou le travail avec des structures cycliques.

Dans cet article, nous allons voir en quoi le module mathématique diffère du reste, comment Rust gère les nombres négatifs et comment écrire votre propre fonction pour calculer le vrai module. L'article est destiné aux débutants, mais sera également utile aux développeurs expérimentés qui souhaitent rafraîchir leurs connaissances.

Sommaire

\n
• Qu'est-ce que le module et le reste : différence mathématique
\n
• Pourquoi % en Rust n'est pas un module
\n
• Comment écrire une fonction module en Rust
\n
• Exemples concrets : indices cycliques et hachages
\n
• Conclusions et conseils pratiques
\n

Mathématiques : module vs reste

Commençons par les bases. En mathématiques, le module (modulus) est une opération qui renvoie un nombre non négatif, inférieur au diviseur. Par exemple :

\n
• 7 mod 3 = 1 (7 divisé par 3 donne un reste de 1)
\n
• -7 mod 3 = 2 (car -7 = 3 * (-3) + 2)
\n

Le reste de division (remainder) est ce qui reste après une division entière. Dans la plupart des langages de programmation (C, C++, Java, Rust), l'opérateur % renvoie précisément le reste, qui peut être négatif si le dividende est négatif. Exemple :

\n
• 7 % 3 = 1 (identique)
\n
• -7 % 3 = -1 (en Rust, car -7 / 3 = -2, reste -1)
\n

Pourquoi est-ce important ? Imaginez que vous écriviez un programme pour une horloge : l'heure va de 0 à 23. S'il est 22 heures et que vous ajoutez 5 heures, vous obtenez 3 heures du matin. Cela fonctionne avec le module : (22 + 5) mod 24 = 3. Mais si vous utilisez le reste, tout se casse avec des valeurs négatives. Par exemple, (-3) % 24 en Rust donnera -3, et non 21.

Pourquoi l'opérateur % en Rust est un remainder

En Rust, l'opérateur % est défini comme un reste de division. C'est documenté et c'est le comportement de la bibliothèque standard. La raison est historique : c'est ainsi que cela fonctionne en C et dans de nombreux autres langages. Rust suit le principe « l'explicite est meilleur que l'implicite », mais ici les débutants tombent souvent dans le piège.

fn main() {\n    println!("7 % 3 = {}", 7 % 3);   // 1\n    println!("-7 % 3 = {}", -7 % 3); // -1\n    println!("7 % -3 = {}", 7 % -3); // 1 (oui, le signe du diviseur n'a pas d'effet)\n    println!("-7 % -3 = {}", -7 % -3); // -1\n}

Remarquez : le signe du résultat est toujours le même que celui du dividende. Ce n'est pas un module. Pour un vrai module, le résultat doit toujours être non négatif.

Comment écrire une fonction de vrai module en Rust ?

La bibliothèque standard de Rust ne fournit pas de fonction intégrée pour le module (contrairement à Python, où % fonctionne comme un module). Mais il est très simple d'en écrire une. Voici la méthode la plus courante : à partir du reste avec correction.

Fonction modulus pour les entiers

fn modulus(a: i32, b: i32) -> i32 {\n    let r = a % b;\n    if r < 0 { r + b.abs() } else { r }\n}\n\nfn main() {\n    println!("modulus(7, 3) = {}", modulus(7, 3));   // 1\n    println!("modulus(-7, 3) = {}", modulus(-7, 3)); // 2\n    println!("modulus(7, -3) = {}", modulus(7, -3)); // 1 (le module est toujours non négatif)\n    println!("modulus(-7, -3) = {}", modulus(-7, -3)); // 2\n}

Comment ça marche : on prend le reste a % b. S'il est négatif, on ajoute la valeur absolue