查看“︁模除”︁的源代码

{{About|计算除法余数的二元运算|有关概念在[[数论]]中的应用|模算數|其他应用|模 (消歧义)}}
[[Image:Divmod.svg| thumb| right| 250px| {{colorbox|red}} [[商數]] (<math>q</math>) 和 {{colorbox|lightgreen}} [[餘數]] (<math>r</math>) 作為[[被除數]] (<math>a</math>) 的函數時的圖像。左侧是[[除数]]为正的情况，右侧[[除数]]为负。从上至下分别使用了：向零取整、向下取整和[[欧几里得除法]]。]]
'''模除'''（{{lang-en|modulo}} 有时也称作 modulus），又稱'''模数'''、'''取模'''、'''取模運算'''等，它得出一个数除以另一个数的余数。给定两个正数：[[被除数]]<math>a</math>和[[除数]]<math>n</math>，<math>a \,\operatorname{modulo}\, n</math>（通常缩写为<math>a \bmod n</math>），得到的是使用[[欧几里得除法]]时的[[余数]]。<math>a \bmod 1</math>所得之数被称为<math>a</math>的[[小数]]部份。

举个例子：计算表达式<math>5\bmod 2</math>得到<math>1</math>，因为<math>5\div 2</math>的商为<math>2</math>而余数为<math>1</math>；而<math>9\bmod 3</math>得到<math>0</math>，因为<math>9\div 3</math>的商为<math>3</math>而余数为<math>0</math>；做除法不能[[整除]]时得到是[[有理数]]，平常使用的计算器采用了[[有限]]个[[数位 (数学)|数位]]的[[十进制]]表示法，它以[[小数点]]分隔[[整数]]部份和[[小数]]部份，比如<math>5\div 2=2.5</math>。

虽然通常情况下模除的被除数<math>a</math>和除数<math>n</math>都是整数，但许多计算系统允许其他类型的数值运算，比如对[[浮点数]]取模。在所有计算系统中当被除数<math>a</math>和除数<math>n</math>都是正数时，结果的余数<math>r</math>的范围为<math>0 \le r < n</math>；而<math>a \bmod 0</math>经常是未定义的，在编程语言里可能会导致[[除以零]]错误。当被除数<math>a</math>或除数<math>n</math>为负数时，不同的编程语言对结果有不同的处理。

== 各种定义 ==

在数学中，取模运算的结果就是[[欧几里德除法]]的[[余数]]。当然也有许多其他的定义方式。计算机和计算器有许多种表示和储存数字的方法，因此在不同的硬件环境下、不同的编程语言中，取模运算有着不同的定义。

几乎所有的计算系统中，<math>a</math>除以<math>n</math>得到商<math>q</math>和余数<math>r</math>均满足以下式子：
{{NumBlk
| ::
| <math>
\begin{align}
&q \in \mathbb{Z} \\
&a = n q + r \\
&|r| < |n|
\end{align}
</math>
| {{EquationRef|1}}
}}

即使如此，当[[余数]]非<math>0</math>时，余数的符号仍然是有歧义的：余数非<math>0</math>时，它的符号有两种选择，一个是正号而另一个是负号{{efn|从数学上讲，正和负只是满足不等式的无穷多个解中的两个。}}。通常情况下，在数论中总是选择正余数。但在编程中，选择余数的符号依赖于编程语言和被除数<math>a</math>或除数<math>n</math>的符号。在编程语言所定义的[[整数]]模除中，ISO/IEC标准[[Pascal_(程式語言)|Pascal]]<ref>{{cite web|title=ISO/IEC 7185, Information Technology—Programming Languages–Pascal. International Standard, 2nd ed.|publisher= ISO/IEC 7185, 1990 (E)|url=https://www.cs.utexas.edu/~novak/iso7185.pdf}}<br />
A term of the form <code>i div j</code> shall be an error if <code>j</code> is zero; otherwise, the value of <code>i div j</code> shall be such that<br />
:<code>abs(i) - abs(j) < abs((i div j) * j) <= abs(i)</code><br />
where the value shall be zero if <code>abs(i) < abs(j)</code>; otherwise, the sign of the value shall be positive if <code>i</code> and <code>j</code> have the same sign and negative if <code>i</code> and <code>j</code> have different signs.<br />
A term of the form <code>i mod j</code> shall be an error if <code>j</code> is zero or negative; otherwise, the value of <code>i mod j</code> shall be that value of <code>(i - (k * j))</code> for integral <code>k</code> such that <code>0 <= i mod j < j</code>.<br />
NOTE 2 — Only for <code>i >= 0</code> and <code>j > 0</code> does the relation <code>(i div j) * j + i mod j = i</code> hold.<br />
{{cite web|url=http://pascal.hansotten.com/uploads/books/Pascal_User_Manual_and_Report_Fourth_Edition.pdf|title=PASCAL User Manual and Report － ISO Pascal Standard|author=Kathleen Jensen, Niklaus Wirth|year=1991}}<br />
{|
|- style="vertical-align:top"
|<code>div</code><tt>&nbsp;&nbsp;</tt>||divide and truncate (i.e., value is not rounded)
|- style="vertical-align:top"
|<code>mod</code><tt>&nbsp;&nbsp;</tt>||modulus: let <code>Remainder = A - (A div B) * B</code>;<br /><tt>&nbsp;&nbsp;</tt>if <code>Remainder < 0</code> then <code>A mod B = Remainder + B</code><br />
<tt>&nbsp;&nbsp;</tt>otherwise <code>A mod B = Remainder</code>
|}
</ref>和[[ALGOL 68]]<ref>{{cite web|author=A. van Wijngaarden, B. J. Mailloux, J. E. L. Peck, C. H. A. Koster, M. Sintzoff, C. H. Lindsey, L. G. L.T. Meertens and R. G. Fisker|title=Revised Report on the Algorithmic Language Algol 68|publisher=IFIP W.G. 2.1|url=https://jmvdveer.home.xs4all.nl/en.post.algol-68-revised-report.html}}<br />10.2.3.3. Operations on integral operands<br />
……<br />
{|
|
 m) OP «÷, %, OVER» = ('''L''' INT a, b) '''L''' INT:
       IF b ≠ '''L''' 0
       THEN '''L''' INT q := '''L''' 0, r := ABS a;
          WHILE (r := r - ABS b) ≥ '''L''' 0 DO q := q + '''L''' 1 OD;
          (a < '''L''' 0 AND b > '''L''' 0 OR a ≥ '''L''' 0 AND b < '''L''' 0 | -q | q)
       FI;
 n) OP «÷×, ÷*, %*, MOD» = ('''L''' INT a, b) '''L''' INT:
       ('''L''' INT r = a - a ÷ b × b; r < 0 | r + ABS b | r);
|}</ref>，在计算出的余数<code>r</code>为负数时，返回正数<math>r + |n|</math>作为结果{{efn|ISO Pascal要求模除运算的除数<code>n</code>为正数。}}；另一些编程语言如ISO/IEC [[ANSI C#C90|C90]]，当被除数<math>a</math>或除数<math>n</math>是负数时，C90标准并没有做具体的规定，而是留给编译器去定义并实现<ref name="C-CPP-Std">{{Cite book|url=http://www.coding-guidelines.com/cbook/cbook1_2.pdf|title=The New C Standard: An Economic and Cultural Commentary|last=Jones|first=Derek M.|publisher=Addison-Wesley|year=2003|isbn=9780201709179|location=|pages=|language=en|archiveurl=https://web.archive.org/web/20180711080420/http://www.coding-guidelines.com/cbook/cbook1_2.pdf|archivedate=2018-07-11|access-date=2018-07-11}}<br />
C99 reflects almost universal processor behavior (as does the Fortran Standard). This definition truncates toward zero and the expression <code>(-(a/b) == (-a)/b) && (-(a/b) == a/(-b))</code> is always true. It also means that the absolute value of the result does not depend on the signs of the operands; for example:<br />
:<code>+10 / +3 == +3</code> <code>+10 % +3 == +1</code> <code>-10 / +3 == -3</code> <code>-10 % +3 == -1</code><br /><code>+10 / -3 == -3</code> <code>+10 % -3 == +1</code> <code>-10 / -3 == +3</code> <code>-10 % -3 == -1</code><br />
C90<br />
:When integers are divided and the division is inexact, if both operands are positive the result of the <code>/</code> operator is the largest integer less than the algebraic quotient and the result of the <code>%</code> operator is positive. If either operand is negative, whether the result of the <code>/</code> operator is the largest integer less than or equal to the algebraic quotient or the smallest integer greater than or equal to the algebraic quotient is implementation-defined, as is the sign of the result of the <code>%</code> operator. <br />
If either operand is negative, the behavior may differ between C90 and C99, depending on the implementation-defined behavior of the C90 implementation.<br />
:<syntaxhighlight lang="c">
#include <stdio.h>

int main(void)
{
int x = -1,
y = +3;
if ((x%y > 0) ||
    ((x+y)%y == x%y))
    printf("This is a C90 translator behaving differently than C99\n");
}
</syntaxhighlight>
Quoting from the C9X Revision Proposal, WG14/N613, that proposed this change:<br />
:The origin of this practice seems to have been a desire to map C’s division directly to the “natural” behavior of the target instruction set, whatever it may be, without requiring extra code overhead that might be necessary to check for special cases and enforce a particular behavior. However, the argument that Fortran programmers are unpleasantly surprised by this aspect of C and that there would be negligible impact on code efficiency was accepted by WG14, who agreed to require Fortran-like behavior in C99.
</ref>。在大多数系统中<math>a \bmod 0</math>是未定义的，虽然有些系统定义它就等于<math>a</math>。更多详情参见后续章节表格。

{{bulleted list
|很多取模的实现都使用了“截断除法”（{{lang-en|truncated division}}），商经由[[截尾函数]]来定义，商向零取整，结果等于普通除法所得的小数靠近<math>0</math>方向的第一个整数：
:<math>q=\operatorname{trunc} \left ( \frac{a}{n} \right )</math>
余数和被除数符号一致：
: <math>r = a - n \operatorname{trunc}\left(\frac{a}{n}\right)</math>
|[[高德纳]]定义的“下取整除法”（{{lang-en|floored division}}）<ref>{{cite book|first=Donald. E.|last=Knuth|title=The Art of Computer Programming|publisher=Addison-Wesley|year=1972|language=en}}<br />
If <math>x</math> is any real number, we write<br />
:<math>\left\lfloor x \right\rfloor</math> = the greatest integer less than or equal to <math>x</math> (the ''floor'' of <math>x</math>);<br />
:<math>\left\lceil x \right\rceil</math> = the least integer greater than or equal to <math>x</math> (the ''ceiling'' of <math>x</math>).<br />
……<br />
The following formulas and examples are easily verified:<br />
……<br />
:{|
|-
|<math>\left\lceil x \right\rceil = \left\lfloor x \right\rfloor</math> ||if and only if <math>x</math> is an integer,
|-
|<math>\left\lceil x \right\rceil = \left\lfloor x \right\rfloor + 1</math> || if and only if <math>x</math> is not an integer;
|-
|<math>\left\lfloor -x \right\rfloor = -\left\lceil x \right\rceil</math>;<tt>&nbsp;&nbsp;</tt>||<math>x - 1 < \left\lfloor x \right\rfloor \le x \le \left\lceil x \right\rceil < x + 1</math>.
|} 
……<br />
If <math>x</math> and <math>y</math> are any real numbers, we define the following binary operation:<br />
:<math>x \bmod y = x - y \left\lfloor x/y \right\rfloor, \ \text{if } y \neq 0</math>;<tt>&nbsp;&nbsp;</tt><math> x \bmod 0 = x</math>.<tt>&nbsp;&nbsp;</tt>(1)<br />
From this definition we can see that, when <math>y \neq 0</math>,<br />
:<math>0 \le \frac{x}{y} - \left\lfloor \frac{x}{y} \right\rfloor = \frac{ x \bmod y} {y} < 1</math>.<tt>&nbsp;&nbsp;</tt>(2)<br />
Consequently<br />
a) if <math>y > 0</math>, then <math>0 \le x \bmod y < y</math>;<br />
b) if <math>y < 0</math>, then  <math>0 \ge x \bmod y >y</math>;<br />
c) the quantity <math>x - (x \bmod y)</math> is an integral multiple of <math>y</math>.<br />
We call <math>x \bmod y</math> the ''remainder'' when <math>x</math> is divided by <math>y</math>; similarly, we call <math>\left\lfloor x/y \right\rfloor</math> the ''quotient''.<br >
When <math>x</math> and <math>y</math> are integers, “<math>\text{mod}</math>” is therefore a familiar operation:<br />
:<math>5 \bmod 3 = 2</math>,<tt>&nbsp;&nbsp;</tt><math>18 \bmod 3 = 0</math>,<tt>&nbsp;&nbsp;</tt><math>-2 \bmod 3 = 1</math>.<tt>&nbsp;&nbsp;</tt>(3)<br />
We have <math>x \bmod y = 0</math> if and only if <math>x</math> is a multiple of <math>y</math>, that is, if and only if <math>x</math> is divisible by <math>y</math>. The notation <math>y \backslash x</math>, read “<math>y</math> divides <math>x</math>,” means that <math>y</math> is a positive integer and <math>x \bmod y = 0</math>. <br />
The “<math>\text{mod}</math>” operation is useful also when <math>x</math> and <math>y</math> take arbitrary real values. For example, with trigonometric functions we can write<br />
:<math>\tan x = \tan (x \bmod \pi)</math>.<br />
The quantity <math>x \bmod 1</math> is the ''fractional part'' of <math>x</math>; we have, by Eq. (1),
:<math>x = \left\lfloor x \right\rfloor + (x \bmod 1)</math>.
</ref>，商经由[[取整函数|下取整函数]]来定义，商总是向[[无穷|负无穷]]取整，即使商已经是负数：
:<math>q=\left\lfloor\frac{a}{n}\right\rfloor</math>
余数和除数符号一致：
:<math>r = a - n \left\lfloor\frac{a}{n}\right\rfloor</math>
|Raymond T. Boute使用的[[欧几里得除法]]定义中<ref>{{cite journal
| last = Boute
| first = Raymond T.
| title = The Euclidean definition of the functions div and mod
| journal = ACM Transactions on Programming Languages and Systems
| volume = 14
| issue = 2
| pages = 127–144
| publisher = 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
| language=en}}<br />
Let us recall Euclid’s theorem.<br />
:THEOREM. For any real numbers <math>D</math> and <math>d</math> with <math>d \neq 0</math>, there exists a unique pair of numbers <math>q, r</math> satisfying the following conditions:<br />
:(a) <math>q \in \mathbb{Z}</math>;<br />
:(b) <math>D = d \cdot q + r</math>;<br />
:(c) <math>0 \le r < |d|</math>.<br />
For the particular case of integers, the conditions (a)-(c) correspond to part of the axioms for Euclidean rings [9].<br />
With the notational conventions of the theorem, we define <math>D \operatorname{div} d = q</math> and <math>D \bmod d = r</math>. Clearly the correspondingly labeled conditions are satisfied.<br />
Properties<br />
:<math>\begin{align}
D \operatorname{div}\, (-d) &= -(D \operatorname{div} d)\\
D \bmod \left(-d\right) &= D \bmod d\\
(-D) \operatorname{div} d &= -(D \operatorname{div} d) - I \cdot J\\
(-D) \bmod d &= -(D \bmod d) + d \cdot I \cdot J
\end{align}</math><br />
where <math>J = \operatorname{sign} d</math> and <math>I</math> is as defined earlier. (<math>I = \text{if } D/d \in \mathbb{Z} \text{ then } 0 \text{ else } 1</math>)
</ref>，要求满足<math>0 \le r < |n|</math>，在这种情况下：
:<math>q = \sgn(n) \left\lfloor\frac{a}{\left|n\right|}\right\rfloor =
\begin{cases}
  \left\lfloor\frac{a}{n}\right\rfloor & \text{if } n > 0 \\
  - \left\lfloor- \frac{a}{n}\right\rfloor & \text{if } n < 0 \\
\end{cases}</math>
这里的<math>\sgn</math>是[[符号函数]]，余数总是非负数:
: <math>r = a - |n| \left\lfloor \frac{a}{\left|n\right|} \right\rfloor =
\begin{cases}
 a - n \left\lfloor \frac{a}{n} \right\rfloor & \text{if } n > 0 \\
 a + n \left\lfloor - \frac{a}{n} \right\rfloor & \text{if } n < 0 \\
\end{cases}</math>
|Common Lisp的<code>round</code>函数和{{en-link|IEEE 754-1985||IEEE 754}}使用“修约除法”（{{lang-en|rounded division}}），商经由[[数值修约|修约函数]]<math>\operatorname{round}</math>（[[奇进偶舍|约半成偶]]）来定义为：
: <math>q = \operatorname{round}\left(\frac{a}{n}\right)</math>
当商为偶数时，余数范围是<math display="inline">-\frac{n}{2} \le r \le \frac{n}{2}</math>；当商为奇数时，余数范围是<math display="inline">-\frac{n}{2} < r < \frac{n}{2}</math>：
: <math>r = a - n \operatorname{round}\left(\frac{a}{n}\right)</math>
|Common Lisp的<code>ceiling</code>函数使用“上取整除法”（{{lang-en|ceiling division}}），商经由[[取整函数|上取整函数]]定义为：
: <math>q = \left\lceil\frac{a}{n}\right\rceil</math>
余数与除数有相反的符号：
: <math>r = a - n \left\lceil\frac{a}{n}\right\rceil</math>
}}

== 记号 ==
一些计算器有取模{{math|mod()}}按钮，很多编程语言里也有类似的函数，通常像<code>mod(a, n)</code>这样。有些语言也支持在表达式内使用<code>%</code>、<code>mod</code>或<code>Mod</code>作为取模或取余操作符，比如<code>a % n</code>或<code>a mod n</code>。

在一些没有{{math|mod()}}函数的环境中或许可使用等价的：<code>a - (n * int(a/n))</code>。这里的<code>int()</code>函数事实上等价于截断函数。

== 性质及恒等式 ==
一些取模操作，经过分解和展开可以等同于其他数学运算。这在[[密码学]]的证明中十分有用，例如：[[迪菲-赫爾曼密鑰交換]]。
* 恒等式：
** <math>(a \bmod n) \bmod n=a \bmod n</math>
** 对所有的正数 <math>x</math> 有：<math>n^x \bmod n=0</math>
** 如果 <math>p</math> 是一个[[质数]]，且不为 <math>b</math> 的[[因数]]，此时由[[费马小定理]]有：<math>ab^{p-1} \bmod p=a \bmod p</math>
* 逆运算：
** <math>[(-a \bmod n)+(a \bmod n)]\bmod n=0</math>.
** <math>b^{-1} \bmod n</math> 表示[[模反元素]]。当且仅当 <math>b</math> 与 <math>n</math> 互质时，等式左侧有定义：<math>[(b^{-1} \bmod n)(b \bmod n)] \bmod n =1</math>。
* 分配律：
** <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>
* 除法定义：仅当式子右侧有定义时，即 <math>b</math>、<math>n</math> 互质时有：<math>\frac{a}{b} \bmod n=[(a \bmod n)(b^{-1} \bmod n)]\bmod n</math>，其他情况为未定义的。
* 乘法逆元：<math>[(ab \bmod n)(b^{-1} \bmod n)]\bmod n=a \bmod n</math>.

==编程语言实现==
{| class="wikitable sortable"
|+ 在各种编程语言中的模除运算
|-
! scope="col" | [[编程语言|语言]]
! scope="col" | 算符
! scope="col" | 整数
! scope="col" | 浮点数
! abbr="Sign" scope="col" | 定义

|-
| [[ABAP]]
| {{code|MOD}}
| {{yes}}
| {{yes}}
| 欧几里得式

|-
| [[ActionScript]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[Ada]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整<ref name="Ada">{{Cite book|title=ISO/IEC 8652:2012 - Information technology — Programming languages — Ada|publisher=[[International Organization for Standardization|ISO]], [[International Electrotechnical Commission|IEC]]|year=2012|at=sec. 4.5.5 Multiplying Operators}}</ref>
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断<ref name="Ada" />

|-
| [[ALGOL 68]]
| {{code|÷×}}, {{code|mod}}
| {{yes}}
| {{no}}
| 类似欧几里得式{{efn|name=pascal&algol68}}

|-
| [[AMPL]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 截断

|-
| [[APL语言|APL]]
| <code><nowiki>|</nowiki></code>{{efn|name=rev|<code><nowiki>α|ω</nowiki></code>计算<math>\omega\bmod\alpha</math>，得出{{code|ω}}除以{{code|α}}的余数。}}
| {{yes}}
| {{yes}}
| 下取整

|-
| [[AppleScript]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 截断

|-
| [[AutoLISP]]
| {{code|(rem d n)}}
| {{yes}}
| {{no}}
| 截断

|-
| [[AWK]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| [[bash (Unix shell)|bash]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| [[BASIC]]
| {{code|Mod}}
| {{yes}}
| {{no}}
| 实现各异

|-
| [[bc语言|bc]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="3" | [[C语言|C]]{{break}}[[C++]]
| {{code|%}}, {{code|div}}
| {{yes}}
| {{no}}
| 截断{{efn|name=c|[[C99]]和[[C++11]]将{{code|%}}的行为定义为截断。<ref name="C99">{{cite web |title=C99 specification (ISO/IEC 9899:TC2) |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf |access-date=16 August 2018 |at=sec. 6.5.5 Multiplicative operators |date=2005-05-06}}</ref>此前的标准将其行为留给实现定义。<ref>{{Cite book|year=2003|title=ISO/IEC 14882:2003: Programming languages – C++|publisher=[[International Organization for Standardization]] (ISO), [[International Electrotechnical Commission]] (IEC)|at=sec. 5.6.4|quote=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}}
| 截断<ref>{{Cite book|title=ISO/IEC 9899:1990: Programming languages – C |publisher=[[International Organization for Standardization|ISO]], [[International Electrotechnical Commission|IEC]] |year=1990 |at=sec. 7.5.6.4 |quote=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}}
| 修约

|-
| rowspan="2" | [[C Sharp (programming language)|C#]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 截断
|-
| {{code|Math.IEEERemainder}}
| {{no}}
| {{yes}}
| 修约<ref name=".NET">{{Cite web |last=dotnet-bot |title=Math.IEEERemainder(Double, Double) Method (System) |url=https://learn.microsoft.com/en-us/dotnet/api/system.math.ieeeremainder?view=net-7.0 |access-date=2022-10-04 |website=Microsoft Learn |language=en-us}}</ref>

|-
| {{en-link|Clarion语言|Clarion (programming language)|Clarion}}
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Clean语言|Clean]]
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[Clojure]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整<ref>{{Cite web |title=clojure.core - Clojure v1.10.3 API documentation |url=https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/mod |access-date=2022-03-16 |website=clojure.github.io}}</ref>
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web |title=clojure.core - Clojure v1.10.3 API documentation |url=https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/rem |access-date=2022-03-16 |website=clojure.github.io}}</ref>

|-
| rowspan="2" | [[COBOL]]
| {{code|FUNCTION MOD}}
| {{yes}}
| {{no}}
| 下取整<ref name="isocobol">{{cite book|title=ISO/IEC 1989:2023 – Programming language COBOL|author=ISO/IEC JTC 1/SC 22/WG 4|publisher=[[ISO]]|date=January 2023|url=https://www.iso.org/standard/74527.html|url-access=subscription}}</ref>
|-
| {{code|FUNCTION REM}}
| {{yes}}
| {{yes}}
| 截断<ref name="isocobol"/>

|-
| rowspan="2" | [[CoffeeScript]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断
|-
| {{code|%%}}
| {{yes}}
| {{no}}
| 下取整<ref name="CoffeeScript">[http://coffeescript.org/#operators CoffeeScript operators]</ref>

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

|-
| rowspan="2" | [[Common Intermediate Language]]
| {{code|rem}} (有符号)
| {{yes}}
| {{yes}}
| 截断<ref>{{cite book|last=ISO/IEC JTC 1/SC 22|date=February 2012|title=ISO/IEC 23271:2012 — Information technology — Common Language Infrastructure (CLI)|url=https://www.iso.org/standard/58046.html|publisher=[[ISO]]|at=§§ III.3.55–56}}</ref>
|-
| {{code|rem.un}} (无符号)
| {{yes}}
| {{no}}
| {{N/A}}

|-
| rowspan="2" | [[Common Lisp]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| 下取整
|-
| {{code|rem}}
| {{yes}}
| {{yes}}
| 截断

|-
| rowspan="2" | {{en-link|Crystal语言|Crystal (programming language)|Crystal}}
| {{code|%}}, {{code|modulo}}
| {{yes}}
| {{yes}}
| 下取整
|-
| {{code|remainder}}
| {{yes}}
| {{yes}}
| 截断

|-
| [[D语言|D]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 截断<ref>{{Cite web|title=Expressions - D Programming Language|url=https://dlang.org/spec/expression.html#mul_expressions|access-date=2021-06-01|website=dlang.org}}</ref>

|-
| rowspan="2" | [[Dart]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 欧几里得式<ref>{{Cite web|title=operator % method - num class - dart:core library - Dart API|url=https://api.dart.dev/stable/2.13.1/dart-core/num/operator_modulo.html|access-date=2021-06-01|website=api.dart.dev}}</ref>
|-
| {{code|remainder()}}
| {{yes}}
| {{yes}}
| 截断<ref>{{Cite web|title=remainder method - num class - dart:core library - Dart API|url=https://api.dart.dev/stable/2.13.1/dart-core/num/remainder.html|access-date=2021-06-01|website=api.dart.dev}}</ref>

|-
| [[Eiffel]]
| {{code|\\}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[Elixir]]
| {{code|rem/2}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web|title=Kernel — Elixir v1.11.3|url=https://hexdocs.pm/elixir/Kernel.html#rem/2|access-date=2021-01-28|website=hexdocs.pm}}</ref>
|-
| {{code|Integer.mod/2}}
| {{yes}}
| {{no}}
| 下取整<ref>{{Cite web|title=Integer — Elixir v1.11.3|url=https://hexdocs.pm/elixir/Integer.html#mod/2|access-date=2021-01-28|website=hexdocs.pm}}</ref>

|-
| rowspan="2" | [[Elm语言|Elm]]
| {{code|modBy}}
| {{yes}}
| {{no}}
| 下取整<ref>{{Cite web |title=Basics - core 1.0.5 |url=https://package.elm-lang.org/packages/elm/core/latest/Basics#modBy |access-date=2022-03-16 |website=package.elm-lang.org}}</ref>
|-
| {{code|remainderBy}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web |title=Basics - core 1.0.5 |url=https://package.elm-lang.org/packages/elm/core/latest/Basics#remainderBy |access-date=2022-03-16 |website=package.elm-lang.org}}</ref>

|-
| rowspan="2" | [[Erlang]]
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断
|-
| {{code|math:fmod/2}}
| {{no}}
| {{yes}}
| 截断 (同于C)<ref>{{Cite web|title=Erlang -- math|url=https://erlang.org/doc/man/math.html#fmod-2|access-date=2021-06-01|website=erlang.org}}</ref>

|-
| rowspan="2" | [[Euphoria语言|Euphoria]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[F Sharp (programming language)|F#]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 截断
|-
| {{code|Math.IEEERemainder}}
| {{no}}
| {{yes}}
| 修约<ref name=".NET" />

|-
| [[Factor语言|Factor]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 截断

|-
| [[FileMaker]]
| {{code|Mod}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="3" | [[Forth]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 实现定义
|-
| {{code|fm/mod}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|sm/rem}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[Fortran]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| 截断
|-
| {{code|modulo}}
| {{yes}}
| {{yes}}
| 下取整

|-
| {{en-link|Frink语言|Frink (programming language)|Frink}}
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="2" | {{en-link|Full BASIC}}
| {{code|MOD}}
| {{yes}}
| {{yes}}
| 下取整<ref>{{cite book|last=[[ANSI]]|title=Programming Languages — Full BASIC|url=https://archive.org/details/federalinformat6821nati_0|date=28 January 1987|publisher=American National Standards Institute|location=New York|at=§ 5.4.4|quote=X modulo Y, i.e., X-Y*INT(X/Y).}}</ref>
|-
| {{code|REMAINDER}}
| {{yes}}
| {{yes}}
| 截断<ref>{{cite book|last=[[ANSI]]|title=Programming Languages — Full BASIC|url=https://archive.org/details/federalinformat6821nati_0|date=28 January 1987|publisher=American National Standards Institute|location=New York|at=§ 5.4.4|quote="The remainder function, i.e., X-Y*IP(X/Y)."}}</ref>

|-
| rowspan="2" | [[GLSL]]
| {{code|%}}
| {{yes}}
| {{no}}
| 未定义<ref>{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.50.pdf|title=GLSL Language Specification, Version 4.50.7|at=section 5.9 Expressions|quote=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}}
| 下取整<ref>{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.50.pdf|title=GLSL Language Specification, Version 4.50.7|at=section 8.3 Common Functions}}</ref>

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

|-
| rowspan="4" | [[Godot|GDScript (Godot)]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断
|-
| {{code|fmod}}
| {{no}}
| {{yes}}
| 截断
|-
| {{code|posmod}}
| {{yes}}
| {{no}}
| 欧几里得式
|-
| {{code|fposmod}}
| {{no}}
| {{yes}}
| 欧几里得式

|-
| rowspan="4" | [[Go (programming language)|Go]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web |title=The Go Programming Language Specification - The Go Programming Language |url=https://go.dev/ref/spec#Integer_operators |access-date=2022-02-28 |website=go.dev}}</ref>
|-
| {{code|math.Mod}}
| {{no}}
| {{yes}}
| 截断<ref>{{Cite web |title=math package - math - pkg.go.dev |url=https://pkg.go.dev/math#Mod |access-date=2022-02-28 |website=pkg.go.dev}}</ref>
|-
| {{code|big.Int.Mod}}
| {{yes}}
| {{no}}
| 欧几里得式<ref>{{Cite web |title=big package - math/big - pkg.go.dev |url=https://pkg.go.dev/math/big#Int.Mod |access-date=2022-02-28 |website=pkg.go.dev}}</ref>
|-
| {{code|big.Int.Rem}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web |title=big package - math/big - pkg.go.dev |url=https://pkg.go.dev/math/big#Int.Rem |access-date=2024-04-12 |website=pkg.go.dev}}</ref>
|-
| [[Apache Groovy|Groovy]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="3" | [[Haskell]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整<ref name="Haskell 2010">{{Cite web |title=6 Predefined Types and Classes |url=https://www.haskell.org/onlinereport/haskell2010/haskellch6.html#x13-1370006.4.2 |access-date=2022-05-22 |website=www.haskell.org}}</ref>
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断<ref name="Haskell 2010" />
|-
| {{code|Data.Fixed.mod'}} ([[Glasgow Haskell Compiler|GHC]])
| {{no}}
| {{yes}}
| 下取整

|-
| [[Haxe]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| [[HLSL]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 未定义<ref>{{cite web |url=https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-operators#additive-and-multiplicative-operators |title=Operators |author=<!--Not stated--> |publisher=[[Microsoft]] |access-date=2021-07-19 |quote=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语言|J]]
| <code><nowiki>|</nowiki></code>{{efn|name=rev}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="2" | [[Java]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 截断
|-
| {{code|Math.floorMod}}
| {{yes}}
| {{no}}
| 下取整

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

|-
| rowspan="2" | [[Julia语言|Julia]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| 下取整<ref>{{Cite web|title=Mathematics · The Julia Language|url=https://docs.julialang.org/en/v1/base/math/#Base.mod|access-date=2021-11-20|website=docs.julialang.org}}</ref>
|-
| {{code|%}}, {{code|rem}}
| {{yes}}
| {{yes}}
| 截断<ref>{{Cite web|title=Mathematics · The Julia Language|url=https://docs.julialang.org/en/v1/base/math/#Base.rem|access-date=2021-11-20|website=docs.julialang.org}}</ref>

|-
| rowspan="2" | [[Kotlin]]
| {{code|%}}, {{code|rem}}
| {{yes}}
| {{yes}}
| 截断<ref>{{Cite web|title=rem - Kotlin Programming Language|url=https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/rem.html|access-date=2021-05-05|website=Kotlin|language=en}}</ref>
|-
| {{code|mod}}
| {{yes}}
| {{yes}}
| 下取整<ref>{{Cite web|title=mod - Kotlin Programming Language|url=https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/mod.html|access-date=2021-05-05|website=Kotlin|language=en}}</ref>

|-
| rowspan="2" | [[KornShell|ksh]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断 (同于POSIX sh)
|-
| {{code|fmod}}
| {{no}}
| {{yes}}
| 截断

|-
| [[LabVIEW]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| 截断

|-
| [[LibreOffice]]
| {{code|1==MOD()}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="2" | [[Logo语言|Logo]]
| {{code|MODULO}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|REMAINDER}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Lua]] 5
| {{code|%}}
| {{yes}}
| {{yes}}
| 下取整

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

|-
| {{en-link|Liberty BASIC}}
| {{code|MOD}}
| {{yes}}
| {{no}}
| 截断

|-
| [[MathCad|Mathcad]]
| {{code|mod(x,y)}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="3" | [[Maple (software)|Maple]]
| {{code|e mod m}} (默认), {{code|modp(e, m)}}
| {{yes}}
| {{no}}
| 欧几里得式
|-
| {{code|mods(e, m)}}
| {{yes}}
| {{no}}
| 修约
|-
| {{code|frem(e, m)}}
| {{yes}}
| {{yes}}
| 修约

|-
| [[Mathematica]]
| {{code|Mod[a, b]}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="2" | [[MATLAB]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[Maxima (software)|Maxima]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| 截断

|-
| {{en-link|Maya嵌入语言|Maya Embedded Language|Maya Embedded Language}}
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Microsoft Excel]]
| {{code|1==MOD()}}
| {{yes}}
| {{yes}}
| 下取整

|-
| [[Minitab]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="2" | [[Modula-2]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|REM}}
| {{yes}}
| {{no}}
| 截断

|-
| {{en-link|MUMPS}}
| {{code|#}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="2" | [[Netwide Assembler]] ([[Netwide Assembler|NASM]], [[Netwide Assembler|NASMX]])
| {{code|%}}, {{code|div}} (无符号)
| {{yes}}
| {{no}}
| {{N/A}}
|-
| {{code|%%}} (有符号)
| {{yes}}
| {{no}}
| 实现定义<ref>{{cite web |title=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]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Oberon]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| 类似下取整{{efn|除数必须是整数，否则未定义。}}

|-
| [[Objective-C]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断 (同于C99)

|-
| [[Object Pascal]], [[Delphi]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[OCaml]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web|title=OCaml library : Stdlib|url=https://ocaml.org/releases/4.13/api/Stdlib.html#VAL(mod)|access-date=2022-02-19|website=ocaml.org}}</ref>
|-
| {{code|mod_float}}
| {{no}}
| {{yes}}
| 截断<ref>{{Cite web|title=OCaml library : Stdlib|url=https://ocaml.org/releases/4.13/api/Stdlib.html#VALmod_float|access-date=2022-02-19|website=ocaml.org}}</ref>

|-
| [[Occam]]
| {{code|\}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Pascal语言|Pascal]] (ISO-7185和ISO-10206)
| {{code|mod}}
| {{yes}}
| {{no}}
| 类似欧几里得式{{efn|name=pascal&algol68|1=按Boute的研讨，ISO Pascal和Algol68的{{code|div}}和{{code|mod}}定义不能维持除法恒等式{{math|1=''D'' = ''d'' · (''D'' / ''d'') + ''D'' % ''d''}}。}}

|-
| rowspan="2" | [[Perl]]
| {{code|%}}
| {{yes}}
| {{no}}
| 下取整{{efn|Perl通常使用机器无关的算术模除运算。其例子和异常，参见关于乘法运算的Perl文档。<ref>[http://perldoc.perl.org/perlop.html#Multiplicative-Operators Perl documentation]</ref>}}

|-
| {{code|POSIX::fmod}}
| {{no}}
| {{yes}}
| 截断

|-
| rowspan="2" | [[PHP]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web|title=PHP: Arithmetic Operators - Manual|url=https://www.php.net/manual/en/language.operators.arithmetic.php|access-date=2021-11-20|website=www.php.net}}</ref>
|-
| {{code|fmod}}
| {{no}}
| {{yes}}
| 截断<ref>{{Cite web|title=PHP: fmod - Manual|url=https://www.php.net/manual/en/function.fmod.php|access-date=2021-11-20|website=www.php.net}}</ref>

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

|-
| [[PL/I]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整 (ANSI PL/I)

|-
| [[PowerShell]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| Programming Code ({{en-link|PRC (Palm OS)||PRC}})
| {{code|MATH.OP - 'MOD; (\)'}}
| {{yes}}
| {{no}}
| 未定义

|-
| {{en-link|OpenEdge高级商务语言|OpenEdge Advanced Business Language|Progress}}
| {{code|modulo}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2"| [[Prolog]] (ISO 1995<ref>[https://www.iso.org/standard/21413.html ISO 1995]</ref>)
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断

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

|-
| [[PureScript]]
| {{code|`mod`}}
| {{yes}}
| {{no}}
| 欧几里得式<ref name="purescript_euclid">{{Cite web|url=https://pursuit.purescript.org/packages/purescript-prelude/5.0.1/docs/Data.EuclideanRing#t:EuclideanRing|title = EuclideanRing}}</ref>

|-
| rowspan="2" | [[Pure Data]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断 (同于C)
|-
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整

|-
| rowspan="3" | [[Python]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 下取整
|-
| {{code|math.fmod}}
| {{no}}
| {{yes}}
| 截断
|-
| {{code|math.remainder}}
| {{no}}
| {{yes}}
| 修约

|-
| [[Q Sharp|Q#]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web|url=https://docs.microsoft.com/en-us/quantum/quantum-qr-expressions?view=qsharp-preview#numeric-expressions|title=Expressions|last=QuantumWriter|website=docs.microsoft.com|language=en-us|access-date=2018-07-11}}</ref>

|-
| [[R语言|R]]
| {{code|%%}}
| {{yes}}
| {{yes}}
| 下取整<ref>{{Cite web |title=R: Arithmetic Operators |url=https://search.r-project.org/R/refmans/base/html/Arithmetic.html |access-date=2022-12-24 |website=search.r-project.org}}</ref>

|-
| rowspan="2" |[[Racket]]
| {{code|modulo}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Raku]]
| {{code|%}}
| {{no}}
| {{yes}}
| 下取整

|-
| {{en-link|RealBasic}}
| {{code|MOD}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Reason语言|Reason]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 截断

|-
| [[REXX|Rexx]]
| {{code|//}}
| {{yes}}
| {{yes}}
| 截断

|-
| {{en-link|IBM RPG||RPG}}
| {{code|%REM}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | [[Ruby]]
| {{code|%}}, {{code|modulo()}}
| {{yes}}
| {{yes}}
| 下取整
|-
| {{code|remainder()}}
| {{yes}}
| {{yes}}
| 截断

|-
| rowspan="2" | [[Rust]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 截断
|-
| {{code|rem_euclid()}}
| {{yes}}
| {{yes}}
| 欧几里得式<ref name="rust_rem_euclid">{{Cite web|url=https://doc.rust-lang.org/std/primitive.f32.html#method.rem_euclid|title = F32 - Rust}}</ref>

|-
| [[SAS语言|SAS]]
| {{code|MOD}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Scala]]
| {{code|%}}
| {{yes}}
| {{yes}}
| 截断

|-
| rowspan="2" | [[Scheme]]
| {{code|modulo}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|remainder}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="4" | [[Scheme]] R<sup>6</sup>RS
| {{code|mod}}
| {{yes}}
| {{no}}
| 欧几里得式<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}}
| 修约<ref name="r6rs"/>
|-
| {{code|flmod}}
| {{no}}
| {{yes}}
| 欧几里得式
|-
| {{code|flmod0}}
| {{no}}
| {{yes}}
| 修约

|-
| [[Scratch]]
| {{code|mod}}
| {{yes}}
| {{yes}}
| 下取整

|-
| rowspan="2" | {{en-link|Seed7}}
| {{code|mod}}
| {{yes}}
| {{yes}}
| 下取整
|-
| {{code|rem}}
| {{yes}}
| {{yes}}
| 截断

|-
| rowspan="2" | {{en-link|SenseTalk}}
| {{code|modulo}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Unix shell]] (包括[[Bash (Unix shell)|bash]]、ash等。)
| {{code|%}}
| {{yes}}
| {{no}}
| 截断 (同于C)<ref>{{Cite web|title=Shell Command Language|url=https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_04|access-date=2021-02-05|website=pubs.opengroup.org}}</ref>

|-
| rowspan="2" | [[Smalltalk]]
| {{code|\\}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|rem:}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Snap!]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整

|-
| {{en-link|Parallax Propeller|Parallax Propeller#Built in Spin byte code interpreter|Spin}}
| {{code|//}}
| {{yes}}
| {{no}}
| 下取整

|-
| [[Solidity]]
| {{code|%}}
| {{yes}}
| {{no}}
| 下取整

|-
| [[SQL]] ({{en-link|SQL:1999}})
| {{code|mod(x,y)}}
| {{yes}}
| {{no}}
| 截断

|-
| [[SQL]] ({{en-link|SQL:2011}})
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="3" | [[Standard ML]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|Int.rem}}
| {{yes}}
| {{no}}
| 截断
|-
| {{code|Real.rem}}
| {{no}}
| {{yes}}
| 截断

|-
| [[Stata]]
| {{code|mod(x,y)}}
| {{yes}}
| {{no}}
| 欧几里得式

|-
| rowspan="3" | [[Swift]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断<ref>{{Cite web|title=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/binaryinteger/2885003|access-date=2021-11-20|website=developer.apple.com}}</ref>
|-
| {{code|remainder(dividingBy:)}}
| {{no}}
| {{yes}}
| 修约<ref>{{Cite web|title=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/floatingpoint/3017981-remainder|access-date=2021-11-20|website=developer.apple.com}}</ref>
|-
| {{code|truncatingRemainder(dividingBy:)}}
| {{no}}
| {{yes}}
| 截断<ref>{{Cite web|title=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/floatingpoint/3017995-truncatingremainder|access-date=2021-11-20|website=developer.apple.com}}</ref>

|-
| rowspan="2" | [[Tcl]]
| {{code|%}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|fmod()}}
| {{no}}
| {{yes}}
| 截断 (同于C)

|-
| [[tcsh]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| {{en-link|Torque (游戏引擎)|Torque (game engine)|Torque}}
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

|-
| {{en-link|Turing语言|Turing (programming language)|Turing}}
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整

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

|-
| rowspan="2" | [[VHDL]]
| {{code|mod}}
| {{yes}}
| {{no}}
| 下取整
|-
| {{code|rem}}
| {{yes}}
| {{no}}
| 截断

|-
| [[Vim|VimL]]
| {{code|%}}
| {{yes}}
| {{no}}
| 截断

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

|-
| rowspan="2" | [[WebAssembly]]
| {{code|i32.rem_u}}, {{code|i64.rem_u}} (无符号)
| {{yes}}
| {{no}}
| {{N/A}}
|-
| {{code|i32.rem_s}}, {{code|i64.rem_s}} (有符号)
| {{yes}}
| {{no}}
| 截断<ref name="wasmcs2">{{cite web|editor-first1=Andreas|editor-last1=Rossberg|date=19 April 2022|title=WebAssembly Core Specification: Version 2.0|url=https://www.w3.org/TR/wasm-core-2/|publisher=[[World Wide Web Consortium]]|at=§ 4.3.2 Integer Operations}}</ref>

|-
| rowspan="2" |{{en-link|x86汇编语言|x86 assembly language|x86 assembly}}
| {{code|DIV}}(无符号)
| {{yes}}
| {{no}}
| {{N/A}}
|-
| {{code|IDIV}}(有符号)
| {{yes}}
| {{no}}
| 截断

|-
| rowspan="2" | {{en-link|XBase++}}
| {{code|%}}
| {{yes}}
| {{yes}}
| 截断
|-
| {{code|Mod()}}
| {{yes}}
| {{yes}}
| 下取整

|-
| [[Zig]]
| {{code|%}}, {{code|@mod}}, {{code|@rem}}
| {{yes}}
| {{yes}}
| 截断<ref>{{Cite web |title=Zig Documentation |url=https://ziglang.org/documentation/0.10.0/#Table-of-Operators |access-date=2022-12-18 |website=Zig Programming Language}}</ref>

|-
| {{en-link|Z3定理证明器|Z3 Theorem Prover|Z3 theorem prover}}
| {{code|div}}, {{code|mod}}
| {{yes}}
| {{no}}
| 欧几里得式
|}

此外，很多计算机系统提供{{code|divmod}}功能，它同时产生商和余数。例子[[x86架构]]的{{code|IDIV}}指令，C编程语言的{{code|div()}}函数，和[[Python]]的{{code|divmod()}}函数。

== 常见错误 ==
当取模的结果与被除数符号相同时，可能会导致意想不到的错误。

举个例子：如果需要判断一个整数是否为奇数，有人可能会测试这个数除 2 的余数是否为 1：
<syntaxhighlight lang="c++">
bool is_odd(int n) {
    return n % 2 == 1;
}
</syntaxhighlight>

但在一个取模结果与被除数符号相同的编程语言里，这样做是错的。因为当被除数 {{math|''n''}} 是奇数且为负数时， <math>n \bmod 2</math> 得到 −1，此时函数返回“假”。

一种正确的实现是测试取模结果是否为 0，因为余数为 0 时没有符号的问题：
<syntaxhighlight lang="c++">
bool is_odd(int n) {
    return n % 2 != 0;
}
</syntaxhighlight>

或者考虑余数的符号，有两种情况：余数可能为 1 或 -1。
<syntaxhighlight lang="c++">
bool is_odd(int n) {
    return n % 2 == 1 || n % 2 == -1;
}
</syntaxhighlight>

== 性能问题 ==
可以通过依次计算带余数的除法实现取模操作。特殊情况下，如某些硬件上，存在更快的实现。
例如：2 的 n 次幂的模，可以通过[[位操作|逐位]][[逻辑与|与运算]]实现：
: <code>x % 2<sup>n</sup> == x & (2<sup>n</sup> - 1)</code>

例子，假定 {{math|''x''}} 为正数：
: <code>x % 2 == x & 1</code>
: <code>x % 4 == x & 3</code>
: <code>x % 8 == x & 7</code>

在进行位操作比取模操作效率更高的设备或软件环境中，以上形式的取模运算速度更快。<ref>{{cite web |first= Adam |last= Horvath |url= http://blog.teamleadnet.com/2012/07/faster-division-and-modulo-operation.html |title= Faster division and modulo operation - the power of two |date= July 5, 2012|language=en|archiveurl=https://web.archive.org/web/20180305063518/http://blog.teamleadnet.com/2012/07/faster-division-and-modulo-operation.html|archivedate=2018-03-05}}</ref>

编译器可以自动识别出对 2 的 n 次幂取模的表达式，自动将其优化为 <code>expression &amp; (constant-1)</code>。这样可以在兼顾效率的情况下写出更整洁的代码。这个优化在取模结果与被除数符号一致的语言中（包括 C 语言）不能使用，除非被除数是无符号整数。这是因为如果被除数是负数，则结果也是负数，但 <code>expression &amp; (constant-1)</code> 总是正数，进行这样的优化就会导致错误，无符号整数则没有这个问题。

== 用途 ==
* 取模运算可用于判断一个数是否能被另一个数整除。对 2 取模即可判断整数的奇偶性；从 2 到 <math>n-1</math> 取模则可判断一个数是否为质数。
* [[進制]]之間的轉換。
* 用于求取最大公约数的[[輾轉相除法]]使用取模运算。
* 密码学中的应用：从古老的[[凯撒密码]]到现代常用的[[RSA加密演算法|RSA]]、[[椭圆曲线密码学|椭圆曲线密码]]，它们的实现过程均使用了取模运算。

== 參見 ==
* [[模 (消歧义)]]和{{tsl|en|modulo (jargon)|模 (术语)}} —— “模数（Modulo）”这个词的许多用法，都是 1801 年[[卡爾·弗里德里希·高斯]]引入[[模算數]]时产生的。
* [[模幂运算]]
* [[同餘]]

== 脚注 ==
{{reflist|group=lower-alpha|2}}

== 参考文献 ==
{{Reflist|2}}

[[Category:計算機算術]]
[[Category:带有C++代码示例的条目]]
[[Category:运算符 (编程)]]
[[Category:同余]]
[[Category:数字运算]]