模除

模除（英語：modulo 有時也稱作 modulus），又稱模數、取模、取模運算等，它得出一個數除以另一個數的餘數。給定兩個正數：被除數 $a$ 和除數 $n$ ， $a\,\operatorname {modulo} \,n$ （通常縮寫為 $a{\bmod {n}}$ ），得到的是使用歐幾里得除法時的餘數。 $a{\bmod {1}}$ 所得之數被稱為 $a$ 的小數部份。

商數 ( $q$ ) 和餘數 ( $r$ ) 作為被除數 ( $a$ ) 的函數時的圖像。左側是除數為正的情況，右側除數為負。從上至下分別使用了：向零取整、向下取整和歐幾里得除法。

舉個例子：計算表達式 $5{\bmod {2}}$ 得到 $1$ ，因為 $5\div 2$ 的商為 $2$ 而餘數為 $1$ ；而 $9{\bmod {3}}$ 得到 $0$ ，因為 $9\div 3$ 的商為 $3$ 而餘數為 $0$ ；做除法不能整除時得到是有理數，平常使用的計算器採用了有限個數位的十進制表示法，它以小數點分隔整數部份和小數部份，比如 $5\div 2=2.5$ 。

雖然通常情況下模除的被除數 $a$ 和除數 $n$ 都是整數，但許多計算系統允許其他類型的數值運算，比如對浮點數取模。在所有計算系統中當被除數 $a$ 和除數 $n$ 都是正數時，結果的餘數 $r$ 的範圍為 $0\leq r<n$ ；而 $a{\bmod {0}}$ 經常是未定義的，在編程語言裡可能會導致除以零錯誤。當被除數 $a$ 或除數 $n$ 為負數時，不同的編程語言對結果有不同的處理。

各種定義

在數學中，取模運算的結果就是歐幾里德除法的餘數。當然也有許多其他的定義方式。計算機和計算器有許多種表示和儲存數字的方法，因此在不同的硬件環境下、不同的編程語言中，取模運算有着不同的定義。

幾乎所有的計算系統中， $a$ 除以 $n$ 得到商 $q$ 和餘數 $r$ 均滿足以下式子：

{\begin{aligned}&q\in \mathbb {Z} \\&a=nq+r\\&|r|<|n|\end{aligned}}

1

即使如此，當餘數非 $0$ 時，餘數的符號仍然是有歧義的：餘數非 $0$ 時，它的符號有兩種選擇，一個是正號而另一個是負號^[a]。通常情況下，在數論中總是選擇正餘數。但在編程中，選擇餘數的符號依賴於編程語言和被除數 $a$ 或除數 $n$ 的符號。在編程語言所定義的整數模除中，ISO/IEC標準Pascal^[1]和ALGOL 68^[2]，在計算出的餘數r為負數時，返回正數 $r+|n|$ 作為結果^[b]；另一些編程語言如ISO/IEC C90，當被除數 $a$ 或除數 $n$ 是負數時，C90標準並沒有做具體的規定，而是留給編譯器去定義並實現^[3]。在大多數系統中 $a{\bmod {0}}$ 是未定義的，雖然有些系統定義它就等於 $a$ 。更多詳情參見後續章節表格。

很多取模的實現都使用了「截斷除法」（英語：truncated division），商經由截尾函數來定義，商向零取整，結果等於普通除法所得的小數靠近 $0$ 方向的第一個整數：
$q=\operatorname {trunc} \left({\frac {a}{n}}\right)$

餘數和被除數符號一致：

$r=a-n\operatorname {trunc} \left({\frac {a}{n}}\right)$
高德納定義的「下取整除法」（英語：floored division）^[4]，商經由下取整函數來定義，商總是向負無窮取整，即使商已經是負數：
$q=\left\lfloor {\frac {a}{n}}\right\rfloor$

餘數和除數符號一致：

$r=a-n\left\lfloor {\frac {a}{n}}\right\rfloor$
Raymond T. Boute使用的歐幾里得除法定義中^[5]，要求滿足 $0\leq r<|n|$ ，在這種情況下：
$q=\operatorname {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}}$

這裡的 $\operatorname {sgn}$ 是符號函數，餘數總是非負數:

$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}}$
Common Lisp的round函數和IEEE 754（英語：IEEE 754-1985）使用「修約除法」（英語：rounded division），商經由修約函數 $\operatorname {round}$ （約半成偶）來定義為：
$q=\operatorname {round} \left({\frac {a}{n}}\right)$

當商為偶數時，餘數範圍是 ${\textstyle -{\frac {n}{2}}\leq r\leq {\frac {n}{2}}}$ ；當商為奇數時，餘數範圍是 ${\textstyle -{\frac {n}{2}}<r<{\frac {n}{2}}}$ ：

$r=a-n\operatorname {round} \left({\frac {a}{n}}\right)$
Common Lisp的ceiling函數使用「上取整除法」（英語：ceiling division），商經由上取整函數定義為：
$q=\left\lceil {\frac {a}{n}}\right\rceil$

餘數與除數有相反的符號：

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

記號

一些計算器有取模 $mod()$ 按鈕，很多編程語言裡也有類似的函數，通常像mod(a, n)這樣。有些語言也支持在表達式內使用%、mod或Mod作為取模或取余操作符，比如a % n或a mod n。

在一些沒有 $mod()$ 函數的環境中或許可使用等價的：a - (n * int(a/n))。這裡的int()函數事實上等價於截斷函數。

性質及恆等式

一些取模操作，經過分解和展開可以等同於其他數學運算。這在密碼學的證明中十分有用，例如：迪菲-赫爾曼密鑰交換。

恆等式：
- $(a{\bmod {n}}){\bmod {n}}=a{\bmod {n}}$
- 對所有的正數 $x$ 有： $n^{x}{\bmod {n}}=0$
- 如果 $p$ 是一個質數，且不為 $b$ 的因數，此時由費馬小定理有： $ab^{p-1}{\bmod {p}}=a{\bmod {p}}$
逆運算：
- $[(-a{\bmod {n}})+(a{\bmod {n}})]={\bmod {n}}=0$ .
- $b^{-1}{\bmod {n}}$ 表示模反元素。當且僅當 $b$ 與 $n$ 互質時，等式左側有定義： $[(b^{-1}{\bmod {n}})(b{\bmod {n}})]{\bmod {n}}=1$ 。
分配律：
- $(a+b){\bmod {n}}=[(a{\bmod {n}})+(b{\bmod {n}})]{\bmod {n}}$
- $ab{\bmod {n}}=[(a{\bmod {n}})(b{\bmod {n}})]{\bmod {n}}$
除法定義：僅當式子右側有定義時，即 $b$ 、 $n$ 互質時有： ${\frac {a}{b}}{\bmod {n}}=[(a{\bmod {n}})(b^{-1}{\bmod {n}})]{\bmod {n}}$ ，其他情況為未定義的。
乘法逆元： $[(ab{\bmod {n}})(b^{-1}{\bmod {n}})]{\bmod {n}}=a{\bmod {n}}$ .

編程語言實現

在各種編程語言中的模除運算
語言	算符	整數	浮點數	定義
ABAP	`MOD`	是	是	歐幾里得式
ActionScript	`%`	是	否	截斷
Ada	`mod`	是	否	下取整^[6]
Ada	`rem`	是	否	截斷^[6]
ALGOL 68	`÷×`, `mod`	是	否	類似歐幾里得式^[c]
AMPL	`mod`	是	否	截斷
APL	`\|`^[d]	是	是	下取整
AppleScript	`mod`	是	否	截斷
AutoLISP	`(rem d n)`	是	否	截斷
AWK	`%`	是	否	截斷
bash	`%`	是	否	截斷
BASIC	`Mod`	是	否	實現各異
bc	`%`	是	否	截斷
C C++	`%`, `div`	是	否	截斷^[e]
	`fmod` (C) `std::fmod` (C++)	否	是	截斷^[9]
	`remainder` (C) `std::remainder` (C++)	否	是	修約
C#	`%`	是	是	截斷
C#	`Math.IEEERemainder`	否	是	修約^[10]
Clarion（英語：Clarion (programming language)）	`%`	是	否	截斷
Clean	`rem`	是	否	截斷
Clojure	`mod`	是	否	下取整^[11]
Clojure	`rem`	是	否	截斷^[12]
COBOL	`FUNCTION MOD`	是	否	下取整^[13]
COBOL	`FUNCTION REM`	是	是	截斷^[13]
CoffeeScript	`%`	是	否	截斷
CoffeeScript	`%%`	是	否	下取整^[14]
ColdFusion	`%`, `MOD`	是	否	截斷
Common Intermediate Language	`rem` (有符號)	是	是	截斷^[15]
Common Intermediate Language	`rem.un` (無符號)	是	否	不適用
Common Lisp	`mod`	是	是	下取整
Common Lisp	`rem`	是	是	截斷
Crystal（英語：Crystal (programming language)）	`%`, `modulo`	是	是	下取整
Crystal（英語：Crystal (programming language)）	`remainder`	是	是	截斷
D	`%`	是	是	截斷^[16]
Dart	`%`	是	是	歐幾里得式^[17]
Dart	`remainder()`	是	是	截斷^[18]
Eiffel	`\\`	是	否	截斷
Elixir	`rem/2`	是	否	截斷^[19]
Elixir	`Integer.mod/2`	是	否	下取整^[20]
Elm	`modBy`	是	否	下取整^[21]
Elm	`remainderBy`	是	否	截斷^[22]
Erlang	`rem`	是	否	截斷
Erlang	`math:fmod/2`	否	是	截斷 (同於C)^[23]
Euphoria	`mod`	是	否	下取整
Euphoria	`remainder`	是	否	截斷
F#	`%`	是	是	截斷
F#	`Math.IEEERemainder`	否	是	修約^[10]
Factor	`mod`	是	否	截斷
FileMaker	`Mod`	是	否	下取整
Forth	`mod`	是	否	實現定義
	`fm/mod`	是	否	下取整
	`sm/rem`	是	否	截斷
Fortran	`mod`	是	是	截斷
Fortran	`modulo`	是	是	下取整
Frink（英語：Frink (programming language)）	`mod`	是	否	下取整
Full BASIC（英語：Full BASIC）	`MOD`	是	是	下取整^[24]
Full BASIC（英語：Full BASIC）	`REMAINDER`	是	是	截斷^[25]
GLSL	`%`	是	否	未定義^[26]
GLSL	`mod`	否	是	下取整^[27]
GameMaker Studio (GML)	`mod`, `%`	是	否	截斷
GDScript (Godot)	`%`	是	否	截斷
	`fmod`	否	是	截斷
	`posmod`	是	否	歐幾里得式
	`fposmod`	否	是	歐幾里得式
Go	`%`	是	否	截斷^[28]
	`math.Mod`	否	是	截斷^[29]
	`big.Int.Mod`	是	否	歐幾里得式^[30]
	`big.Int.Rem`	是	否	截斷^[31]
Groovy	`%`	是	否	截斷
Haskell	`mod`	是	否	下取整^[32]
	`rem`	是	否	截斷^[32]
	`Data.Fixed.mod'` (GHC)	否	是	下取整
Haxe	`%`	是	否	截斷
HLSL	`%`	是	是	未定義^[33]
J	`\|`^[d]	是	否	下取整
Java	`%`	是	是	截斷
Java	`Math.floorMod`	是	否	下取整
JavaScript TypeScript	`%`	是	是	截斷
Julia	`mod`	是	是	下取整^[34]
Julia	`%`, `rem`	是	是	截斷^[35]
Kotlin	`%`, `rem`	是	是	截斷^[36]
Kotlin	`mod`	是	是	下取整^[37]
ksh	`%`	是	否	截斷 (同於POSIX sh)
ksh	`fmod`	否	是	截斷
LabVIEW	`mod`	是	是	截斷
LibreOffice	`=MOD()`	是	否	下取整
Logo	`MODULO`	是	否	下取整
Logo	`REMAINDER`	是	否	截斷
Lua 5	`%`	是	是	下取整
Lua 4	`mod(x,y)`	是	是	截斷
Liberty BASIC（英語：Liberty BASIC）	`MOD`	是	否	截斷
Mathcad	`mod(x,y)`	是	否	下取整
Maple	`e mod m` (默認), `modp(e, m)`	是	否	歐幾里得式
	`mods(e, m)`	是	否	修約
	`frem(e, m)`	是	是	修約
Mathematica	`Mod[a, b]`	是	否	下取整
MATLAB	`mod`	是	否	下取整
MATLAB	`rem`	是	否	截斷
Maxima	`mod`	是	否	下取整
Maxima	`remainder`	是	否	截斷
Maya Embedded Language（英語：Maya Embedded Language）	`%`	是	否	截斷
Microsoft Excel	`=MOD()`	是	是	下取整
Minitab	`MOD`	是	否	下取整
Modula-2	`MOD`	是	否	下取整
Modula-2	`REM`	是	否	截斷
MUMPS（英語：MUMPS）	`#`	是	否	下取整
Netwide Assembler (NASM, NASMX)	`%`, `div` (無符號)	是	否	不適用
Netwide Assembler (NASM, NASMX)	`%%` (有符號)	是	否	實現定義^[38]
Nim	`mod`	是	否	截斷
Oberon	`MOD`	是	否	類似下取整^[f]
Objective-C	`%`	是	否	截斷 (同於C99)
Object Pascal, Delphi	`mod`	是	否	截斷
OCaml	`mod`	是	否	截斷^[39]
OCaml	`mod_float`	否	是	截斷^[40]
Occam	`\`	是	否	截斷
Pascal (ISO-7185和ISO-10206)	`mod`	是	否	類似歐幾里得式^[c]
Perl	`%`	是	否	下取整^[g]
Perl	`POSIX::fmod`	否	是	截斷
PHP	`%`	是	否	截斷^[42]
PHP	`fmod`	否	是	截斷^[43]
PIC BASIC Pro	`\\`	是	否	截斷
PL/I	`mod`	是	否	下取整 (ANSI PL/I)
PowerShell	`%`	是	否	截斷
Programming Code (PRC（英語：PRC (Palm OS)）)	`MATH.OP - 'MOD; (\)'`	是	否	未定義
Progress（英語：OpenEdge Advanced Business Language）	`modulo`	是	否	截斷
Prolog (ISO 1995^[44])	`mod`	是	否	下取整
Prolog (ISO 1995^[44])	`rem`	是	否	截斷
PureBasic	`%`, `Mod(x,y)`	是	否	截斷
PureScript	`mod`	是	否	歐幾里得式^[45]
Pure Data	`%`	是	否	截斷 (同於C)
Pure Data	`mod`	是	否	下取整
Python	`%`	是	是	下取整
	`math.fmod`	否	是	截斷
	`math.remainder`	否	是	修約
Q#	`%`	是	否	截斷^[46]
R	`%%`	是	是	下取整^[47]
Racket	`modulo`	是	否	下取整
Racket	`remainder`	是	否	截斷
Raku	`%`	否	是	下取整
RealBasic（英語：RealBasic）	`MOD`	是	否	截斷
Reason	`mod`	是	否	截斷
Rexx	`//`	是	是	截斷
RPG（英語：IBM RPG）	`%REM`	是	否	截斷
Ruby	`%`, `modulo()`	是	是	下取整
Ruby	`remainder()`	是	是	截斷
Rust	`%`	是	是	截斷
Rust	`rem_euclid()`	是	是	歐幾里得式^[48]
SAS	`MOD`	是	否	截斷
Scala	`%`	是	是	截斷
Scheme	`modulo`	是	否	下取整
Scheme	`remainder`	是	否	截斷
Scheme R⁶RS	`mod`	是	否	歐幾里得式^[49]
	`mod0`	是	否	修約^[49]
	`flmod`	否	是	歐幾里得式
	`flmod0`	否	是	修約
Scratch	`mod`	是	是	下取整
Seed7（英語：Seed7）	`mod`	是	是	下取整
Seed7（英語：Seed7）	`rem`	是	是	截斷
SenseTalk（英語：SenseTalk）	`modulo`	是	否	下取整
SenseTalk（英語：SenseTalk）	`rem`	是	否	截斷
Unix shell (包括bash、ash等。)	`%`	是	否	截斷 (同於C)^[50]
Smalltalk	`\\`	是	否	下取整
Smalltalk	`rem:`	是	否	截斷
Snap!	`mod`	是	否	下取整
Spin（英語：Parallax Propeller#Built in Spin byte code interpreter）	`//`	是	否	下取整
Solidity	`%`	是	否	下取整
SQL (SQL:1999（英語：SQL:1999）)	`mod(x,y)`	是	否	截斷
SQL (SQL:2011（英語：SQL:2011）)	`%`	是	否	截斷
Standard ML	`mod`	是	否	下取整
	`Int.rem`	是	否	截斷
	`Real.rem`	否	是	截斷
Stata	`mod(x,y)`	是	否	歐幾里得式
Swift	`%`	是	否	截斷^[51]
	`remainder(dividingBy:)`	否	是	修約^[52]
	`truncatingRemainder(dividingBy:)`	否	是	截斷^[53]
Tcl	`%`	是	否	下取整
Tcl	`fmod()`	否	是	截斷 (同於C)
tcsh	`%`	是	否	截斷
Torque（英語：Torque (game engine)）	`%`	是	否	截斷
Turing（英語：Turing (programming language)）	`mod`	是	否	下取整
Verilog (2001)	`%`	是	否	截斷
VHDL	`mod`	是	否	下取整
VHDL	`rem`	是	否	截斷
VimL	`%`	是	否	截斷
Visual Basic	`Mod`	是	否	截斷
WebAssembly	`i32.rem_u`, `i64.rem_u` (無符號)	是	否	不適用
WebAssembly	`i32.rem_s`, `i64.rem_s` (有符號)	是	否	截斷^[54]
x86 assembly（英語：x86 assembly language）	`DIV`(無符號)	是	否	不適用
x86 assembly（英語：x86 assembly language）	`IDIV`(有符號)	是	否	截斷
XBase++（英語：XBase++）	`%`	是	是	截斷
XBase++（英語：XBase++）	`Mod()`	是	是	下取整
Zig	`%`, `@mod`, `@rem`	是	是	截斷^[55]
Z3 theorem prover（英語：Z3 Theorem Prover）	`div`, `mod`	是	否	歐幾里得式

此外，很多計算機系統提供divmod功能，它同時產生商和餘數。例子x86架構的IDIV指令，C編程語言的div()函數，和Python的divmod()函數。

常見錯誤

當取模的結果與被除數符號相同時，可能會導致意想不到的錯誤。

舉個例子：如果需要判斷一個整數是否為奇數，有人可能會測試這個數除 2 的餘數是否為 1：

bool is_odd(int n) {
    return n % 2 == 1;
}

但在一個取模結果與被除數符號相同的編程語言裡，這樣做是錯的。因為當被除數 $n$ 是奇數且為負數時， $n{\bmod {2}}$ 得到 −1，此時函數返回「假」。

一種正確的實現是測試取模結果是否為 0，因為餘數為 0 時沒有符號的問題：

bool is_odd(int n) {
    return n % 2 != 0;
}

或者考慮餘數的符號，有兩種情況：餘數可能為 1 或 -1。

bool is_odd(int n) {
    return n % 2 == 1 || n % 2 == -1;
}

性能問題

可以通過依次計算帶餘數的除法實現取模操作。特殊情況下，如某些硬件上，存在更快的實現。例如：2 的 n 次冪的模，可以通過逐位與運算實現：

x % 2ⁿ == x & (2ⁿ - 1)

例子，假定 $x$ 為正數：

x % 2 == x & 1

x % 4 == x & 3

x % 8 == x & 7

在進行位操作比取模操作效率更高的設備或軟件環境中，以上形式的取模運算速度更快。^[56]

編譯器可以自動識別出對 2 的 n 次冪取模的表達式，自動將其優化為 expression & (constant-1)。這樣可以在兼顧效率的情況下寫出更整潔的代碼。這個優化在取模結果與被除數符號一致的語言中（包括 C 語言）不能使用，除非被除數是無符號整數。這是因為如果被除數是負數，則結果也是負數，但 expression & (constant-1) 總是正數，進行這樣的優化就會導致錯誤，無符號整數則沒有這個問題。

用途

取模運算可用於判斷一個數是否能被另一個數整除。對 2 取模即可判斷整數的奇偶性；從 2 到 $n-1$ 取模則可判斷一個數是否為質數。
進制之間的轉換。
用於求取最大公約數的輾轉相除法使用取模運算。
密碼學中的應用：從古老的凱撒密碼到現代常用的RSA、橢圓曲線密碼，它們的實現過程均使用了取模運算。

參見

模 (消歧義)和模 (術語)（英語：modulo (jargon)） —— 「模數（Modulo）」這個詞的許多用法，都是 1801 年卡爾·弗里德里希·高斯引入模算數時產生的。
模冪運算
同餘

腳註

^ 從數學上講，正和負只是滿足不等式的無窮多個解中的兩個。
^ ISO Pascal要求模除運算的除數n為正數。
^ ^3.0 ^3.1 按Boute的研討，ISO Pascal和Algol68的div和mod定義不能維持除法恆等式 $D = d \cdot (D / d) + D % d$ 。
^ ^4.0 ^4.1 α|ω計算 $\omega {\bmod {\alpha }}$ ，得出ω除以α的餘數。
^ C99和C++11將%的行為定義為截斷。^[7]此前的標準將其行為留給實現定義。^[8]
^ 除數必須是整數，否則未定義。
^ Perl通常使用機器無關的算術模除運算。其例子和異常，參見關於乘法運算的Perl文檔。^[41]

參考文獻

^ ISO/IEC 7185, Information Technology—Programming Languages–Pascal. International Standard, 2nd ed. (PDF). ISO/IEC 7185, 1990 (E).
A term of the form i div j shall be an error if j is zero; otherwise, the value of i div j shall be such that

abs(i) - abs(j) < abs((i div j) * j) <= abs(i)
where the value shall be zero if abs(i) < abs(j); otherwise, the sign of the value shall be positive if i and j have the same sign and negative if i and j have different signs.
A term of the form i mod j shall be an error if j is zero or negative; otherwise, the value of i mod j shall be that value of (i - (k * j)) for integral k such that 0 <= i mod j < j.
NOTE 2 — Only for i >= 0 and j > 0 does the relation (i div j) * j + i mod j = i hold.
Kathleen Jensen, Niklaus Wirth. PASCAL User Manual and Report － ISO Pascal Standard (PDF). 1991.

div   divide and truncate (i.e., value is not rounded)

mod   modulus: let Remainder = A - (A div B) * B;
  if Remainder < 0 then A mod B = Remainder + B

  otherwise A mod B = Remainder

^ 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. Revised Report on the Algorithmic Language Algol 68. IFIP W.G. 2.1.
10.2.3.3. Operations on integral operands
……

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);

^
Jones, Derek M. The New C Standard: An Economic and Cultural Commentary (PDF). Addison-Wesley. 2003 [2018-07-11]. ISBN 9780201709179. （原始內容 (PDF)存檔於2018-07-11）（英語）.
C99 reflects almost universal processor behavior (as does the Fortran Standard). This definition truncates toward zero and the expression (-(a/b) == (-a)/b) && (-(a/b) == a/(-b)) is always true. It also means that the absolute value of the result does not depend on the signs of the operands; for example:

+10 / +3 == +3 +10 % +3 == +1 -10 / +3 == -3 -10 % +3 == -1
+10 / -3 == -3 +10 % -3 == +1 -10 / -3 == +3 -10 % -3 == -1
C90

When integers are divided and the division is inexact, if both operands are positive the result of the / operator is the largest integer less than the algebraic quotient and the result of the % operator is positive. If either operand is negative, whether the result of the / 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 % operator.
If either operand is negative, the behavior may differ between C90 and C99, depending on the implementation-defined behavior of the C90 implementation.
#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"); }
Quoting from the C9X Revision Proposal, WG14/N613, that proposed this change:

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.

^ Knuth, Donald. E. The Art of Computer Programming. Addison-Wesley. 1972 （英語）.
If

x

is any real number, we write

\left\lfloor x\right\rfloor

= the greatest integer less than or equal to

x

(the floor of

x

);

\left\lceil x\right\rceil

= the least integer greater than or equal to

x

(the ceiling of

x

).

……
The following formulas and examples are easily verified:
……

$\left\lceil x\right\rceil =\left\lfloor x\right\rfloor$	if and only if $x$ is an integer,
$\left\lceil x\right\rceil =\left\lfloor x\right\rfloor +1$	if and only if $x$ is not an integer;
$\left\lfloor -x\right\rfloor =-\left\lceil x\right\rceil$ ;	$x-1<\left\lfloor x\right\rfloor \leq x\leq \left\lceil x\right\rceil <x+1$ .

……
If $x$ and $y$ are any real numbers, we define the following binary operation:

x{\bmod {y}}=x-y\left\lfloor x/y\right\rfloor ,\ {\text{if }}y\neq 0

;

x{\bmod {0}}=x

. (1)

From this definition we can see that, when $y\neq 0$ ,

0\leq {\frac {x}{y}}-\left\lfloor {\frac {x}{y}}\right\rfloor ={\frac {x{\bmod {y}}}{y}}<1

. (2)

Consequently
a) if $y>0$ , then $0\leq x{\bmod {y}}<y$ ;
b) if $y<0$ , then $0\geq x{\bmod {y}}>y$ ;
c) the quantity $x-(x{\bmod {y}})$ is an integral multiple of $y$ .
We call $x{\bmod {y}}$ the remainder when $x$ is divided by $y$ ; similarly, we call $\left\lfloor x/y\right\rfloor$ the quotient.
When $x$ and $y$ are integers, 「 ${\text{mod}}$ 」 is therefore a familiar operation:

5{\bmod {3}}=2

,

18{\bmod {3}}=0

,

-2{\bmod {3}}=1

. (3)

We have $x{\bmod {y}}=0$ if and only if $x$ is a multiple of $y$ , that is, if and only if $x$ is divisible by $y$ . The notation $y\backslash x$ , read 「 $y$ divides $x$ ,」 means that $y$ is a positive integer and $x{\bmod {y}}=0$ .
The 「 ${\text{mod}}$ 」 operation is useful also when $x$ and $y$ take arbitrary real values. For example, with trigonometric functions we can write

\tan x=\tan(x{\bmod {\pi }})

.

The quantity $x{\bmod {1}}$ is the fractional part of $x$ ; we have, by Eq. (1),

x=\left\lfloor x\right\rfloor +(x{\bmod {1}})

.

^ Boute, Raymond T. The Euclidean definition of the functions div and mod. ACM Transactions on Programming Languages and Systems (ACM Press (New York, NY, USA)). April 1992, 14 (2): 127–144. doi:10.1145/128861.128862 （英語）.
Let us recall Euclid’s theorem.

THEOREM. For any real numbers $D$ and $d$ with $d\neq 0$ , there exists a unique pair of numbers $q,r$ satisfying the following conditions:

(a) $q\in \mathbb {Z}$ ;

(b) $D=d\cdot q+r$ ;

(c) $0\leq r<|d|$ .
For the particular case of integers, the conditions (a)-(c) correspond to part of the axioms for Euclidean rings [9].
With the notational conventions of the theorem, we define $D\operatorname {div} d=q$ and $D{\bmod {d}}=r$ . Clearly the correspondingly labeled conditions are satisfied.
Properties

${\begin{aligned}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{aligned}}$
where $J=\operatorname {sign} d$ and $I$ is as defined earlier. ( $I={\text{if }}D/d\in \mathbb {Z} {\text{ then }}0{\text{ else }}1$ )
^ ^6.0 ^6.1 ISO/IEC 8652:2012 - Information technology — Programming languages — Ada. ISO, IEC. 2012. sec. 4.5.5 Multiplying Operators.
^ C99 specification (ISO/IEC 9899:TC2) (PDF). sec. 6.5.5 Multiplicative operators. 2005-05-06 [16 August 2018].
^ ISO/IEC 14882:2003: Programming languages – C++. International Organization for Standardization (ISO), International Electrotechnical Commission (IEC). 2003. sec. 5.6.4. 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
^ ISO/IEC 9899:1990: Programming languages – C. ISO, IEC. 1990. sec. 7.5.6.4. The $fmod$ function returns the value $x - i * y$ , for some integer $i$ such that, if $y$ is nonzero, the result has the same sign as $x$ and magnitude less than the magnitude of $y$ .
^ ^10.0 ^10.1 dotnet-bot. Math.IEEERemainder(Double, Double) Method (System). Microsoft Learn. [2022-10-04] （美國英語）.
^ clojure.core - Clojure v1.10.3 API documentation. clojure.github.io. [2022-03-16].
^ clojure.core - Clojure v1.10.3 API documentation. clojure.github.io. [2022-03-16].
^ ^13.0 ^13.1 ISO/IEC JTC 1/SC 22/WG 4. ISO/IEC 1989:2023 – Programming language COBOL . ISO. January 2023.
^ CoffeeScript operators
^ ISO/IEC JTC 1/SC 22. ISO/IEC 23271:2012 — Information technology — Common Language Infrastructure (CLI). ISO. February 2012. §§ III.3.55–56.
^ Expressions - D Programming Language. dlang.org. [2021-06-01].
^ operator % method - num class - dart:core library - Dart API. api.dart.dev. [2021-06-01].
^ remainder method - num class - dart:core library - Dart API. api.dart.dev. [2021-06-01].
^ Kernel — Elixir v1.11.3. hexdocs.pm. [2021-01-28].
^ Integer — Elixir v1.11.3. hexdocs.pm. [2021-01-28].
^ Basics - core 1.0.5. package.elm-lang.org. [2022-03-16].
^ Basics - core 1.0.5. package.elm-lang.org. [2022-03-16].
^ Erlang -- math. erlang.org. [2021-06-01].
^ ANSI. Programming Languages — Full BASIC. New York: American National Standards Institute. 28 January 1987. § 5.4.4. X modulo Y, i.e., X-Y*INT(X/Y).
^ ANSI. Programming Languages — Full BASIC. New York: American National Standards Institute. 28 January 1987. § 5.4.4. The remainder function, i.e., X-Y*IP(X/Y).
^ GLSL Language Specification, Version 4.50.7 (PDF). section 5.9 Expressions. If both operands are non-negative, then the remainder is non-negative. Results are undefined if one or both operands are negative.
^ GLSL Language Specification, Version 4.50.7 (PDF). section 8.3 Common Functions.
^ The Go Programming Language Specification - The Go Programming Language. go.dev. [2022-02-28].
^ math package - math - pkg.go.dev. pkg.go.dev. [2022-02-28].
^ big package - math/big - pkg.go.dev. pkg.go.dev. [2022-02-28].
^ big package - math/big - pkg.go.dev. pkg.go.dev. [2024-04-12].
^ ^32.0 ^32.1 6 Predefined Types and Classes. www.haskell.org. [2022-05-22].
^ Operators. Microsoft. [2021-07-19]. 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.
^ Mathematics · The Julia Language. docs.julialang.org. [2021-11-20].
^ Mathematics · The Julia Language. docs.julialang.org. [2021-11-20].
^ rem - Kotlin Programming Language. Kotlin. [2021-05-05] （英語）.
^ mod - Kotlin Programming Language. Kotlin. [2021-05-05] （英語）.
^ Chapter 3: The NASM Language. NASM - The Netwide Assembler version 2.15.05.
^ OCaml library : Stdlib. ocaml.org. [2022-02-19].
^ OCaml library : Stdlib. ocaml.org. [2022-02-19].
^ Perl documentation
^ PHP: Arithmetic Operators - Manual. www.php.net. [2021-11-20].
^ PHP: fmod - Manual. www.php.net. [2021-11-20].
^ ISO 1995
^ EuclideanRing.
^ QuantumWriter. Expressions. docs.microsoft.com. [2018-07-11] （美國英語）.
^ R: Arithmetic Operators. search.r-project.org. [2022-12-24].
^ F32 - Rust.
^ ^49.0 ^49.1 r6rs.org
^ Shell Command Language. pubs.opengroup.org. [2021-02-05].
^ Apple Developer Documentation. developer.apple.com. [2021-11-20].
^ Apple Developer Documentation. developer.apple.com. [2021-11-20].
^ Apple Developer Documentation. developer.apple.com. [2021-11-20].
^ Rossberg, Andreas (編). WebAssembly Core Specification: Version 2.0. World Wide Web Consortium. § 4.3.2 Integer Operations. 19 April 2022.
^ Zig Documentation. Zig Programming Language. [2022-12-18].
^ Horvath, Adam. Faster division and modulo operation - the power of two. July 5, 2012. （原始內容存檔於2018-03-05）（英語）.

[1] 從數學上講，正和負只是滿足不等式的無窮多個解中的兩個。

[4] ISO Pascal要求模除運算的除數n為正數。

[pascal&algol68-9] 3.0 ^3.1 按Boute的研討，ISO Pascal和Algol68的div和mod定義不能維持除法恆等式 $D = d \cdot (D / d) + D % d$ 。

[rev-10] 4.0 ^4.1 α|ω計算 $\omega {\bmod {\alpha }}$ ，得出ω除以α的餘數。

[c-13] C99和C++11將%的行為定義為截斷。^[7]此前的標準將其行為留給實現定義。^[8]

[44] 除數必須是整數，否則未定義。

[48] Perl通常使用機器無關的算術模除運算。其例子和異常，參見關於乘法運算的Perl文檔。^[41]

[2] ISO/IEC 7185, Information Technology—Programming Languages–Pascal. International Standard, 2nd ed. (PDF). ISO/IEC 7185, 1990 (E).
A term of the form i div j shall be an error if j is zero; otherwise, the value of i div j shall be such that

abs(i) - abs(j) < abs((i div j) * j) <= abs(i)
where the value shall be zero if abs(i) < abs(j); otherwise, the sign of the value shall be positive if i and j have the same sign and negative if i and j have different signs.
A term of the form i mod j shall be an error if j is zero or negative; otherwise, the value of i mod j shall be that value of (i - (k * j)) for integral k such that 0 <= i mod j < j.
NOTE 2 — Only for i >= 0 and j > 0 does the relation (i div j) * j + i mod j = i hold.
Kathleen Jensen, Niklaus Wirth. PASCAL User Manual and Report － ISO Pascal Standard (PDF). 1991.

div divide and truncate (i.e., value is not rounded)

mod modulus: let Remainder = A - (A div B) * B;
if Remainder < 0 then A mod B = Remainder + B

otherwise A mod B = Remainder

[3] 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. Revised Report on the Algorithmic Language Algol 68. IFIP W.G. 2.1.
10.2.3.3. Operations on integral operands
……

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);

[C-CPP-Std-5] Jones, Derek M. The New C Standard: An Economic and Cultural Commentary (PDF). Addison-Wesley. 2003 [2018-07-11]. ISBN 9780201709179. （原始內容 (PDF)存檔於2018-07-11）（英語）.
C99 reflects almost universal processor behavior (as does the Fortran Standard). This definition truncates toward zero and the expression (-(a/b) == (-a)/b) && (-(a/b) == a/(-b)) is always true. It also means that the absolute value of the result does not depend on the signs of the operands; for example:

+10 / +3 == +3 +10 % +3 == +1 -10 / +3 == -3 -10 % +3 == -1
+10 / -3 == -3 +10 % -3 == +1 -10 / -3 == +3 -10 % -3 == -1
C90

When integers are divided and the division is inexact, if both operands are positive the result of the / operator is the largest integer less than the algebraic quotient and the result of the % operator is positive. If either operand is negative, whether the result of the / 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 % operator.
If either operand is negative, the behavior may differ between C90 and C99, depending on the implementation-defined behavior of the C90 implementation.

#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"); }
Quoting from the C9X Revision Proposal, WG14/N613, that proposed this change:

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.

[6] Knuth, Donald. E. The Art of Computer Programming. Addison-Wesley. 1972 （英語）.
If $x$ is any real number, we write

$\left\lfloor x\right\rfloor$ = the greatest integer less than or equal to $x$ (the floor of $x$ );

$\left\lceil x\right\rceil$ = the least integer greater than or equal to $x$ (the ceiling of $x$ ).
……
The following formulas and examples are easily verified:
……

$\left\lceil x\right\rceil =\left\lfloor x\right\rfloor$ if and only if $x$ is an integer,

$\left\lceil x\right\rceil =\left\lfloor x\right\rfloor +1$ if and only if $x$ is not an integer;

$\left\lfloor -x\right\rfloor =-\left\lceil x\right\rceil$ ; $x-1<\left\lfloor x\right\rfloor \leq x\leq \left\lceil x\right\rceil <x+1$ .

……
If $x$ and $y$ are any real numbers, we define the following binary operation:

$x{\bmod {y}}=x-y\left\lfloor x/y\right\rfloor ,\ {\text{if }}y\neq 0$ ; $x{\bmod {0}}=x$ . (1)

From this definition we can see that, when $y\neq 0$ ,

$0\leq {\frac {x}{y}}-\left\lfloor {\frac {x}{y}}\right\rfloor ={\frac {x{\bmod {y}}}{y}}<1$ . (2)

Consequently
a) if $y>0$ , then $0\leq x{\bmod {y}}<y$ ;
b) if $y<0$ , then $0\geq x{\bmod {y}}>y$ ;
c) the quantity $x-(x{\bmod {y}})$ is an integral multiple of $y$ .
We call $x{\bmod {y}}$ the remainder when $x$ is divided by $y$ ; similarly, we call $\left\lfloor x/y\right\rfloor$ the quotient.
When $x$ and $y$ are integers, 「 ${\text{mod}}$ 」 is therefore a familiar operation:

$5{\bmod {3}}=2$ , $18{\bmod {3}}=0$ , $-2{\bmod {3}}=1$ . (3)

We have $x{\bmod {y}}=0$ if and only if $x$ is a multiple of $y$ , that is, if and only if $x$ is divisible by $y$ . The notation $y\backslash x$ , read 「 $y$ divides $x$ ,」 means that $y$ is a positive integer and $x{\bmod {y}}=0$ .
The 「 ${\text{mod}}$ 」 operation is useful also when $x$ and $y$ take arbitrary real values. For example, with trigonometric functions we can write

$\tan x=\tan(x{\bmod {\pi }})$ .

The quantity $x{\bmod {1}}$ is the fractional part of $x$ ; we have, by Eq. (1),

$x=\left\lfloor x\right\rfloor +(x{\bmod {1}})$ .

[7] Boute, Raymond T. The Euclidean definition of the functions div and mod. ACM Transactions on Programming Languages and Systems (ACM Press (New York, NY, USA)). April 1992, 14 (2): 127–144. doi:10.1145/128861.128862 （英語）.
Let us recall Euclid’s theorem.

THEOREM. For any real numbers $D$ and $d$ with $d\neq 0$ , there exists a unique pair of numbers $q,r$ satisfying the following conditions:

(a) $q\in \mathbb {Z}$ ;

(b) $D=d\cdot q+r$ ;

(c) $0\leq r<|d|$ .
For the particular case of integers, the conditions (a)-(c) correspond to part of the axioms for Euclidean rings [9].
With the notational conventions of the theorem, we define $D\operatorname {div} d=q$ and $D{\bmod {d}}=r$ . Clearly the correspondingly labeled conditions are satisfied.
Properties

${\begin{aligned}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{aligned}}$
where $J=\operatorname {sign} d$ and $I$ is as defined earlier. ( $I={\text{if }}D/d\in \mathbb {Z} {\text{ then }}0{\text{ else }}1$ )

[Ada-8] 6.0 ^6.1 ISO/IEC 8652:2012 - Information technology — Programming languages — Ada. ISO, IEC. 2012. sec. 4.5.5 Multiplying Operators.

[C99-11] C99 specification (ISO/IEC 9899:TC2) (PDF). sec. 6.5.5 Multiplicative operators. 2005-05-06 [16 August 2018].

[12] ISO/IEC 14882:2003: Programming languages – C++. International Organization for Standardization (ISO), International Electrotechnical Commission (IEC). 2003. sec. 5.6.4. 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

[14] ISO/IEC 9899:1990: Programming languages – C. ISO, IEC. 1990. sec. 7.5.6.4. The $fmod$ function returns the value $x - i * y$ , for some integer $i$ such that, if $y$ is nonzero, the result has the same sign as $x$ and magnitude less than the magnitude of $y$ .

[.NET-15] 10.0 ^10.1 dotnet-bot. Math.IEEERemainder(Double, Double) Method (System). Microsoft Learn. [2022-10-04] （美國英語）.

[16] ure.core - Clojure v1.10.3 API documentation. clojure.github.io. [2022-03-16].

[17] ure.core - Clojure v1.10.3 API documentation. clojure.github.io. [2022-03-16].

[isocobol-18] 13.0 ^13.1 ISO/IEC JTC 1/SC 22/WG 4. ISO/IEC 1989:2023 – Programming language COBOL . ISO. January 2023.

[CoffeeScript-19] CoffeeScript operators

[20] ISO/IEC JTC 1/SC 22. ISO/IEC 23271:2012 — Information technology — Common Language Infrastructure (CLI). ISO. February 2012. §§ III.3.55–56.

[21] Expressions - D Programming Language. dlang.org. [2021-06-01].

[22] rator % method - num class - dart:core library - Dart API. api.dart.dev. [2021-06-01].

[23] remainder method - num class - dart:core library - Dart API. api.dart.dev. [2021-06-01].

[24] Kernel — Elixir v1.11.3. hexdocs.pm. [2021-01-28].

[25] Integer — Elixir v1.11.3. hexdocs.pm. [2021-01-28].

[26] Basics - core 1.0.5. package.elm-lang.org. [2022-03-16].

[27] Basics - core 1.0.5. package.elm-lang.org. [2022-03-16].

[28] Erlang -- math. erlang.org. [2021-06-01].

[29] ANSI. Programming Languages — Full BASIC. New York: American National Standards Institute. 28 January 1987. § 5.4.4. X modulo Y, i.e., X-Y*INT(X/Y).

[30] ANSI. Programming Languages — Full BASIC. New York: American National Standards Institute. 28 January 1987. § 5.4.4. The remainder function, i.e., X-Y*IP(X/Y).

[31] GLSL Language Specification, Version 4.50.7 (PDF). section 5.9 Expressions. If both operands are non-negative, then the remainder is non-negative. Results are undefined if one or both operands are negative.

[32] GLSL Language Specification, Version 4.50.7 (PDF). section 8.3 Common Functions.

[33] The Go Programming Language Specification - The Go Programming Language. go.dev. [2022-02-28].

[34] th package - math - pkg.go.dev. pkg.go.dev. [2022-02-28].

[35] - math/big - pkg.go.dev. pkg.go.dev. [2022-02-28].

[36] - math/big - pkg.go.dev. pkg.go.dev. [2024-04-12].

[Haskell_2010-37] 32.0 ^32.1 6 Predefined Types and Classes. www.haskell.org. [2022-05-22].

[38] Operators. Microsoft. [2021-07-19]. 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.

[39] Mathematics · The Julia Language. docs.julialang.org. [2021-11-20].

[40] Mathematics · The Julia Language. docs.julialang.org. [2021-11-20].

[41] rem - Kotlin Programming Language. Kotlin. [2021-05-05] （英語）.

[42] - Kotlin Programming Language. Kotlin. [2021-05-05] （英語）.

[43] Chapter 3: The NASM Language. NASM - The Netwide Assembler version 2.15.05.

[45] OCaml library : Stdlib. ocaml.org. [2022-02-19].

[46] OCaml library : Stdlib. ocaml.org. [2022-02-19].

[47] Perl documentation

[49] PHP: Arithmetic Operators - Manual. www.php.net. [2021-11-20].

[50] PHP: fmod - Manual. www.php.net. [2021-11-20].

[51] ISO 1995

[purescript_euclid-52] EuclideanRing.

[53] QuantumWriter. Expressions. docs.microsoft.com. [2018-07-11] （美國英語）.

[54] R: Arithmetic Operators. search.r-project.org. [2022-12-24].

[rust_rem_euclid-55] F32 - Rust.

[r6rs-56] 49.0 ^49.1 r6rs.org

[57] Shell Command Language. pubs.opengroup.org. [2021-02-05].

[58] Apple Developer Documentation. developer.apple.com. [2021-11-20].

[59] Apple Developer Documentation. developer.apple.com. [2021-11-20].

[60] Apple Developer Documentation. developer.apple.com. [2021-11-20].

[wasmcs2-61] Rossberg, Andreas (編). WebAssembly Core Specification: Version 2.0. World Wide Web Consortium. § 4.3.2 Integer Operations. 19 April 2022.

[62] Zig Documentation. Zig Programming Language. [2022-12-18].

[63] Horvath, Adam. Faster division and modulo operation - the power of two. July 5, 2012. （原始內容存檔於2018-03-05）（英語）.

[a]

[1]

[2]

[b]

[3]

[4]

[5]

[6]

[c]

[d]

[e]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]

[24]

[25]

[26]

[27]

[28]

[29]

[30]

[31]

[32]

[33]

[34]

[35]

[36]

[37]

[38]

[f]

[39]

[40]

[g]

[42]

[43]

[44]

[45]

[46]

[47]

[48]

[49]

[50]

[51]

[52]

[53]

[54]

[55]

[56]

[7]

[8]

[41]

`div`	divide and truncate (i.e., value is not rounded)
`mod`	modulus: let `Remainder = A - (A div B) * B`; if `Remainder < 0` then `A mod B = Remainder + B` otherwise `A mod B = Remainder`