Voir la source de Modulo (opération)

{{homon|Modulo}}
{{à sourcer|date=juin 2009}}

En [[informatique]], l''''opération modulo'''<ref>
{{lien web|titre=Fonction modulo|url=https://www.ibm.com/docs/fr/wcici/7.5.1?topic=reference-modulo-function|site=IBM.com}}
</ref>{{,}}<ref>
{{ouvrage|auteur1=Brian W. Kernighan|auteur2=Denis M. Ritchie|titre=Le Langage C|sous-titre=Norme Ansi|éditeur=Dunod|année=2000|page=41 - Les opérateurs arithmétiques}}
</ref>, ou '''opération mod'''<ref>{{Ouvrage|auteur1=Ronald Graham|auteur2=Donald Knuth|auteur3=Oren Patashnik|traducteur=Alain Denise|titre=Mathématiques concrètes|sous-titre=Fondations pour l'informatique|lieu=Paris|éditeur=[[Vuibert]]|année=2003|numéro d'édition=2|pages totales=xiv+688|isbn=978-2-7117-4824-2}}, {{p.|88-89}}.</ref>, est une opération binaire qui associe, à deux [[entier naturel|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 [[Langage de programmation|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 [[Entier relatif|entiers relatifs]], voire aux [[nombre réel|nombres réels]]<ref name="portal.acm.org">{{article
 | nom = Boute| prénom = Raymond T.
 | titre = The Euclidean definition of the functions div and mod
 | journal = [[ACM Transactions on Programming Languages and Systems]] | volume = 1 | numéro = 2| pages = 127–144| éditeur = ACM Press (New York, NY, USA)
 | date = April 1992| url = http://portal.acm.org/citation.cfm?id=128862&coll=portal&dl=ACM
 | doi = 10.1145/128861.128862}}, p. 128-129.</ref>, mais alors les [[langage de programmation|langages de programmation]] peuvent diverger, en particulier ''a'' mod ''n'' n'est plus forcément positif ou nul<ref>{{harvsp|Graham|Knuth|Patashnik|2003|p=89}}, et note marginale p. 88.</ref>. 

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<ref>{{harvsp|Graham|Knuth|Patashnik|2003|p=88-89}}, pour l'opération binaire, {{p.|143}} pour la congruence. Les auteurs n'utilisent le terme ''modulo'' que pour la relation de congruence, mais nomment « mod » l'opération binaire.</ref>.

== Différentes définitions de la fonction modulo ==
L'opération mod associe à deux entiers naturels {{mvar|a}} et {{math|§=''b'' ≠ 0}} le ''reste'' de la [[division euclidienne]] de {{mvar|a}} par {{mvar|b}}, qui est l'unique entier {{mvar|r}} vérifiant :
* {{math|§=''a = b × q + r''}} pour un certain entier naturel {{mvar|q}} ;
* {{math|§=0 ≤ ''r'' < ''b''}}.

Par exemple : 
:{{math|§=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 ====
[[Fichier:Clock group.svg|vignette|Les opérations sur les horloges sont modulo 12. C'est un cas d'usage classique de l'opération modulo appliqué aux entiers naturels, en mathématique comme en informatique.]]
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{{'}}<sub>i</sub>'' = ((''u<sub>i</sub>'' + ''p'' − 1) mod ''n'') + 1.
Par exemple, pour décaler de deux la suite (1, 2, 3, 4, 5) :
: ''u{{'}}<sub>i</sub>'' = ((''u<sub>i</sub>'' + 1) mod 5) + 1 ;
on a bien :
* ''u{{'}}''<sub>1</sub> = ((1 + 1) mod 5) + 1 = 3
* ''u{{'}}''<sub>2</sub> = ((2 + 1) mod 5) + 1 = 4
*…
* ''u{{'}}''<sub>4</sub> = ((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 ===
[[Fichier:Divmod Euclidean.svg|vignette|253x253px|Représentations graphiques des fonctions «reste» (en vert ) et «quotient»  (en rouge)  dans la division euclidienne par un entier n, à gauche pour un entier n positif et à droite pour un entier n négatif.Le reste de la division euclidienne reste positif dans tous les cas.]]
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 ==

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

{{article connexe|Partie entière et partie fractionnaire}}
[[Fichier:Divmod floored.svg|vignette|253x253px|Évolution du quotient et du reste (résultat du modulo) en fonction des éléments a et b et du signe du diviseur dans le cas où on utilise la définition utilisant la partie entière. ]]
Soit la notation <math>\lfloor x \rfloor</math> définissant le plus grand entier inférieur ou égal à ''x''.

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

: <math>a \bmod n = a - \left\lfloor \frac{a}{n} \right\rfloor \times n</math>

L'opérateur ''mod'' retourne 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 <u>puisque le modulo peut alors être négatif quand le quotient est négatif.</u>

Exemple :

{| class="wikitable"  style="text-align:right"
! 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
|}

Cette définition vérifie les lois de l'[[arithmétique modulo]], plus :  ''x'' mod −''y'' = −((−''x'') mod ''y''). Elle convient pour les calculs cycliques. La valeur modulaire retourné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 ===
[[Fichier:Divmod truncated.svg|vignette|253x253px|Évolution du quotient et du reste (résultat du modulo) en fonction des éléments a et b et du signe du diviseur dans le cas où on utilise la définition utilisant la troncature. ]]
<math>\left[ x \right]</math> est la [[troncature]] entière de x.

: <math>a \bmod n = a - \left[ \frac{a}{n} \right] \times n</math>

L'opérateur ''mod'' retourne alors :

* un modulo positif inférieur à <math>\left| n \right|</math> pour ''a'' positif.
* un modulo négatif supérieur à <math>-\left| n \right|</math> pour ''a'' négatif.

Exemple :

{| class="wikitable" style="text-align:right"
! Dividende !! Diviseur !! Quotient !! Reste
|-
| 117 || 17 || 6 || 15
|-
| −117 || 17 || −6 || −15
|-
| −117 || −17 || 6 || −15
|-
| 117 || −17 || −6 || 15
|}

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 ===
[[Fichier:Divmod rounding.svg|vignette|254x254px|Évolution du quotient et du reste (résultat du modulo) en fonction des éléments a et b et du signe du diviseur dans le cas où on utilise la définition utilisant l'arrondi. ]]
On peut également utiliser l'arrondi en définissant le quotient tel que : 

<math>q=arrondi(\frac{a}{b})</math>

Où « arrondi » est la fonction [[Arrondi (mathématiques)|arrondi]].

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

<math>r = a - n \times arrondi(\frac{a}{b})</math>

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

=== Définition utilisant la partie entière supérieure ===
[[Fichier:Divmod ceiling.svg|vignette|253x253px|Évolution du quotient et du reste (résultat du modulo) en fonction des éléments a et b et du signe du diviseur dans le cas où on utilise la définition utilisant l'arrondi. ]]
Soit la notation <math>\left \lceil x \right \rceil </math> définissant le plus petit entier supérieur ou égal à ''x''.

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

<math>q = \left\lceil \frac{a}{n} \right\rceil</math> 

Et la définition du modulo tel que : 

<math>a \bmod n = a - \left\lceil \frac{a}{n} \right\rceil \times n</math> 

Le comportement est proche de celui de la [[Partie entière et partie fractionnaire|partie entière]] inférieure.

Ce comportement est également trouvé en LISP.

=== Comparaison sous forme de tableau ===
{{...}}

{| class="wikitable" style="text-align: right;"
|+ comparaison des opérateurs Modulo
! colspan=2 | !! colspan=2 style="text-align: center;" |partie entière !! colspan="2" style="text-align: center;" |troncature 
! colspan="2" |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
|}

== 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 [[Nombre rationnel|nombres rationnels]] (ou [[Nombre réel|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 <code>mod</code> ou <code>%</code> 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 [[Conversion de type|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 ==
{| class="wikitable sortable"
|+ Tableau récapitulatif des différents opérateurs et de leur définition en fonction du langage informatique
|-
! scope="col" | [[Langage_de_programmation|Langage]]
! scope="col" | Opérateur
! scope="col" | Prend en charge les entiers ?
! scope="col" | Prise en charge nombres flottants ?
! abbr="Sign" scope="col" | Définition utilisée

|-
| [[ABAP]]
| {{code|MOD}}
| {{yes}}
| {{yes}}
| Euclidienne

|-
| [[ActionScript]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[Ada (langage)]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)<ref name="Ada">{{article|titre=ISO/IEC 8652:2012 - Information technology — Programming languages — Ada|périodique=[[International Organization for Standardization|ISO]], [[International Electrotechnical Commission|IEC]]|année=2012|passage=sec. 4.5.5 Multiplying Operators}}</ref>
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature<ref name="Ada" />

|-
| [[ALGOL 68]]
| {{code|÷×}}, {{code|mod}}
| {{yes}}
| {{no}}
| Euclidienne

|-
| [[AMPL]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[APL (langage)|APL]]
| <code><nowiki>|</nowiki></code>{{efn|name=rev|Argument order reverses, i.e., <code><nowiki>α|ω</nowiki></code> computes <math>\omega\bmod\alpha</math>, the remainder when dividing {{code|ω}} by {{code|α}}.}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)

|-
| [[AppleScript]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Troncature

|-
| AutoLISP de [[AutoCAD]]
| {{code|(rem d n)}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Awk|AWK]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Bourne-Again shell|bash]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[BASIC]]
| {{code|Mod}}
| {{yes}}
| {{no}}
| Dépend de l'implémentation

|-
| [[bc (programming language)|bc]] (voir [[bc (Unix)]])
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="3" | [[C (langage)|C]]<ref name="ref_auto_1">Depuis ISO C99. En ISO C90, en cas d'opérande négatif, le signe du résultat était défini par l'implémentation.</ref>{{break}}[[C++]]
| {{code|%}}, {{code|div}}
| {{yes}}
| {{no}}
| Troncature{{efn|name=c|[[C99 (standard)|C99]] and [[C++11]] define the behavior of {{code|%}} to be Troncature<ref name="C99">{{lien web|titre=C99 specification (ISO/IEC 9899:TC2) |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf |consulté le=16 août 2018 |passage=sec. 6.5.5 Multiplicative operators |date=2005-05-06}}</ref>. The standards before then leave the behavior implementation-defined<ref>{{article|année=2003|titre=ISO/IEC 14882:2003: Programming languages – C++|périodique=[[International Organization for Standardization]] (ISO), [[International Electrotechnical Commission]] (IEC)|passage=sec. 5.6.4|extrait=the binary % operator yields the remainder from the division of the first expression by the second. .... If both operands are nonnegative then the remainder is nonnegative; if not, the sign of the remainder is implementation-defined}}</ref>.}}
|-
| {{code|fmod}} (C){{break}}{{code|std::fmod}} (C++)
| {{no}}
| {{yes}}
| Troncature<ref>{{article|titre=ISO/IEC 9899:1990: Programming languages – C |périodique=[[International Organization for Standardization|ISO]], [[International Electrotechnical Commission|IEC]] |année=1990 |passage=sec. 7.5.6.4 |extrait=The {{math|fmod}} function returns the value {{math|x - i * y}}, for some integer {{math|i}} such that, if {{math|y}} is nonzero, the result has the same sign as {{math|x}} and magnitude less than the magnitude of {{math|y}}.}}</ref>
|-
| {{code|remainder}} (C){{break}}{{code|std::remainder}} (C++)
| {{no}}
| {{yes}}
| Arrondi

|-
| rowspan="2" | [[C Sharp (programming language)|C#]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature
|-
| {{code|Math.IEEERemainder}}
| {{no}}
| {{yes}}
| Arrondi<ref name=".NET">{{lien web|nom=dotnet-bot |titre=Math.IEEERemainder(Double, Double) Method (System) |url=https://learn.microsoft.com/en-us/dotnet/api/system.math.ieeeremainder?view=net-7.0 |consulté le=2022-10-04 |langue=en-us}}</ref>

|-
| [[Clarion (langage)]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| {{Lien|trad=Clean (programming language)|fr=Clean (langage)}}
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[Clojure]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)<ref>{{lien web|titre=clojure.core - Clojure v1.10.3 API documentation |url=https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/mod |consulté le=2022-03-16 }}</ref>
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|titre=clojure.core - Clojure v1.10.3 API documentation |url=https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/rem |consulté le=2022-03-16 |website=clojure.github.io}}</ref>

|-
| rowspan="2" | [[COBOL]]
| {{code|FUNCTION MOD}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)<ref name="isocobol">{{ouvrage|titre=ISO/IEC 1989:2023 – Programming language COBOL|auteur=ISO/IEC JTC 1/SC 22/WG 4|éditeur=[[ISO]]|date=January 2023|url=https://www.iso.org/standard/74527.html|accès url=payant}}</ref>
|-
| {{code|FUNCTION REM}}
| {{yes}}
| {{yes}}
| Troncature<ref name="isocobol"/>

|-
| rowspan="2" | [[CoffeeScript]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature
|-
| {{code|%%}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)<ref name="CoffeeScript">[http://coffeescript.org/#operators CoffeeScript operators]</ref>

|-
| [[ColdFusion]]
| {{code|%}}, {{code|MOD}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[Common Intermediate Language]]
| {{code|rem}} (signed)
| {{yes}}
| {{yes}}
| Troncature<ref>{{ouvrage|nom=ISO/IEC JTC 1/SC 22|date=February 2012|titre=ISO/IEC 23271:2012 — Information technology — Common Language Infrastructure (CLI)|url=https://www.iso.org/standard/58046.html|éditeur=[[ISO]]|passage=§§ III.3.55–56}}</ref>
|-
| {{code|rem.un}} (unsigned)
| {{yes}}
| {{no}}
| {{N/A}}

|-
| rowspan="2" | [[Common Lisp]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)
|-
| {{code|rem}}
| {{yes}}
| {{yes}}
| Troncature

|-
| rowspan="2" | [[Crystal (langage de programmation)]]
| {{code|%}}, {{code|modulo}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)
|-
| {{code|remainder}}
| {{yes}}
| {{yes}}
| Troncature

|-
| [[D (langage)]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature<ref>{{lien web|titre=Expressions - D Programming Language|url=https://dlang.org/spec/expression.html#mul_expressions|consulté le=2021-06-01|website=dlang.org}}</ref>

|-
| rowspan="2" | [[Dart (langage)]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Euclidienne<ref>{{lien web|titre=operator % method - num class - dart:core library - Dart API|url=https://api.dart.dev/stable/2.13.1/dart-core/num/operator_modulo.html|consulté le=2021-06-01|website=api.dart.dev}}</ref>
|-
| {{code|remainder()}}
| {{yes}}
| {{yes}}
| Troncature<ref>{{lien web|titre=remainder method - num class - dart:core library - Dart API|url=https://api.dart.dev/stable/2.13.1/dart-core/num/remainder.html|consulté le=2021-06-01|website=api.dart.dev}}</ref>

|-
| [[Eiffel (langage)]]
| {{code|\\}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[Elixir (langage)]]
| {{code|rem/2}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|titre=Kernel — Elixir v1.11.3|url=https://hexdocs.pm/elixir/Kernel.html#rem/2|consulté le=2021-01-28|website=hexdocs.pm}}</ref>
|-
| {{code|Integer.mod/2}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)<ref>{{lien web|titre=Integer — Elixir v1.11.3|url=https://hexdocs.pm/elixir/Integer.html#mod/2|consulté le=2021-01-28|website=hexdocs.pm}}</ref>

|-
| rowspan="2" | [[Elm (langage)]]
| {{code|modBy}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)<ref>{{lien web|titre=Basics - core 1.0.5 |url=https://package.elm-lang.org/packages/elm/core/latest/Basics#modBy |consulté le=2022-03-16 |website=package.elm-lang.org}}</ref>
|-
| {{code|remainderBy}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|titre=Basics - core 1.0.5 |url=https://package.elm-lang.org/packages/elm/core/latest/Basics#remainderBy |consulté le=2022-03-16 |website=package.elm-lang.org}}</ref>

|-
| rowspan="2" | [[Erlang (langage)]]
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature
|-
| {{code|math:fmod/2}}
| {{no}}
| {{yes}}
| Troncature (identique au C)<ref>{{lien web|titre=Erlang -- math|url=https://erlang.org/doc/man/math.html#fmod-2|consulté le=2021-06-01|website=erlang.org}}</ref>

|-
| rowspan="2" | [[Euphoria (langage)]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[F Sharp|F#]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature
|-
| {{code|Math.IEEERemainder}}
| {{no}}
| {{yes}}
| Arrondi<ref name=".NET" />

|-
| [[Factor]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[FileMaker]]
| {{code|Mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="3" | [[Forth (langage)]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Dépend de l'implémentation
|-
| {{code|fm/mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|sm/rem}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[Fortran]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| Troncature
|-
| {{code|modulo}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)

|-
| {{Lien|trad=Frink (programming language)|fr=Frink (langage)}}
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="2" |  ({{Lien|trad=Full BASIC|fr=Full BASIC|texte=Full BASIC}}) (standard [[American National Standards Institute|ANSI]])
| {{code|MOD}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)<ref>{{ouvrage|nom=[[ANSI]]|titre=Programming Languages — Full BASIC|url=https://archive.org/details/federalinformat6821nati_0|date=28 January 1987|éditeur=American National Standards Institute|lieu=New York|passage=§ 5.4.4|extrait=X modulo Y, i.e., X-Y*INT(X/Y).}}</ref>
|-
| {{code|REMAINDER}}
| {{yes}}
| {{yes}}
| Troncature<ref>{{ouvrage|nom=[[ANSI]]|titre=Programming Languages — Full BASIC|url=https://archive.org/details/federalinformat6821nati_0|date=28 January 1987|éditeur=American National Standards Institute|lieu=New York|passage=§ 5.4.4|extrait="The remainder function, i.e., X-Y*IP(X/Y)."}}</ref>

|-
| rowspan="2" | [[GLSL]]
| {{code|%}}
| {{yes}}
| {{no}}
| Non défini<ref>{{lien web|url=https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.50.pdf|titre=GLSL Language Specification, Version 4.50.7|passage=section 5.9 Expressions|extrait=If both operands are non-negative, then the remainder is non-negative. Results are undefined if one or both operands are negative.}}</ref>
|-
| {{code|mod}}
| {{no}}
| {{yes}}
| Partie entière (inférieure)<ref>{{lien web|url=https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.50.pdf|titre=GLSL Language Specification, Version 4.50.7|passage=section 8.3 Common Functions}}</ref>

|-
| [[GameMaker]] Studio (GML)
| {{code|mod}}, {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="4" | [[Godot (moteur de jeu)|GDScript (Godot)]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature
|-
| {{code|fmod}}
| {{no}}
| {{yes}}
| Troncature
|-
| {{code|posmod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|fposmod}}
| {{no}}
| {{yes}}
| Partie entière (inférieure)

|-
| rowspan="3" | [[Go (langage)]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|titre=The Go Programming Language Specification - The Go Programming Language |url=https://go.dev/ref/spec#Integer_operators |consulté le=2022-02-28 |website=go.dev}}</ref>
|-
| {{code|math.Mod}}
| {{no}}
| {{yes}}
| Troncature<ref>{{lien web|titre=math package - math - pkg.go.dev |url=https://pkg.go.dev/math#Mod |consulté le=2022-02-28 |website=pkg.go.dev}}</ref>
|-
| {{code|big.Int.Mod}}
| {{yes}}
| {{no}}
| Euclidienne<ref>{{lien web|titre=big package - math/big - pkg.go.dev |url=https://pkg.go.dev/math/big#Int.Mod |consulté le=2022-02-28 |website=pkg.go.dev}}</ref>

|-
| [[Groovy (langage)]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="3" | [[Haskell]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)<ref name="Haskell 2010">{{lien web|titre=6 Predefined Types and Classes |url=https://www.haskell.org/onlinereport/haskell2010/haskellch6.html#x13-1370006.4.2 |consulté le=2022-05-22 |website=www.haskell.org}}</ref>
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature<ref name="Haskell 2010" />
|-
| {{code|Data.Fixed.mod'}} ([[Glasgow Haskell Compiler|GHC]])
| {{no}}
| {{yes}}
| Partie entière (inférieure)

|-
| [[Haxe]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[HLSL]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Non défini<ref>{{lien web|url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-operators#additive-and-multiplicative-operators |titre=Operators |auteur=<!--Not stated--> |éditeur=[[Microsoft]] |consulté le=2021-07-19 |extrait=The % operator is defined only in cases where either both sides are positive or both sides are negative. Unlike C, it also operates on floating-point data types, as well as integers.}}</ref>

|-
| [[J (langage)]]
| <code><nowiki>|</nowiki></code>{{efn|name=rev}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="2" | [[Java (langage)]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature
|-
| {{code|Math.floorMod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| [[JavaScript]]{{break}}[[TypeScript]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature

|-
| rowspan="2" | [[Julia (langage)]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)<ref>{{lien web|titre=Mathematics · The Julia Language|url=https://docs.julialang.org/en/v1/base/math/#Base.mod|consulté le=2021-11-20|website=docs.julialang.org}}</ref>
|-
| {{code|%}}, {{code|rem}}
| {{yes}}
| {{yes}}
| Troncature<ref>{{lien web|titre=Mathematics · The Julia Language|url=https://docs.julialang.org/en/v1/base/math/#Base.rem|consulté le=2021-11-20|website=docs.julialang.org}}</ref>

|-
| rowspan="2" | [[Kotlin (langage)]]
| {{code|%}}, {{code|rem}}
| {{yes}}
| {{yes}}
| Troncature<ref>{{lien web|titre=rem - Kotlin Programming Language|url=https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/rem.html|consulté le=2021-05-05|website=Kotlin|langue=en}}</ref>
|-
| {{code|mod}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)<ref>{{lien web|titre=mod - Kotlin Programming Language|url=https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/mod.html|consulté le=2021-05-05|website=Kotlin|langue=en}}</ref>

|-
| rowspan="2" | [[Korn shell|ksh]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature (identique à POSIX sh)
|-
| {{code|fmod}}
| {{no}}
| {{yes}}
| Troncature

|-
| [[LabVIEW]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| Troncature

|-
| [[LibreOffice]]
| {{code|1==MOD()}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="2" | [[Logo (langage)]]
| {{code|MODULO}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|REMAINDER}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Lua (langage)]] 5
| {{code|%}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)

|-
| [[Lua (langage)]] 4
| {{code|mod(x,y)}}
| {{yes}}
| {{yes}}
| Troncature

|-
| ({{Lien|trad=Liberty BASIC|fr=Liberty BASIC|texte=Liberty BASIC}})
| {{code|MOD}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Mathcad]]
| {{code|mod(x,y)}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="3" | [[Maple]]
| {{code|e mod m}} (by default), {{code|modp(e, m)}}
| {{yes}}
| {{no}}
| Euclidienne
|-
| {{code|mods(e, m)}}
| {{yes}}
| {{no}}
| Arrondie
|-
| {{code|frem(e, m)}}
| {{yes}}
| {{yes}}
| Arrondie

|-
| [[Mathematica]]
| {{code|Mod[a, b]}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="2" | [[MATLAB]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[Maxima (logiciel)]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Maya Embedded Language]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Microsoft Excel]]
| {{code|1==MOD()}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)

|-
| [[Minitab]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="2" | [[Modula-2]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|REM}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[MUMPS]]
| {{code|#}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="2" | [[Netwide Assembler]] ([[Netwide Assembler|NASM]], [[Netwide Assembler|NASMX]])
| {{code|%}}, {{code|div}} (unsigned)
| {{yes}}
| {{no}}
| {{N/A}}
|-
| {{code|%%}} (signed)
| {{yes}}
| {{no}}
| Dépends de l'implémentation<ref>{{lien web|titre=Chapter 3: The NASM Language |url=https://nasm.us/doc/nasmdoc3.html#section-3.5.11 |website=NASM - The Netwide Assembler version 2.15.05}}</ref>

|-
| [[Nim (langage)]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Oberon (langage)]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| Proche de Partie entière (inférieure){{efn|Divisor must be positive, otherwise undefined.}}

|-
| [[Objective-C]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature (identique à C99)

|-
| [[Object Pascal]], [[Delphi (langage)]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[OCaml]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|titre=OCaml library : Stdlib|url=https://ocaml.org/releases/4.13/api/Stdlib.html#VAL(mod)|consulté le=2022-02-19|website=ocaml.org}}</ref>
|-
| {{code|mod_float}}
| {{no}}
| {{yes}}
| Troncature<ref>{{lien web|titre=OCaml library : Stdlib|url=https://ocaml.org/releases/4.13/api/Stdlib.html#VALmod_float|consulté le=2022-02-19|website=ocaml.org}}</ref>

|-
| [[Occam (langage)]]
| {{code|\}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Pascal (langage)]] (ISO-7185 and -10206)
| {{code|mod}}
| {{yes}}
| {{no}}
| Proche de l'Euclidienne{{efn|1=As discussed by Boute, ISO [[Pascal (langage)]]'s definitions of {{code|div}} and {{code|mod}} do not obey the Division Identity of {{math|1=''D'' = ''d'' · (''D'' / ''d'') + ''D'' % ''d''}}, and are thus fundamentally broken.}}

|-
| rowspan="2" | [[Perl (langage)]]
| {{code|%}}
| {{yes}}
| {{no}}
| Partie entière (inférieure){{efn|[[Perl (langage)]] usually uses arithmetic modulo operator that is machine-independent. For examples and exceptions, see the Perl documentation on multiplicative operators<ref>[http://perldoc.perl.org/perlop.html#Multiplicative-Operators Perl documentation]</ref>.}}
|-
| {{code|POSIX::fmod}}
| {{no}}
| {{yes}}
| Troncature

|-
| rowspan="2" | [[Phix]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[PHP]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|titre=PHP: Arithmetic Operators - Manual|url=https://www.php.net/manual/en/language.operators.arithmetic.php|consulté le=2021-11-20|website=www.php.net}}</ref>
|-
| {{code|fmod}}
| {{no}}
| {{yes}}
| Troncature<ref>{{lien web|titre=PHP: fmod - Manual|url=https://www.php.net/manual/en/function.fmod.php|consulté le=2021-11-20|website=www.php.net}}</ref>

|-
| PIC [[BASIC]] Pro
| {{code|\\}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[PL/I]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure) (ANSI PL/I)

|-
| [[PowerShell]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| Programming Code ([[PRC (Palm OS)|PRC]])
| {{code|MATH.OP - 'MOD; (\)'}}
| {{yes}}
| {{no}}
| Undefined

|-
| [[OpenEdge Advanced Business Language|Progress]] ([[Progress Software]])
| {{code|modulo}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2"| [[Prolog]] ([https://www.iso.org/standard/21413.html ISO 1995])
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[PureBasic]]
| {{code|%}}, {{code|Mod(x,y)}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[PureScript]]
| {{code|`mod`}}
| {{yes}}
| {{no}}
| Euclidean<ref name="purescript_euclid">{{lien web|url=https://pursuit.purescript.org/packages/purescript-prelude/5.0.1/docs/Data.EuclideanRing#t:EuclideanRing|titre = EuclideanRing}}</ref>

|-
| rowspan="2" | [[Pure Data]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature (same as C)
|-
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| rowspan="2" | [[Python (programming language)|Python]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)
|-
| {{code|math.fmod}}
| {{no}}
| {{yes}}
| Troncature

|-
| [[Q Sharp|Q#]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|url=https://docs.microsoft.com/en-us/quantum/quantum-qr-expressions?view=qsharp-preview#numeric-expressions|titre=Expressions|nom=QuantumWriter|website=docs.microsoft.com|langue=en-us|consulté le=2018-07-11}}</ref>

|-
| [[R (langage)]]
| {{code|%%}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)<ref>{{lien web|titre=R: Arithmetic Operators |url=https://search.r-project.org/R/refmans/base/html/Arithmetic.html |consulté le=2022-12-24 |website=search.r-project.org}}</ref>

|-
| rowspan="2" |[[Racket (langage)|Racket]]
| {{code|modulo}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Raku (langage)|Raku]]
| {{code|%}}
| {{no}}
| {{yes}}
| Partie entière (inférieure)

|-
| [[RealBasic]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Reason (langage)|Reason]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Rexx]]
| {{code|//}}
| {{yes}}
| {{yes}}
| Troncature

|-
| [[RPG (programming language)|RPG]]
| {{code|%REM}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[Ruby]]
| {{code|%}}, {{code|modulo()}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)
|-
| {{code|remainder()}}
| {{yes}}
| {{yes}}
| Troncature

|-
| rowspan="2" | [[Rust (langage)|Rust]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature
|-
| {{code|rem_euclid()}}
| {{yes}}
| {{yes}}
| Euclidienne<ref name="rust_rem_euclid">{{lien web|url=https://doc.rust-lang.org/std/primitive.f32.html#method.rem_euclid|titre = F32 - Rust}}</ref>

|-
| [[SAS (langage)|SAS]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Scala (langage)|Scala]]
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature

|-
| rowspan="2" | [[Scheme]]
| {{code|modulo}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="4" | [[Scheme#RnRS|Scheme R<sup>6</sup>RS]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Euclidienne<ref name="r6rs">[http://www.r6rs.org/final/html/r6rs/r6rs-Z-H-14.html#node_sec_11.7.3.1 r6rs.org]</ref>
|-
| {{code|mod0}}
| {{yes}}
| {{no}}
| Arrondie<ref name="r6rs"/>
|-
| {{code|flmod}}
| {{no}}
| {{yes}}
| Euclidienne
|-
| {{code|flmod0}}
| {{no}}
| {{yes}}
| Arrondie

|-
| [[Scratch (langage)|Scratch]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)

|-
| rowspan="2" | {{Lien|trad=Seed7|fr=Seed7}}
| {{code|mod}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)
|-
| {{code|rem}}
| {{yes}}
| {{yes}}
| Troncature

|-
| rowspan="2" | {{Lien|trad=SenseTalk|fr=SenseTalk}}
| {{code|modulo}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[POSIX shell|{{Code|sh}} (POSIX)]] (includes [[Bourne-Again shell|bash]], [[mksh]], &c.)
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature (same as C)<ref>{{lien web|titre=Shell Command Language|url=https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_04|consulté le=2021-02-05|website=pubs.opengroup.org}}</ref>

|-
| rowspan="2" | [[Smalltalk]]
| {{code|\\}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|rem:}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Snap! (langage)|Snap!]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| {{Lien|trad=Parallax_Propeller#Built_in_Spin_bytecode_interpreter|fr=Parallax_Propeller|texte=Spin}}
| {{code|//}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| [[Solidity]]
| {{code|%}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| [[SQL]] ([[SQL:1999]])
| {{code|mod(x,y)}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[SQL]] ([[SQL:2011]])
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="3" | [[Standard ML]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|Int.rem}}
| {{yes}}
| {{no}}
| Troncature
|-
| {{code|Real.rem}}
| {{no}}
| {{yes}}
| Troncature

|-
| [[Stata]]
| {{code|mod(x,y)}}
| {{yes}}
| {{no}}
| Euclidienne

|-
| rowspan="3" | [[Swift (langage d'Apple)|Swift]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature<ref>{{lien web|titre=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/binaryinteger/2885003|consulté le=2021-11-20|website=developer.apple.com}}</ref>
|-
| {{code|remainder(dividingBy:)}}
| {{no}}
| {{yes}}
| Arrondie<ref>{{lien web|titre=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/floatingpoint/3017981-remainder|consulté le=2021-11-20|website=developer.apple.com}}</ref>
|-
| {{code|truncatingRemainder(dividingBy:)}}
| {{no}}
| {{yes}}
| Troncature<ref>{{lien web|titre=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/floatingpoint/3017995-truncatingremainder|consulté le=2021-11-20|website=developer.apple.com}}</ref>

|-
| rowspan="2" | [[Tool Command Language|Tcl]]
| {{code|%}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|fmod()}}
| {{no}}
| {{yes}}
| Troncature (as C)

|-
| [[tcsh]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Torque 3D|Torque]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| {{Lien|trad=Turing (programming language)|fr=Turing (langage)}}
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)

|-
| [[Verilog]] (2001)
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[VHDL]]
| {{code|mod}}
| {{yes}}
| {{no}}
| Partie entière (inférieure)
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Vim script|VimL]]
| {{code|%}}
| {{yes}}
| {{no}}
| Troncature

|-
| [[Visual Basic .NET|Visual Basic]]
| {{code|Mod}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | [[WebAssembly]]
| {{code|i32.rem_u}}, {{code|i64.rem_u}} (unsigned)
| {{yes}}
| {{no}}
| {{N/A}}<ref name="wasmcs2">{{lien web|editeur=Andreas Rossberg|date=19 April 2022|titre=WebAssembly Core Specification: Version 2.0|url=https://www.w3.org/TR/wasm-core-2/|éditeur=[[World Wide Web Consortium]]|passage=§ 4.3.2 Integer Operations}}</ref>
|-
| {{code|i32.rem_s}}, {{code|i64.rem_s}} (signed)
| {{yes}}
| {{no}}
| Troncature<ref name="wasmcs2" />

|-
| {{Lien|trad=x86 assembly language|fr=Langage Assembleur x86|texte=Assembleur x86}}
| {{code|IDIV}}
| {{yes}}
| {{no}}
| Troncature

|-
| rowspan="2" | {{Lien|trad=XBase++|fr=XBase++}}
| {{code|%}}
| {{yes}}
| {{yes}}
| Troncature
|-
| {{code|Mod()}}
| {{yes}}
| {{yes}}
| Partie entière (inférieure)

|-
| [[Zig (langage)|Zig]]
| {{code|%}},
{{code|@mod}}, {{code|@rem}}
| {{yes}}
| {{yes}}
| Troncature<ref>{{lien web|titre=Zig Documentation |url=https://ziglang.org/documentation/0.10.0/#Table-of-Operators |consulté le=2022-12-18 |website=Zig Programming Language}}</ref>

|-
| {{Lien|trad=Z3 Theorem Prover|fr=Z3 Theorem Prover}}
| {{code|div}}, {{code|mod}}
| {{yes}}
| {{no}}
| Euclidienne
|}

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

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

{{citation bloc|1=si une horloge indique 10 heures, qu'indiquait-elle 200 heures avant ? <code>-190 % 12 == 2</code> est utile ; <code>-190 % 12 == -10</code> est un bug prêt à mordre<ref>[http://docs.python.org/2/faq/programming.html#why-does-22-10-return-3 "Why does -22 // 10 return -3?"]</ref>.}}

=== Quelques détails concernant certains langages suivants la définition utilisant la troncature ===
* [[Free Pascal]] et [[Embarcadero Delphi|Delphi]] n'autorisent que des opérandes entiers, et la définition du langage<ref>{{lien web|url=http://www.freepascal.org/docs-html/ref/ref.html|titre=Reference guide for Free Pascal, version 2.6.0|date=décembre 2011|auteur=Michaël Van Canneyt|langue=en}}.</ref> précise : « Le signe du résultat est le signe de l'opérande gauche » ;
* [[C (langage)|C]]<ref name="ref_auto_1" />, [[C++]] : <code>a % n</code> demande des opérandes entiers ;
* [[PHP (langage)|PHP]] : <code>$a % $n</code> est défini sur les entiers et retournera un résultat ayant le même signe que <code>$a</code> ;
* [[Scilab]] : <code>modulo(a, n)</code> 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 ==
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é:
**<math>(a\,\bmod\,n)\,\bmod\,n = a\,\bmod\,n</math>
**<math>n^x\,\bmod\,n = 0</math> pour tous les entiers strictement positifs <math>x</math>.
** Si <math>n</math> est un [[nombre premier]] qui n'est pas un [[diviseur]] de <math>b</math>, alors <math>ab^{n-1}\,\bmod\,n = a\,\bmod\,n</math>, d'après le [[petit théorème de Fermat]].
*Inverse:
**<math>((-a\,\bmod\,n) + (a\,\bmod\,n))\,\bmod\,n =0</math>
**<math>b^{-1}\,\bmod\,n</math> est l'[[inverse modulaire]], qui est défini si et seulement si <math>b</math> et <math>n</math> sont [[Nombres premiers entre eux|premiers entre eux]], ce qui est le cas quand la partie gauche est définie: <math>((b^{-1}\,\bmod\,n) \, (b\,\bmod\,n))\,\bmod\,n =1</math>.
*[[Distributivité]]:
**<math>(a+b)\,\bmod\,n = ((a\,\bmod\,n)+(b\,\bmod\,n))\,\bmod\,n</math>
**<math>ab\,\bmod\,n = ((a\,\bmod\,n)\,(b\,\bmod\,n))\,\bmod\,n</math>
**D’où : <math>a^2\,\bmod\, n=(a\,\bmod\, n)^2\,\bmod \,n</math>
*Division (définition): <math>\frac{a}{b}\,\bmod\,n = ((a\,\bmod\,n)(b^{-1}\,\bmod\,n))\,\bmod\,n</math>, quand l'opérande de gauche est défini. Non définie sinon.
*Multiplication inverse: <math>((ab\,\bmod\,n)\,(b^{-1}\,\bmod\,n))\,\bmod\,n = a\,\bmod\,n</math>

== Notes et références ==
=== Notes ===
<references group="note"/>
=== Références ===
{{Références}}

{{Portail|informatique}}

{{DEFAULTSORT:Modulo}}
[[Catégorie:Programmation informatique]]
[[Catégorie:Arithmétique]]