Xem mã nguồn của Phép toán modulo

Trong [[điện toán]], phép toán '''modulo''' là phép toán tìm [[số dư]] của [[phép chia]] 2 số (đôi khi được gọi là ''modulus'').

Cho hai [[số dư]], ([[số bị chia]]) {{math|''a''}} và ([[chia hết|số chia]]) {{math|''n''}}, {{math|''a''}} modulo {{math|''n''}} (viết tắt là {{math|''a'' mod ''n''}}) là [[số dư]] của [[phép chia có dư|phép chia có dư Euclid]] của {{math|''a''}} cho {{math|''n''}}. Ví dụ, biểu thức "5 mod 2" bằng 1 vì 5 chia cho 2 có [[Phép chia có dư|thương số]] là 2 là [[số dư]] là 1, trong khi "9 mod 3" bằng 0 do 9 chia 3 có thương số là 3 và [[số dư]] 0; không còn gì trong phép trừ của 9 cho 3 nhân 3. (Lưu ý rằng thực hiện phép chia bằng máy tính cầm tay sẽ không hiển thị kết quả giống như phép toán này; thương số sẽ được biểu diễn dưới dạng phần thập phân.)

Mặc dù thường được thực hiện khi {{math|''a''}} và {{math|''n''}} đều là số nguyên, nhiều hệ tính toán cho phép sử dụng các kiểu khác của toán học bằng số. Giới hạn của một modulo nguyên của {{math|''n''}} là từ 0 đến {{math|''n'' − 1}}. ({{math|''a''}} mod 1 luôn bằng 0; {{math|''a'' mod 0}} là không xác định, có thể trả về lỗi [[Division by zero|chia cho số 0]] trong nhiều ngôn ngữ lập trình.) Xem [[số học mô-đun]] để tìm các quy ước cũ hơn và liên quan được áp dụng trong [[lý thuyết số]].

Khi hoặc {{math|''a''}} hoặc {{math|''n''}} là số âm, định nghĩa cơ bản bị phá vỡ và các [[ngôn ngữ lập trình]] khác nhau trong việc định nghĩa các kết quả này.
==Tính toán phần dư trong phép toán modulo==
[[Hình:Divmod.svg|thumb|right|250px|{{colorbox|red}} Thương số ({{math|''q''}}) và {{colorbox|lightgreen}} [[số dư]] ({{math|''r''}}) theo các hàm của số bị chia ({{math|''a''}}), bằng cách dùng các thuật toán khác nhau]]
Trong [[toán học]], kết quả của phép toán modulo là [[số dư]] của [[phép chia có dư]]. Tuy vậy các quy ước khác vẫn tồn tại. Máy vi tính và máy tính có nhiều cách khác nhau để lưu trữ và đại diện cho các số; do đó định nghĩa của chúng về phép toán modulo phụ thuộc vào [[ngôn ngữ lập trình]] hoặc [[phần cứng]] máy tính bên dưới cơ bản.

Trong hầu hết các hệ thống máy tính, [[quotient|thương số]] {{math|''q''}} và [[số dư]] {{math|''r''}} của phép chia {{math|''a''}} cho {{math|''n''}} thỏa mãn
: {{NumBlk|:|<math>\begin{align}
q \,&\in \mathbb{Z} \\
a \,&= n q + r \\
|r| \,&< |n|
\end{align}</math>|{{EquationRef|1}}}}

Tuy nhiên, vẫn còn sự nhập nhằng về dấu nếu [[số dư]] khác không: hai lựa chọn có thể cho [[số dư]] xảy ra, một âm và một dương, và hai lựa chọn cho thương số xảy ra. Trong lý thuyết số, thông thường [[số dư]] dương luôn được chọn, nhưng lựa chọn của các ngôn ngữ lập trình tùy thuộc vào ngôn ngữ và dấu của {{math|''a''}} hoặc {{math|''n''}}.{{ref|2}} Ngôn ngữ [[Pascal (ngôn ngữ lập trình)|Pascal]] và [[ALGOL 68]] tiêu chuẩn chọn [[số dư]] dương (hoặc 0) kể cả khi số chia là các số âm, đối với một vài ngôn ngữ lập trình như C90 thì dấu tùy thuộc vào cài đặt khi hoặc {{math|''n''}} hoặc {{math|''a''}} là số âm. Xem bảng để biết chi tiết. {{math|''a''}} modulo 0 là không xác định trong hầu hết các hệ thống, mặc dù một số hệ thống định nghĩa là {{math|''a''}}.

{{bulleted list
| Nhiều cài đặt sử dụng ''phép chia rút gọn'' mà trong đó thương số được định nghĩa bởi hàm [[truncation|rút gọn]] {{math|''q'' {{=}} trunc({{sfrac|''a''|''n''}})}} do đó theo phương trình ({{EquationNote|1}}) [[số dư]] sẽ có ''cùng dấu với số bị chia''. Thương số được làm tròn về số không: bằng số nguyên đầu tiên có phần hướng tới không của thương số hữu tỉ.
:<math>r = a - n \operatorname{trunc}\left(\frac{a}{n}\right)</math>

| [[Donald Knuth]]<ref>{{chú thích sách|
first=Donald. E.|last=Knuth|title=The Art of Computer Programming
|publisher=Addison-Wesley|year=1972
}}</ref> mô tả ''phép chia sàn'' trong đó thương số được định nghĩa bởi [[floor function|hàm floor]] {{math|''q'' {{=}} ⌊{{sfrac|''a''|''n''}}⌋}}, do đó theo phương trình ({{EquationNote|1}}) [[số dư]] sẽ có ''cùng dấu với số chia''. Do hàm floor, thương số luôn được làm tròn xuống kể cả khi nó là số âm.
:<math>r = a - n \left\lfloor\frac{a}{n}\right\rfloor</math>

| Raymond T. Boute<ref>{{chú thích tạp chí
 | 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}}</ref> mô tả định nghĩa phép chia có dư trong đó [[số dư]] luôn không âm, {{math|0 ≤ ''r''}}, phù hợp với giải thuật ''[[phép chia có dư]]''. Trong đó,
: <math>n > 0 \Rightarrow q = \left\lfloor\frac{a}{n}\right\rfloor</math>
: <math>n < 0 \Rightarrow q = \left\lceil\frac{a}{n}\right\rceil</math>
hoặc tương đương
: <math>q = \sgn(n) \left\lfloor \frac{a}{\left|n\right|} \right\rfloor</math>
với {{math|sgn}} là [[Signum|hàm sign]], do đó
: <math>r = a - |n| \left\lfloor \frac{a}{\left|n\right|} \right\rfloor</math>

| Ngôn ngữ Common Lisp cũng định nghĩa phép chia làm tròn và phép chia trần, trong đó thương số cho bởi {{math|''q'' {{=}} round({{sfrac|''a''|''n''}})}} và {{math|q {{=}} ⌈{{sfrac|''a''|''n''}}⌉}} tương ứng.

| [[IEEE 754-1985|IEEE 754]] định nghĩa hàm [[số dư]] trong đó thương số là {{math|{{sfrac|''a''|''n''}}}} được làm tròn dựa trên [[IEEE 754-1985#Rounding floating-point numbers|quy ước làm tròn đến số gần nhất]]. Do vậy, dấu của [[số dư]] được chọn là ''gần với số 0 nhất''.

}}

Theo mô tả của Leijen,
{{Quote|text=Boute argues that Euclidean division is superior to the other ones in terms of regularity and useful mathematical properties, although floored division, promoted by Knuth, is also a good definition. Despite its widespread use, truncated division is shown to be inferior to the other definitions.
(Tạm dịch: Boute lập luận rằng phép chia có dư là vượt trội so với các phép chia khác về tính đều đặn và các thuộc tính toán học hữu ích, dù rằng với phép chia sàn, được Knuth ủng hộ, cũng là một định nghĩa tốt. Tuy được sử dụng rộng rãi, phép chia rút gọn được chứng minh kém hơn các định nghĩa khác.)
|sign=Daan Leijen|source=''Division and Modulus for Computer Scientists''<ref>{{chú thích web
 | last = Leijen
 | first = Daan
 | title = Division and Modulus for Computer Scientists (Tạm dịch: Phép chia và Phép Modulus của các nhà khoa học máy tính)
 | date = Tháng 3 năm 2001
 | url = http://research.microsoft.com/pubs/151917/divmodnote.pdf
 | format = PDF
 | access-date = ngày 25 tháng 12 năm 2014}}</ref>}}

Tuy nhiên, Boute tập trung vào các tính chất của chính phép toán modulo và không đánh giá sự thật là phép chia rút gọn (tiếng Anh: truncated division) cho thấy sự đối xứng của {{math|(-''a'') div ''n'' {{=}} -(''a'' div ''n'')}} và {{math|''a'' div (-''n'') {{=}} -(''a'' div ''n'')}}, mà cũng giống phép chia thông thường. Bởi vì cả hai phép chia sàn và phép chia có dư đều không có tính đối xứng này, phán đoán của Boute ít nhất là không toàn diện.{{cần chú thích|date=Tháng 1 năm 2018}}{{OR|date=Tháng 1 năm 2018}}

==Các sai lầm thông thường==
Nếu kết quả của phép chia modulo có dấu của số bị chia thì sẽ dẫn đến các sai lầm đáng ngạc nhiên.

Ví dụ, để kiểm tra tính lẻ của một số nguyên, ta có thể kiểm tra [[số dư]] khi chia cho có bằng 1:

<syntaxhighlight lang="cpp">
bool is_odd(int n) {
    return n % 2 == 1;
}
</syntaxhighlight>

Khi ngôn ngữ lập trình có [[số dư]] có dấu của số bị chia, việc kiểm tra sẽ sai, do khi {{math|''n''}} (số bị chia) là số âm lẻ, {{math|''n''}} mod 2 trả về −1, và hàm trả về false.

Có thể sửa lại sai lầm đó bằng cách kiểm tra rằng kết quả khác 0 (do [[số dư]] bằng 0 được xem xét như nhau bất kể dấu):

<syntaxhighlight lang="cpp">
bool is_odd(int n) {
    return n % 2 != 0;
}
</syntaxhighlight>

Hay là, bằng việc hiểu trước rằng với bất kỳ số lẻ nào, [[số dư]] modulo có thể hoặc bằng 1 hoặc −1:

<syntaxhighlight lang="cpp">
bool is_odd(int n) {
    return n % 2 == 1 || n % 2 == -1;
}
</syntaxhighlight>

==Ký hiệu==
{{Về|phép toán ''mod'' nhị phân|kí hiệu ''(mod m)''|Quan hệ đồng dư|section=yes}}

Một số máy tính cầm tay có nút của hàm {{math|mod()}}, và nhiều ngôn ngữ lập trình khác có hàm tương tự, biểu diễn cho {{math|mod(''a'', ''n'')}}. Một vài ngôn ngữ hỗ trợ các biễu thức mà dùng "%", "mod", hoặc "Mod" là toán tử modulo hoặc [[Toán tử (lập trình máy tính)|toán tử]] lấy [[số dư]], chẳng hạn
:<code>a % n</code>
hoặc
:<code>a mod n</code>
hoặc tương đương cho môi trường thiếu hàm {{math|mod()}} (chú ý rằng kiểu 'int' vốn đã sinh ra giá trị rút gọn {{math|{{sfrac|''a''|''n''}}}})
:<code>a - (n * int(a/n))</code>

==Vấn đề hiệu suất==
Phép toán modulo có thể được cài đặt sao cho mỗi lần phép chia với [[số dư]] được tính. Đôi với nhu cầu đặc biệt, trên vài phần cứng, tồn tại các phép toán tương tự nhưng nhanh hơn. Ví dụ, modulo cho lũy thừa của 2 có thể biễu diễn tương đương bởi phép toán [[Phép toán thao tác bit|bitwise]] AND:
:<code>x % 2<sup>n</sup> == x & (2<sup>n</sup> - 1)</code>

Ví dụ (giả sử {{math|''x''}} là số nguyên dương):
:<code>x % 2 == x & 1</code>
:<code>x % 4 == x & 3</code>
:<code>x % 8 == x & 7</code>

Trong các thiết bị và phần mềm mà cài đặt toán tử bitwise hiệu quả hơn toán tử modulo, các dạng thay thế này có thể dẫn đến tính toán nhanh hơn.<ref>{{chú thích 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= ngày 5 tháng 7 năm 2012}}</ref>

Các [[trình biên dịch]] [[Compiler optimization|tối ưu hóa]] có thể nhận diện các biểu thức có dạng <code>expression % constant</code> trong đó <code>constant</code> là lũy thừa của 2 và tự động cài đặt chúng thành <code>expression & (constant-1)</code>. Điều này cho phép viết mã rõ ràng hơn mà không ảnh hưởng đến hiệu suất. Cách tối ưu hóa này không áp dụng cho các ngôn ngữ mà kết quả của phép toán modulo có cùng dẫu với số bị chia (bao gồm C), trừ phi số bị chia là kiểu số nguyên [[Signedness|không dấu]]. Bởi vì nếu số bị chia là số âm thì modulo sẽ là số âm trong khi <code>expression &amp; (constant-1)</code> sẽ luôn dương.

==Tính tương đương==
Một số phép toán modulo có thể được mở rộng tương tự sang các phép toán toán học khác. Điều này có tính hữu dụng trong các chứng minh [[mật mã học]], chẳng hạn [[trao đổi khóa Diffie-Hellman]].
*Phần tử đơn vị:
**{{math|(''a'' mod ''n'') mod ''n'' {{=}} ''a'' mod ''n''}}.
**{{math|''n''{{sup|''x''}} mod ''n'' {{=}} 0}} với mọi số nguyên dương {{math|''x''}}.
** Nếu {{math|''p''}} là [[số nguyên tố]] không phải là [[chia hết|ước số]] của {{math|''b''}}, thì {{math|''ab''{{sup|''p''−1}} mod ''p'' {{=}} ''a'' mod ''p''}}, dựa theo [[định lý nhỏ Fermat]].
*Phần tử đảo:
**{{math|[(−''a'' mod ''n'') + (''a'' mod ''n'')] mod ''n'' {{=}} 0}}.
**{{math|''b''{{sup|−1}} mod ''n''}} kí hiệu [[modular multiplicative inverse|phần tử đảo modular]], được định nghĩa khi và chỉ khi {{math|''b''}} và {{math|''n''}} là các [[số nguyên tố cùng nhau]], khi vế trái xác định: {{math|[(''b''{{sup|−1}} mod ''n'')(''b'' mod ''n'')] mod ''n'' {{=}} 1}}.
*Tính phân phối:
**{{math|(''a'' + ''b'') mod ''n'' {{=}} [(''a'' mod ''n'') + (''b'' mod ''n'')] mod ''n''}}.
**{{math|''ab'' mod ''n'' {{=}} [(''a'' mod ''n'')(''b'' mod ''n'')] mod ''n''}}.
*Phép chia (định nghĩa): {{math|{{sfrac|''a''|''b''}} mod ''n'' {{=}} [(''a'' mod ''n'')(''b''{{sup|−1}} mod ''n'')] mod ''n''}}, khi vế phải xác định (là khi {{math|''b''}} và math|''n''}} là các [[số nguyên tố cùng nhau]]). Các trường hợp còn lại là không xác định.
*Phép nhân nghịch đảo: {{math|[(''ab'' mod ''n'')(''b''{{sup|−1}} mod ''n'')] mod ''n'' {{=}} ''a'' mod ''n''}}.
==Dấu Mod trong các ngôn ngữ lập trình==
{| class="wikitable" 
|+ Toán tử modulo của số nguyên trong nhiều ngôn ngữ lập trình khác nhau
|-
! [[Ngôn ngữ lập trình|Ngôn ngữ]]
! Toán tử
! abbr="Sign" | Kết quả có cùng dấu với
|-
| [[ABAP]]
| <code>MOD</code>
| Luôn không âm
|-
| [[ActionScript]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Ada (ngôn ngữ lập trình)|Ada]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| [[ALGOL 68]]
| <code>÷×, mod</code>
| Luôn không âm
|-
| [[AMPL]]
| <code>mod</code>
| Số bị chia
|-
| [[APL (ngôn ngữ lập trình)|APL]]
| <code><nowiki>|</nowiki></code>{{ref|5a}}
| Số chia
|-
| [[AppleScript]]
| <code>mod</code>
| Số bị chia
|-
| [[AutoLISP]]
| <code>(rem d n)</code>
| [[Số dư]]
|-
| [[AWK]]
| <code>%</code>
| Số bị chia
|-
| [[BASIC]]
| <code>Mod</code>
| Không xác định
|-
| [[Bash (Unix shell)|bash]]
| <code>%</code>
| Số bị chia
|-
| [[bc (ngôn ngữ lập trình)|bc]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[C (ngôn ngữ lập trình)|C]] (ISO 1990)
| <code>%</code>
| Định nghĩa tùy thuộc cài đặt
|-
| <code>div</code>
| ngôn ngữ lập trình
|-
| rowspan="2" | [[C++]] (ISO 1998)
| <code>%</code>
| Định nghĩa tùy thuộc cài đặt<ref>{{Chú thích tạp chí |title=ISO/IEC 14882:2003: programming languages – C++ |publisher=[[International Organization for Standardization]] (ISO), [[International Electrotechnical Commission]] (IEC) |year=2003 |location=5.6.4 |postscript=<!--None-->}}. "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>div</code>
| Số bị chia
|-
| [[C99|C (ISO 1999)]]
| <code>%</code>, <code>div</code>
| Số bị chia<ref name="C99">[http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf open-std.org], mục 6.5.5</ref>
|-
| [[C++11|C++ (ISO 2011)]]
| <code>%</code>, <code>div</code>
| Số bị chia
|-
| [[C Sharp (ngôn ngữ lập trình)|C#]]
| <code>%</code>
| Số bị chia
|-
| [[Clarion (ngôn ngữ lập trình)|Clarion]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Clojure]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| [[COBOL]]{{ref|4}}
| <code>FUNCTION&nbsp;MOD</code>
| Số chia
|-
| rowspan="2" | [[CoffeeScript]]
| <code>%</code>
| Số bị chia
|-
| <code>%%</code>
| Số chia<ref name="CoffeeScript">[http://coffeescript.org/#operators CoffeeScript operators]</ref>
|-
| [[ColdFusion]]
| <code>%, MOD</code>
| Số bị chia
|-
| rowspan="2" | [[Common Lisp]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
|[https://www.scirra.com/construct2 Construct 2]
|%
|
|-
| [[D (ngôn ngữ lập trình)|D]]
| <code>%</code>
| Số bị chia<ref>{{chú thích web |title=Expressions |url=http://www.digitalmars.com/d/2.0/expression.html#MulExpression |work=D ngôn ngữ lập trình 2.0 |publisher=Digital Mars |access-date=ngày 29 tháng 7 năm 2010}}</ref>
|-
| rowspan="2" | [[Dart (ngôn ngữ lập trình)|Dart]]
| <code>%</code>
| Luôn không âm
|-
| remainder()
| Số bị chia
|-
| [[Eiffel (ngôn ngữ lập trình)|Eiffel]]
| <code>\\</code>
| 
|-
| [[Erlang (ngôn ngữ lập trình)|Erlang]]
| <code>rem</code>
| Số bị chia
|-
| rowspan="2" | [[Euphoria (ngôn ngữ lập trình)|Euphoria]]
| <code>mod</code>
| Số chia
|-
| <code>remainder</code>
| Số bị chia
|-
| [[F Sharp (ngôn ngữ lập trình)|F#]]
| <code>%</code>
| Số bị chia
|-
| [[FileMaker]]
| <code>Mod</code>
| Số chia
|-
| [[Forth (ngôn ngữ lập trình)|Forth]]
| <code>mod</code>
| tùy thuộc vào cài đặt
|-
| rowspan="2" | [[Fortran]]
| <code>mod</code>
| Số bị chia
|-
| <code>modulo</code>
| Số chia
|-
| Frink
| <code>mod</code>
| Số chia
|-
| [[GameMaker: Studio]] (GML)
| <code>mod</code>, <code>%</code>
| Số bị chia
|-
| [[Godot (game engine)|GDScript]]
| <code>%</code>
| Số bị chia
|-
| [[Go (ngôn ngữ lập trình)|Go]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Haskell (ngôn ngữ lập trình)|Haskell]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| [[Haxe]]
| <code>%</code>
| Số bị chia
|-
| [[Kotlin (ngôn ngữ lập trình)|Kotlin]]
| <code>%</code>
| Số bị chia
|-
| [[J (ngôn ngữ lập trình)|J]]
| <code><nowiki>|</nowiki></code>{{ref|5b}}
| Số chia
|-
| rowspan="2" | [[Java (ngôn ngữ lập trình)|Java]]
| <code>%</code>
| Số bị chia
|-
| <code>Math.floorMod</code>
| Số chia
|-
| [[JavaScript]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Julia (ngôn ngữ lập trình)|Julia]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
|[[LabVIEW]]
|<code>mod</code>
| Số bị chia
|-
| [[LibreOffice]]
| <code>=MOD()</code>
| Số chia
|-
| [[Lua (ngôn ngữ lập trình)|Lua]] 5
| <code>%</code>
| Số chia
|-
| [[Lua (ngôn ngữ lập trình)|Lua]] 4
| <code>mod(x,y)</code>
| Số chia
|-
| [[Liberty BASIC]]
| <code>MOD</code>
| Số bị chia
|-
| [[Mathcad]]
| <code>mod(x,y)</code>
| Số chia
|-
| [[Maple (phần mềm)|Maple]]
| <code>e mod m</code>
| Luôn không âm
|-
| [[Mathematica]]
| <code>Mod[a, b]</code>
| Số chia
|-
| rowspan="2" | [[MATLAB]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| rowspan="2" | [[Maxima (phần mềm)|Maxima]]
| <code>mod</code>
| Số chia
|-
| <code>remainder</code>
| Số bị chia
|-
| [[Maya Embedded Language]]
| <code>%</code>
| Số bị chia
|-
| [[Microsoft Excel]]
| <code>=MOD()</code>
| Số chia
|-
| [[Minitab]]
| <code>MOD</code>
| Số chia
|-
| [[Korn shell|mksh]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Modula-2]]
| <code>MOD</code>
| Số chia
|-
| <code>REM</code>
| Số bị chia
|-
| [[MUMPS]]
| <code>#</code>
| Số chia
|-
| rowspan="2" | [[Netwide Assembler]] (NASM, NASMX)
| <code>%</code>
| toán tử modulo không dấu
|-
| <code>%%</code>
| toán tử modulo có dấu
|-
| [[Oberon (ngôn ngữ lập trình)|Oberon]]
| <code>MOD</code>
| Số chia{{ref|3}}
|-
| [[Object Pascal]], [[Delphi (ngôn ngữ lập trình)|Delphi]]
| <code>mod</code>
| Số bị chia
|-
| [[OCaml]]
| <code>mod</code>
| Số bị chia
|-
| [[Occam (ngôn ngữ lập trình)|Occam]]
| <code>\</code>
| Số bị chia
|-
| [[Pascal (ngôn ngữ lập trình)|Pascal]] (ISO-7185 and -10206)
| <code>mod</code>
| Luôn không âm
|-
| [[Perl]]
| <code>%</code>
| Số chia{{ref|1}}
|-
| [[PHP]]
| <code>%</code>
| Số bị chia
|-
| PIC [[BASIC]] Pro
| <code>\\</code>
| Số bị chia
|-
| [[PL/I]]
| <code>mod</code>
| Số chia (ANSI PL/I)
|-
| [[PowerShell]]
| <code>%</code>
| Số bị chia
|-
| [[OpenEdge Advanced Business Language|Progress]]
| <code>modulo</code>
| Số bị chia
|-
| rowspan="2"| [[Prolog]] (ISO 1995)
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| [[PureBasic]]
| <code>%,Mod(x,y)</code>
| Số bị chia
|-
| rowspan="2" | [[Python (ngôn ngữ lập trình)|Python]]
| <code>%</code>
| Số chia
|-
| <code>math.fmod</code>
| Số bị chia
|-
| [[Racket (ngôn ngữ lập trình)|Racket]]
| <code>remainder</code>
| Số bị chia
|-
| [[RealBasic]]
| <code>MOD</code>
| Số bị chia
|-
| [[R (ngôn ngữ lập trình)|R]]
| <code>%%</code>
| Số chia
|-
| [[Rexx]]
| <code>//</code>
| Số bị chia
|-
| [[RPG (ngôn ngữ lập trình)|RPG]]
| <code>%REM</code>
| Số bị chia
|-
| rowspan="2" | [[Ruby (ngôn ngữ lập trình)|Ruby]]
| <code>%, modulo()</code>
| Số chia
|-
| <code>remainder()</code>
| Số bị chia
|-
| [[Rust (ngôn ngữ lập trình)|Rust]]
| <code>%</code>
| Số bị chia
|-
| [[Scala (ngôn ngữ lập trình)|Scala]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Scheme (ngôn ngữ lập trình)|Scheme]]
| <code>modulo</code>
| Số chia
|-
| <code>remainder</code>
| Số bị chia
|-
| rowspan="2" | [[Scheme (ngôn ngữ lập trình)|Scheme]] R<sup>6</sup>RS
| <code>mod</code>
| Luôn không âm<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</code>
| Nearest to zero<ref name="r6rs"/>
|-
| rowspan="2" | [[Seed7]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| rowspan="2" | [[SenseTalk]]
| <code>modulo</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| rowspan="2" | [[Smalltalk]]
| <code>\\</code>
| Số chia
|-
| <code>rem:</code>
| Số bị chia
|-
| [[Parallax Propeller#Built in Spin byte code interpreter|Spin]]
| <code>//</code>
| Số chia
|-
| [[SQL]] ([[SQL:1999]])
| <code>mod(x,y)</code>
| Số bị chia
|-
| SQL (SQL:2012)
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Standard ML]]
| <code>mod</code>
| Số chia
|-
| <code>Int.rem</code>
| Số bị chia
|-
| [[Stata]]
| <code>mod(x,y)</code>
| Luôn không âm
|-
| [[Swift (ngôn ngữ lập trình)|Swift]]
| <code>%</code>
| Số bị chia
|-
| [[Tcl]]
| <code>%</code>
| Số chia
|-
| [[Torque (game engine)|Torque]]
| <code>%</code>
| Số bị chia
|-
| [[Turing (ngôn ngữ lập trình)|Turing]]
| <code>mod</code>
| Số chia
|-
| [[Verilog]] (2001)
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[VHDL]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| [[Vimscript|VimL]]
| <code>%</code>
| Số bị chia
|-
| [[Visual Basic]]
| <code>Mod</code>
| Số bị chia
|-
| [[x86 assembly language|x86 assembly]]
| <code>IDIV</code>
| Số bị chia
|-
|-
| rowspan="2" | [[XBase++]]
| <code>%</code>
| Số bị chia
|-
| <code>Mod()</code>
| Số chia
|-
| Z3 theorem prover
| <code>div</code>, <code>mod</code>
| Luôn không âm
|}

{| class="wikitable"
|+ Toán tử modulo của số chấm động trong nhiều ngôn ngữ lập trình
|-
! [[ngôn ngữ lập trình|Ngôn ngữ]]
! Toán tử
! abbr="Sign" | Kết quả có cùng dấu với
|-
| [[ABAP]]
| <code>MOD</code>
| Luôn không âm
|-
| [[C (ngôn ngữ lập trình)|C]] (ISO 1990)
| <code>fmod</code>
| Số bị chia<ref>{{Chú thích tạp chí|title=ISO/IEC 9899:1990: programming languages – C |publisher=[[International Organization for Standardization|ISO]], [[International Electrotechnical Commission|IEC]] |year=1990 |location=7.5.6.4 |postscript=<!--None-->}} "The <code>fmod</code> function returns the value <code>x - i * y</code>, for some integer <code>i</code> such that, if <code>y</code> is nonzero, the result as the same sign as <code>x</code> and magnitude less than the magnitude of <code>y</code>.".</ref>
|-
| rowspan="2" | [[C99|C (ISO 1999)]]
| <code>fmod</code>
| Số bị chia
|-
| <code>remainder</code>
| Gần với số 0
|-
| [[C++]] (ISO 1998)
| <code>std::fmod</code>
| Số bị chia
|-
| rowspan="2" | [[C++11|C++ (ISO 2011)]]
| <code>std::fmod</code>
| Số bị chia
|-
| <code>std::remainder</code>
| Gần với số 0
|-
| [[C Sharp (ngôn ngữ lập trình)|C#]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Common Lisp]]
| <code>mod</code>
| Số chia
|-
| <code>rem</code>
| Số bị chia
|-
| [[D (ngôn ngữ lập trình)|D]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Dart (ngôn ngữ lập trình)|Dart]]
| <code>%</code>
| Luôn không âm
|-
| remainder()
| Số bị chia
|-
| [[F Sharp (ngôn ngữ lập trình)|F#]]
| <code>%</code>
| Số bị chia
|-
| rowspan="2" | [[Fortran]]
| <code>mod</code>
| Số bị chia
|-
| <code>modulo</code>
| Số chia
|-
| [[Go (ngôn ngữ lập trình)|Go]]
| <code>math.Mod</code>
| Số bị chia
|-
| [[Haskell (ngôn ngữ lập trình)|Haskell]] (GHC)
| <code>Data.Fixed.mod'</code>
| Số chia
|-
| [[Java (ngôn ngữ lập trình)|Java]]
| <code>%</code>
| Số bị chia
|-
| [[JavaScript]]
| <code>%</code>
| Số bị chia
|-
|[[LabVIEW]]
|<code>mod</code>
| Số bị chia
|-
| [[Microsoft Excel]]
| <code>=MOD()</code>
| Số chia
|-
| [[OCaml]]
| <code>mod_float</code>
| Số bị chia
|-
| [[Perl]]
| <code>POSIX::fmod</code>
| Số bị chia
|-
| [[Perl6]]
| <code>%</code>
| Số chia
|-
| [[PHP]]
| <code>fmod</code>
| Số bị chia
|-
| rowspan="2"| [[Python (ngôn ngữ lập trình)|Python]]
| <code>%</code>
| Số chia
|-
| <code>math.fmod</code>
| Số bị chia
|-
| [[Rexx]]
| <code>//</code>
| Số bị chia
|-
| rowspan="2" | [[Ruby (ngôn ngữ lập trình)|Ruby]]
| <code>%, modulo()</code>
| Số chia
|-
| <code>remainder()</code>
| Số bị chia
|-
| rowspan="2" | [[Scheme (ngôn ngữ lập trình)|Scheme]] R<sup>6</sup>RS
| <code>flmod</code>
| Luôn không âm
|-
| <code>flmod0</code>
| Gần với số 0
|-
| [[Standard ML]]
| <code>Real.rem</code>
| Số bị chia
|-
| [[Swift (ngôn ngữ lập trình)|Swift]]
| <code>truncatingRemainder(dividingBy:)</code>
| Số bị chia
|-
| rowspan="2" | [[XBase++]] 
| <code>%</code>
| Số bị chia
|-
| <code>Mod()</code>
| Số chia
|}

==Xem thêm==
*[[Modulo (disambiguation)|Modulo (Chống nhầm lẫn)]] và [[modulo (jargon)|modulo (biệt ngữ)]] – nhiều cách sử dụng từ ''modulo'', tất cả đều phát sinh từ cuốn sách Nhập môn ''[[số học mô đun]]'' (tựa Anh:introduction of ''[[modular arithmetic]]'') của [[Carl F. Gauss]] năm 1801.
*[[Modular exponentiation|Lũy thừa Modular]]

==Chú thích==
* {{note|1}} Perl sử dụng toán tử modulo số học mà độc lập với máy tính. Để biết thêm ví dụ và các ngoại lệ, xem tài liệu Perl về toán tử nhân.<ref>[http://perldoc.perl.org/perlop.html#Multiplicative-Operators Perl documentation]</ref>
* {{note|2}} Trên phương diện toán học, hai lựa chọn này là hai trong số vô số lựa chọn có sẵn trong [[remainder#The inequality satisfied by the remainder|bất đẳng thức thỏa mãn bằng một [[số dư]]]]
* {{note|3}} Số chia phải là dương, nếu không không xác định.
* {{note|4}} Như được cài dặt trong ACUCOBOL, Micro Focus COBOL, và có thẻ là các ngôn ngữ khác
* {{note|5a}}{{note|5b}} Trật tự tham số đảo ngược, ví dụ, <code>α|ω</code> computes <math>\omega\bmod\alpha</math>, [[số dư]] khi chia <code>ω</code> cho <code>α</code>.

==Tham khảo==
{{Tham khảo}}

{{DEFAULTSORT:Modulo operation}}
[[Thể loại:Phép toán hai ngôi]]
[[Thể loại:Số học máy tính]]
[[Thể loại:Số học Modulo]]
[[Thể loại:Toán tử (lập trình)]]

[[de:Division mit Rest#Modulo]]