Modulo (opération)

Pour les articles homonymes, voir Modulo.

En informatique, l'opération modulo^[1]^,^[2], ou opération mod^[3], est une opération binaire qui associe, à deux entiers naturels, le reste de la division euclidienne du premier par le second. Le reste de la division de a par n (n ≠ 0) est noté a mod n (ou a % n dans certains langages informatiques). Ainsi 9 mod 4 = 1, car 9 = 2×4 + 1 et 0 ≤ 1 < 4. De même 9 mod 3 = 0. L'opération peut être étendue aux entiers relatifs, voire aux nombres réels^[4], mais alors les langages de programmation peuvent diverger, en particulier a mod n n'est plus forcément positif ou nul^[5].

Si ce bandeau n'est plus pertinent, retirez-le. Cliquez ici pour en savoir plus.

Cet article ne cite pas suffisamment ses sources (juin 2009).

En mathématiques, l'usage du terme modulo est différent même s'il est lié : il ne désigne pas une opération mais intervient pour caractériser une relation de congruence sur les entiers (et plus généralement pour d'autres congruences) ; le mot clef mod associé n'est le plus souvent utilisé que pour noter cette congruence, même si un ouvrage comme Concrete Mathematics l'utilise également pour désigner l'opération binaire^[6].

Différentes définitions de la fonction modulo

Résumé

Contexte

L'opération mod associe à deux entiers naturels $a$ et $b \neq 0$ le reste de la division euclidienne de $a$ par $b$ , qui est l'unique entier $r$ vérifiant :

$a = b \times q + r$ pour un certain entier naturel $q$ ;
$0 \leq r < b$ .

Par exemple :

12 mod 10 = 2

car 12 = 10 × 1 + 2 et 0 ≤ 2 < 10

c'est-à-dire que 2 est le reste de la division euclidienne de 12 par 10.

Usage

En mathématique le modulo est couramment utilisé pour définir des relations de congruence sur les entiers. C'est-à-dire des relations de comparaison circulaire typique, par exemple, des calculs calendaires.

En informatique, le modulo est classiquement utilisé dans le même esprit.

Exemple simple

Un exemple classique utilisé en mathématique et également représentatif de son usage en informatique, est le calcul sur une horloge.

En effet, sur une horloge, l'addition des heures est circulaire : s'il est 9h et que je rajoute 4h alors il est 13h, mais, sur une horloge qui repasse à 0 après le passage à 12, alors il est noté 1h.

On dit que les opérations sur l'horloge sont alors « modulo 12 ».

1 et 13 sont alors dit « congrus modulo 12 », ou encore :

1 ≡ 13 (mod 12).

En considérant le modulo comme une opération, comme c'est le cas en informatique, on écrirait :

Heure_finale = ( Heure_initiale + x ) mod 12

De manière générale, en informatique, l'opération modulo est utilisée pour toute opération circulaire similaire (calcul calendaire, certains parcours de tableau etc.)

Exemple avec des décalages circulaires

L'opération modulo permet d'effectuer un décalage circulaire d'indices. En effet, si l'on considère la suite des entiers contigus de 1 à n, u = (1, 2, 3…, n − 1, n), alors on peut décaler de p rangs avec :

u'_i = ((u_i + p − 1) mod n) + 1.

Par exemple, pour décaler de deux la suite (1, 2, 3, 4, 5) :

u'_i = ((u_i + 1) mod 5) + 1 ;

on a bien :

u'₁ = ((1 + 1) mod 5) + 1 = 3
u'₂ = ((2 + 1) mod 5) + 1 = 4
…
u'₄ = ((4 + 1) mod 5) + 1 = 1

et donc u' = (3, 4, 5, 1, 2).

Divergence des définitions dans les cas autres que les entiers naturels

L'analogie avec la définition du reste de la division euclidienne est brisée une fois qu'on l'étend aux entiers négatifs ou aux réels. Le comportement du modulo diffère alors en fonction des langages de programmation et ne respecte en général plus la définition mathématique du reste de la division euclidienne.

En effet, le reste de la division reste positif dans tous les cas (voir schéma ci-contre), contrairement à de nombreuses autres définitions utilisées en informatique (voir sections ci-après).

On décrit ci-dessous quelques-unes des définitions courantes dans les langages informatiques.

Les différentes définitions en informatique

Résumé

Contexte

Définition utilisant la partie entière (inférieure)

Article connexe : Partie entière et partie fractionnaire.

Soit la notation $\lfloor x\rfloor$ définissant le plus grand entier inférieur ou égal à x.

Alors on peut poser une définition du modulo tel que :

a{\bmod {n}}=a-\left\lfloor {\frac {a}{n}}\right\rfloor \times n

L'opérateur mod renvoie alors un modulo toujours compris entre 0 (inclus) et le diviseur n (exclu) et qui a le même signe que le diviseur n. Ce qui le distingue du reste de la division euclidienne puisque le modulo peut alors être négatif quand le quotient est négatif.

Exemple :

Davantage d’informations Dividende, Diviseur ...

Dividende	Diviseur	Quotient	Reste
117	17	6	15
−117	17	−7	2
−117	−17	6	−15
117	−17	−7	−2
12,7	3,5	3	2,2

Fermer

Cette définition vérifie les lois de l'arithmétique modulaire, plus : x mod −y = −((−x) mod y). Elle convient pour les calculs cycliques. La valeur modulaire renvoyée est toujours du signe du diviseur (le diviseur étant positif dans la plupart des calculs cycliques).

Définition utilisant la troncature de la partie décimale

$\left[x\right]$ est la troncature entière de x.

a{\bmod {n}}=a-\left[{\frac {a}{n}}\right]\times n

L'opérateur mod renvoie alors :

un modulo positif inférieur à $\left|n\right|$ pour a positif.
un modulo négatif supérieur à $-\left|n\right|$ pour a négatif.

Exemple :

Davantage d’informations Dividende, Diviseur ...

Dividende	Diviseur	Quotient	Reste
117	17	6	15
−117	17	−6	−15
−117	−17	6	−15
117	−17	−6	15

Fermer

Le modulo a le même signe que l'opérande gauche.

Cette définition vérifie la loi: x mod −y = x mod y. Elle viole la loi (x+n) mod n = x mod n.

Définition utilisant l'arrondi

On peut également utiliser l'arrondi en définissant le quotient tel que :

$q=arrondi({\frac {a}{b}})$

Où « arrondi » est la fonction arrondi.

Le reste, résultat du modulo, est alors défini par :

$r=a-n\times arrondi({\frac {a}{b}})$

Cette définition est notamment utilisée dans le langage LISP.

Définition utilisant la partie entière supérieure

Soit la notation $\left\lceil x\right\rceil$ définissant le plus petit entier supérieur ou égal à x.

Alors on peut poser une définition du quotient ainsi :

$q=\left\lceil {\frac {a}{n}}\right\rceil$

Et la définition du modulo tel que :

$a{\bmod {n}}=a-\left\lceil {\frac {a}{n}}\right\rceil \times n$

Le comportement est proche de celui de la partie entière inférieure.

Ce comportement est également trouvé en LISP.

Comparaison sous forme de tableau

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

Davantage d’informations partie entière, troncature ...

comparaison des opérateurs Modulo
		partie entière		troncature		fonct. euclidienne
Dividende	Diviseur	Quotient	Reste	Quotient	Reste	Quotient	Reste
117	17	6	15	6	15	6	15
−117	17	−7	2	−6	−15	-7	2
−117	−17	6	−15	6	−15	7	2
117	−17	−7	−2	−6	15	-6	15
12,7	3,5	3	2,2

Fermer

Comportement avec des opérandes non entiers

D'un point de vue strictement mathématique, il n'existe pas d'équivalent strict au modulo dans l'espace des réels. Il peut exister des équivalences partielles mais certaines opérations ne sont alors plus valables.

Toutefois, du strict point de vue des définitions utilisées dans les langages informatiques, les deux définitions informatiques précédentes du modulo restent valide et permettent donc à x et y d'être des nombres rationnels (ou réels en mathématiques, bien que les systèmes informatiques de calcul numérique ne sachent travailler que sur un sous-ensemble des nombres rationnels, du fait de limites de précision).

Cependant, par analogie avec la fonction mathématique, en C, C++, PHP et de nombreux langages, l'opérateur mod ou % n'opère que sur les types entiers. A contrario : dans certains cas l'opérateur modulo est étendu aux réels. Attention, parce que suivant le langage, les types numériques sont parfois convertis implicitement en entiers (par coercition) ce qui peut donner l'impression que l'opérateur est étendu aux réels quand ce n'est pas le cas.

Comportement des langages de programmation

Résumé

Contexte

Davantage d’informations Langage, Opérateur ...

Tableau récapitulatif des différents opérateurs et de leur définition en fonction du langage informatique
Langage	Opérateur	Prend en charge les entiers ?	Prise en charge nombres flottants ?	Définition utilisée
ABAP	`MOD`	Oui	Oui	Euclidienne
ActionScript	`%`	Oui	(no)	Troncature
Ada (langage)	`mod`	Oui	(no)	Partie entière (inférieure)^[7]
Ada (langage)	`rem`	Oui	(no)	Troncature^[7]
ALGOL 68	`÷×`, `mod`	Oui	(no)	Euclidienne
AMPL	`mod`	Oui	(no)	Troncature
APL	`\|`^{[note 1]}	Oui	Oui	Partie entière (inférieure)
AppleScript	`mod`	Oui	(no)	Troncature
AutoLISP de AutoCAD	`(rem d n)`	Oui	(no)	Troncature
AWK	`%`	Oui	(no)	Troncature
bash	`%`	Oui	(no)	Troncature
BASIC	`Mod`	Oui	(no)	Dépend de l'implémentation
bc (voir bc (Unix))	`%`	Oui	(no)	Troncature
C^[8] C++	`%`, `div`	Oui	(no)	Troncature^{[note 2]}
	`fmod` (C) `std::fmod` (C++)	(no)	Oui	Troncature^[11]
	`remainder` (C) `std::remainder` (C++)	(no)	Oui	Arrondi
C#	`%`	Oui	Oui	Troncature
C#	`Math.IEEERemainder`	(no)	Oui	Arrondi^[12]
Clarion (langage)	`%`	Oui	(no)	Troncature
Clean (langage) (en)	`rem`	Oui	(no)	Troncature
Clojure	`mod`	Oui	(no)	Partie entière (inférieure)^[13]
Clojure	`rem`	Oui	(no)	Troncature^[14]
COBOL	`FUNCTION MOD`	Oui	(no)	Partie entière (inférieure)^[15]
COBOL	`FUNCTION REM`	Oui	Oui	Troncature^[15]
CoffeeScript	`%`	Oui	(no)	Troncature
CoffeeScript	`%%`	Oui	(no)	Partie entière (inférieure)^[16]
ColdFusion	`%`, `MOD`	Oui	(no)	Troncature
Common Intermediate Language	`rem` (signed)	Oui	Oui	Troncature^[17]
Common Intermediate Language	`rem.un` (unsigned)	Oui	(no)	NC
Common Lisp	`mod`	Oui	Oui	Partie entière (inférieure)
Common Lisp	`rem`	Oui	Oui	Troncature
Crystal (langage de programmation)	`%`, `modulo`	Oui	Oui	Partie entière (inférieure)
Crystal (langage de programmation)	`remainder`	Oui	Oui	Troncature
D (langage)	`%`	Oui	Oui	Troncature^[18]
Dart (langage)	`%`	Oui	Oui	Euclidienne^[19]
Dart (langage)	`remainder()`	Oui	Oui	Troncature^[20]
Eiffel (langage)	`\\`	Oui	(no)	Troncature
Elixir (langage)	`rem/2`	Oui	(no)	Troncature^[21]
Elixir (langage)	`Integer.mod/2`	Oui	(no)	Partie entière (inférieure)^[22]
Elm (langage)	`modBy`	Oui	(no)	Partie entière (inférieure)^[23]
Elm (langage)	`remainderBy`	Oui	(no)	Troncature^[24]
Erlang (langage)	`rem`	Oui	(no)	Troncature
Erlang (langage)	`math:fmod/2`	(no)	Oui	Troncature (identique au C)^[25]
Euphoria (langage)	`mod`	Oui	(no)	Partie entière (inférieure)
Euphoria (langage)	`remainder`	Oui	(no)	Troncature
F#	`%`	Oui	Oui	Troncature
F#	`Math.IEEERemainder`	(no)	Oui	Arrondi^[12]
Factor	`mod`	Oui	(no)	Troncature
FileMaker	`Mod`	Oui	(no)	Partie entière (inférieure)
Forth (langage)	`mod`	Oui	(no)	Dépend de l'implémentation
	`fm/mod`	Oui	(no)	Partie entière (inférieure)
	`sm/rem`	Oui	(no)	Troncature
Fortran	`mod`	Oui	Oui	Troncature
Fortran	`modulo`	Oui	Oui	Partie entière (inférieure)
Frink (langage) (en)	`mod`	Oui	(no)	Partie entière (inférieure)
(Full BASIC (en)) (standard ANSI)	`MOD`	Oui	Oui	Partie entière (inférieure)^[26]
(Full BASIC (en)) (standard ANSI)	`REMAINDER`	Oui	Oui	Troncature^[27]
GLSL	`%`	Oui	(no)	Non défini^[28]
GLSL	`mod`	(no)	Oui	Partie entière (inférieure)^[29]
GameMaker Studio (GML)	`mod`, `%`	Oui	(no)	Troncature
GDScript (Godot)	`%`	Oui	(no)	Troncature
	`fmod`	(no)	Oui	Troncature
	`posmod`	Oui	(no)	Partie entière (inférieure)
	`fposmod`	(no)	Oui	Partie entière (inférieure)
Go (langage)	`%`	Oui	(no)	Troncature^[30]
	`math.Mod`	(no)	Oui	Troncature^[31]
	`big.Int.Mod`	Oui	(no)	Euclidienne^[32]
Groovy (langage)	`%`	Oui	(no)	Troncature
Haskell	`mod`	Oui	(no)	Partie entière (inférieure)^[33]
	`rem`	Oui	(no)	Troncature^[33]
	`Data.Fixed.mod'` (GHC)	(no)	Oui	Partie entière (inférieure)
Haxe	`%`	Oui	(no)	Troncature
HLSL	`%`	Oui	Oui	Non défini^[34]
J (langage)	`\|`^{[note 1]}	Oui	(no)	Partie entière (inférieure)
Java (langage)	`%`	Oui	Oui	Troncature
Java (langage)	`Math.floorMod`	Oui	(no)	Partie entière (inférieure)
JavaScript TypeScript	`%`	Oui	Oui	Troncature
Julia (langage)	`mod`	Oui	Oui	Partie entière (inférieure)^[35]
Julia (langage)	`%`, `rem`	Oui	Oui	Troncature^[36]
Kotlin (langage)	`%`, `rem`	Oui	Oui	Troncature^[37]
Kotlin (langage)	`mod`	Oui	Oui	Partie entière (inférieure)^[38]
ksh	`%`	Oui	(no)	Troncature (identique à POSIX sh)
ksh	`fmod`	(no)	Oui	Troncature
LabVIEW	`mod`	Oui	Oui	Troncature
LibreOffice	`=MOD()`	Oui	(no)	Partie entière (inférieure)
Logo (langage)	`MODULO`	Oui	(no)	Partie entière (inférieure)
Logo (langage)	`REMAINDER`	Oui	(no)	Troncature
Lua (langage) 5	`%`	Oui	Oui	Partie entière (inférieure)
Lua (langage) 4	`mod(x,y)`	Oui	Oui	Troncature
(Liberty BASIC (en))	`MOD`	Oui	(no)	Troncature
Mathcad	`mod(x,y)`	Oui	(no)	Partie entière (inférieure)
Maple	`e mod m` (by default), `modp(e, m)`	Oui	(no)	Euclidienne
	`mods(e, m)`	Oui	(no)	Arrondie
	`frem(e, m)`	Oui	Oui	Arrondie
Mathematica	`Mod[a, b]`	Oui	(no)	Partie entière (inférieure)
MATLAB	`mod`	Oui	(no)	Partie entière (inférieure)
MATLAB	`rem`	Oui	(no)	Troncature
Maxima (logiciel)	`mod`	Oui	(no)	Partie entière (inférieure)
Maxima (logiciel)	`remainder`	Oui	(no)	Troncature
Maya Embedded Language	`%`	Oui	(no)	Troncature
Microsoft Excel	`=MOD()`	Oui	Oui	Partie entière (inférieure)
Minitab	`MOD`	Oui	(no)	Partie entière (inférieure)
Modula-2	`MOD`	Oui	(no)	Partie entière (inférieure)
Modula-2	`REM`	Oui	(no)	Troncature
MUMPS	`#`	Oui	(no)	Partie entière (inférieure)
Netwide Assembler (NASM, NASMX)	`%`, `div` (unsigned)	Oui	(no)	NC
Netwide Assembler (NASM, NASMX)	`%%` (signed)	Oui	(no)	Dépends de l'implémentation^[39]
Nim (langage)	`mod`	Oui	(no)	Troncature
Oberon (langage)	`MOD`	Oui	(no)	Proche de Partie entière (inférieure)^{[note 3]}
Objective-C	`%`	Oui	(no)	Troncature (identique à C99)
Object Pascal, Delphi (langage)	`mod`	Oui	(no)	Troncature
OCaml	`mod`	Oui	(no)	Troncature^[40]
OCaml	`mod_float`	(no)	Oui	Troncature^[41]
Occam (langage)	`\`	Oui	(no)	Troncature
Pascal (langage) (ISO-7185 and -10206)	`mod`	Oui	(no)	Proche de l'Euclidienne^{[note 4]}
Perl (langage)	`%`	Oui	(no)	Partie entière (inférieure)^{[note 5]}
Perl (langage)	`POSIX::fmod`	(no)	Oui	Troncature
Phix	`mod`	Oui	(no)	Partie entière (inférieure)
Phix	`remainder`	Oui	(no)	Troncature
PHP	`%`	Oui	(no)	Troncature^[43]
PHP	`fmod`	(no)	Oui	Troncature^[44]
PIC BASIC Pro	`\\`	Oui	(no)	Troncature
PL/I	`mod`	Oui	(no)	Partie entière (inférieure) (ANSI PL/I)
PowerShell	`%`	Oui	(no)	Troncature
Programming Code (PRC)	`MATH.OP - 'MOD; (\)'`	Oui	(no)	Undefined
Progress (Progress Software)	`modulo`	Oui	(no)	Troncature
Prolog (ISO 1995)	`mod`	Oui	(no)	Partie entière (inférieure)
Prolog (ISO 1995)	`rem`	Oui	(no)	Troncature
PureBasic	`%`, `Mod(x,y)`	Oui	(no)	Troncature
PureScript	`mod`	Oui	(no)	Euclidean^[45]
Pure Data	`%`	Oui	(no)	Troncature (same as C)
Pure Data	`mod`	Oui	(no)	Partie entière (inférieure)
Python	`%`	Oui	Oui	Partie entière (inférieure)
Python	`math.fmod`	(no)	Oui	Troncature
Q#	`%`	Oui	(no)	Troncature^[46]
R (langage)	`%%`	Oui	Oui	Partie entière (inférieure)^[47]
Racket	`modulo`	Oui	(no)	Partie entière (inférieure)
Racket	`remainder`	Oui	(no)	Troncature
Raku	`%`	(no)	Oui	Partie entière (inférieure)
RealBasic	`MOD`	Oui	(no)	Troncature
Reason	`mod`	Oui	(no)	Troncature
Rexx	`//`	Oui	Oui	Troncature
RPG	`%REM`	Oui	(no)	Troncature
Ruby	`%`, `modulo()`	Oui	Oui	Partie entière (inférieure)
Ruby	`remainder()`	Oui	Oui	Troncature
Rust	`%`	Oui	Oui	Troncature
Rust	`rem_euclid()`	Oui	Oui	Euclidienne^[48]
SAS	`MOD`	Oui	(no)	Troncature
Scala	`%`	Oui	Oui	Troncature
Scheme	`modulo`	Oui	(no)	Partie entière (inférieure)
Scheme	`remainder`	Oui	(no)	Troncature
Scheme R⁶RS	`mod`	Oui	(no)	Euclidienne^[49]
	`mod0`	Oui	(no)	Arrondie^[49]
	`flmod`	(no)	Oui	Euclidienne
	`flmod0`	(no)	Oui	Arrondie
Scratch	`mod`	Oui	Oui	Partie entière (inférieure)
Seed7 (en)	`mod`	Oui	Oui	Partie entière (inférieure)
Seed7 (en)	`rem`	Oui	Oui	Troncature
SenseTalk (en)	`modulo`	Oui	(no)	Partie entière (inférieure)
SenseTalk (en)	`rem`	Oui	(no)	Troncature
`sh` (POSIX) (includes bash, mksh, &c.)	`%`	Oui	(no)	Troncature (same as C)^[50]
Smalltalk	`\\`	Oui	(no)	Partie entière (inférieure)
Smalltalk	`rem:`	Oui	(no)	Troncature
Snap!	`mod`	Oui	(no)	Partie entière (inférieure)
Spin (en)	`//`	Oui	(no)	Partie entière (inférieure)
Solidity	`%`	Oui	(no)	Partie entière (inférieure)
SQL (SQL:1999)	`mod(x,y)`	Oui	(no)	Troncature
SQL (SQL:2011)	`%`	Oui	(no)	Troncature
Standard ML	`mod`	Oui	(no)	Partie entière (inférieure)
	`Int.rem`	Oui	(no)	Troncature
	`Real.rem`	(no)	Oui	Troncature
Stata	`mod(x,y)`	Oui	(no)	Euclidienne
Swift	`%`	Oui	(no)	Troncature^[51]
	`remainder(dividingBy:)`	(no)	Oui	Arrondie^[52]
	`truncatingRemainder(dividingBy:)`	(no)	Oui	Troncature^[53]
Tcl	`%`	Oui	(no)	Partie entière (inférieure)
Tcl	`fmod()`	(no)	Oui	Troncature (as C)
tcsh	`%`	Oui	(no)	Troncature
Torque	`%`	Oui	(no)	Troncature
Turing (langage) (en)	`mod`	Oui	(no)	Partie entière (inférieure)
Verilog (2001)	`%`	Oui	(no)	Troncature
VHDL	`mod`	Oui	(no)	Partie entière (inférieure)
VHDL	`rem`	Oui	(no)	Troncature
VimL	`%`	Oui	(no)	Troncature
Visual Basic	`Mod`	Oui	(no)	Troncature
WebAssembly	`i32.rem_u`, `i64.rem_u` (unsigned)	Oui	(no)	NC^[54]
WebAssembly	`i32.rem_s`, `i64.rem_s` (signed)	Oui	(no)	Troncature^[54]
Assembleur x86 (en)	`IDIV`	Oui	(no)	Troncature
XBase++ (en)	`%`	Oui	Oui	Troncature
XBase++ (en)	`Mod()`	Oui	Oui	Partie entière (inférieure)
Zig	`%`, `@mod`, `@rem`	Oui	Oui	Troncature^[55]
Z3 Theorem Prover (en)	`div`, `mod`	Oui	(no)	Euclidienne

Fermer

Quelques détails concernant certains langages suivants la définition utilisant la partie entière inférieure

Perl : $a % $n est défini sur les entiers ; les opérandes réels sont tronqués vers 0 par coercition ;
Visual Basic : a Mod n est défini sur les réels et sur les entiers, et renvoie un entier si les deux opérandes sont entiers ;
Pascal (ISO 7185) : a mod n n'admet que des opérandes entiers, et n doit être strictement positif ;
Excel : MOD(a;n) fonctionne sur les nombres réels ;
Python : La FAQ explique ce choix par l'exemple suivant :

« si une horloge indique 10 heures, qu'indiquait-elle 200 heures avant ? -190 % 12 == 2 est utile ; -190 % 12 == -10 est un bug prêt à mordre^[56]. »

Quelques détails concernant certains langages suivants la définition utilisant la troncature

Free Pascal et Delphi n'autorisent que des opérandes entiers, et la définition du langage^[57] précise : « Le signe du résultat est le signe de l'opérande gauche » ;
C^[8], C++ : a % n demande des opérandes entiers ;
PHP : $a % $n est défini sur les entiers et renvoie un résultat ayant le même signe que $a ;
Scilab : modulo(a, n) accepte des réels.

Si l'on souhaite utiliser le modulo dans sa définition partie entière inférieure pour l'un de ces langages on peut utiliser l'expression :

   (a % n + n) % n

Valeur d'un modulo 0 (valeur 'zéro')

Dans la plupart des langages, l'opération modulo ne donne aucun résultat si le diviseur est nul, mais lance une exception arithmétique de division par zéro.

Équivalence

Résumé

Contexte

Les opérations sur les modulos peuvent être réduites ou étendues de la même manière que les autres opérations mathématiques.

Identité:
- $(a\,{\bmod {\,}}n)\,{\bmod {\,}}n=a\,{\bmod {\,}}n$
- $n^{k}\,{\bmod {\,}}n=0$ pour tous les entiers strictement positifs $k$ .
- Si $n$ est un nombre premier qui n'est pas un diviseur de $b$ , alors $ab^{n-1}\,{\bmod {\,}}n=a\,{\bmod {\,}}n$ , d'après le petit théorème de Fermat.
Inverse:
- $((-a\,{\bmod {\,}}n)+(a\,{\bmod {\,}}n))\,{\bmod {\,}}n=0$
- $b^{-1}\,{\bmod {\,}}n$ est l'inverse modulaire, qui est défini si et seulement si $b$ et $n$ sont premiers entre eux, ce qui est le cas quand la partie gauche est définie: $((b^{-1}\,{\bmod {\,}}n)\,(b\,{\bmod {\,}}n))\,{\bmod {\,}}n=1$ .
Distributivité:
- $(a+b)\,{\bmod {\,}}n=((a\,{\bmod {\,}}n)+(b\,{\bmod {\,}}n))\,{\bmod {\,}}n$
- $ab\,{\bmod {\,}}n=((a\,{\bmod {\,}}n)\,(b\,{\bmod {\,}}n))\,{\bmod {\,}}n$
- D’où : $a^{2}\,{\bmod {\,}}n=(a\,{\bmod {\,}}n)^{2}\,{\bmod {\,}}n$
Division (définition): ${\frac {a}{b}}\,{\bmod {\,}}n=((a\,{\bmod {\,}}n)(b^{-1}\,{\bmod {\,}}n))\,{\bmod {\,}}n$ , quand l'opérande de gauche est défini. Non définie sinon.
Multiplication inverse: $((ab\,{\bmod {\,}}n)\,(b^{-1}\,{\bmod {\,}}n))\,{\bmod {\,}}n=a\,{\bmod {\,}}n$
Autre:
- $(a+kn)\,{\bmod {\,}}n=a\,{\bmod {\,}}n$ ,avec k un entier naturel

Notes et références

Loading content...

Loading related searches...

Wikiwand - on

Seamless Wikipedia browsing. On steroids.