In computing, the modulo operation returns the remainder or signed remainder of a division, after one number is divided by another (called the modulus of the operation).
Given two positive numbers and , modulo (abbreviated as ) is the remainder of the Euclidean division of by , where is the dividend and is the divisor. The modulo operation is to be distinguished from the symbol , which refers to the modulus (or divisor) one is operating from.
For example, the expression "5 mod 2" would evaluate to 1, because 5 divided by 2 has a quotient of 2 and a remainder of 1, while "9 mod 3" would evaluate to 0, because the division of 9 by 3 has a quotient of 3 and a remainder of 0; there is nothing to subtract from 9 after multiplying 3 times 3.
Although typically performed with and both being , many computing systems now allow other types of numeric operands. The range of values for an integer modulo operation of is 0 to inclusive ( mod 1 is always 0; is undefined, possibly resulting in a division by zero error in some programming languages). See Modular arithmetic for an older and related convention applied in number theory.
When exactly one of or is negative, the naive definition breaks down, and programming languages differ in how these values are defined.
In nearly all computing systems, the quotient and the remainder of divided by satisfy the following conditions:
However, this still leaves a sign ambiguity if the remainder is nonzero: two possible choices for the remainder occur, one negative and the other positive, and two possible choices for the quotient occur. In number theory, the positive remainder is always chosen, but in computing, programming languages choose depending on the language and the signs of or . Standard Pascal and ALGOL 68, for example, give a positive remainder (or 0) even for negative divisors, and some programming languages, such as C90, leave it to the implementation when either of or is negative (see the table under for details). modulo 0 is undefined in most systems, although some do define it as .
As described by Leijen,
However, truncated division satisfies the identity $(a)/b\; =\; (a/b)\; =\; a/(b)$.
For environments lacking a similar function, any of the three definitions above can be used.
For example, to test if an integer is odd, one might be inclined to test if the remainder by 2 is equal to 1:
return n % 2 == 1;}
But in a language where modulo has the sign of the dividend, that is incorrect, because when (the dividend) is negative and odd, mod 2 returns −1, and the function returns false.
One correct alternative is to test that the remainder is not 0 (because remainder 0 is the same regardless of the signs):
return n % 2 != 0;}
Another alternative is to use the fact that for any odd number, the remainder may be either 1 or −1:
return n % 2 == 1  n % 2 == 1;}
Examples:
In devices and software that implement bitwise operations more efficiently than modulo, these alternative forms can result in faster calculations.
Compiler optimizations may recognize expressions of the form where is a power of two and automatically implement them as , allowing the programmer to write clearer code without compromising performance. This simple optimization is not possible for languages in which the result of the modulo operation has the sign of the dividend (including C), unless the dividend is of an Signedness integer type. This is because, if the dividend is negative, the modulo will be negative, whereas will always be positive. For these languages, the equivalence x % 2<sup>n</sup> == x < 0 ? x  ~(2<sup>n</sup>  1) : x & (2<sup>n</sup>  1) has to be used instead, expressed using bitwise OR, NOT and AND operations.
Optimizations for general constantmodulus operations also exist by calculating the division first using the constantdivisor optimization.
+ Modulo operators in various programming languages  
ABAP  Euclidean  
ActionScript  Truncated  
Ada  Floored  
Truncated  
ALGOL 68  ,  Euclidean  
AMPL  Truncated  
APL  <nowiki></nowiki>  Floored  
AppleScript  Truncated  
AutoLISP  Truncated  
AWK  Truncated  
BASIC  Undefined  
bc  Truncated  
CC++  ,  Truncated  
(C) (C++)  Truncated  
(C) (C++)  Rounded  
C#  Truncated  
Clarion  Truncated  
Clean  Truncated  
Clojure  Floored  
Truncated  
COBOL  Floored  
CoffeeScript  Truncated  
Floored CoffeeScript operators  
ColdFusion  ,  Truncated  
Common Lisp  Floored  
Truncated  
Crystal  Truncated  
D  Truncated  
Dart  Euclidean  
Truncated  
Eiffel  Truncated  
Elixir  Truncated  
Floored  
Elm  Floored  
Truncated  
Erlang  Truncated  
Truncated (same as C)  
Euphoria  Floored  
Truncated  
F#  Truncated  
Factor  Truncated  
FileMaker  Floored  
Forth  Implementation defined  
Floored  
Truncated  
Fortran  Truncated  
Floored  
Frink  Floored  
GLSL  Undefined  
Floored  
GameMaker Studio (GML)  ,  Truncated  
GDScript (Godot)  Truncated  
Truncated  
Floored  
Floored  
Go  Truncated  
Truncated  
Apache Groovy  Truncated  
Haskell  Floored  
Truncated  
(GHC)  Floored  
Haxe  Truncated  
HLSL  Undefined  
J  <nowiki></nowiki>  Floored  
Java  Truncated  
Floored  
JavaScriptTypeScript  Truncated  
Julia  Floored  
,  Truncated  
Kotlin  ,  Truncated  
Floored  
KornShell  Truncated (same as POSIX sh)  
Truncated  
LabVIEW  Truncated  
LibreOffice  Floored  
Logo  Floored  
Truncated  
Lua 5  Floored  
Lua 4  Truncated  
Liberty BASIC  Truncated  
Mathcad  Floored  
Maple  (by default),  Euclidean  
Rounded  
Rounded  
Mathematica  Floored  
MATLAB  Floored  
Truncated  
Maxima  Floored  
Truncated  
Maya Embedded Language  Truncated  
Microsoft Excel  Floored  
Minitab  Floored  
Modula2  Floored  
Truncated  
MUMPS  Floored  
Netwide Assembler (NASM, NASMX)  , (unsigned)  
(signed)  Implementationdefined  
Nim  Truncated  
Oberon  Flooredlike  
ObjectiveC  Truncated (same as C99)  
Object Pascal, Delphi  Truncated  
OCaml  Truncated  
Truncated  
Occam  Truncated  
Pascal (ISO7185 and 10206)  Euclideanlike  
Programming Code Advanced (PCA)  Undefined  
Perl  Floored  
Truncated  
Phix  Floored  
Truncated  
PHP  Truncated  
Truncated  
PIC BASIC Pro  Truncated  
PL/I  Floored (ANSI PL/I)  
PowerShell  Truncated  
Programming Code (PRC)  Undefined  
Progress  Truncated  
Prolog ( ISO 1995)  Floored  
Truncated  
PureBasic  ,  Truncated  
PureScript  Floored  
Pure Data  Truncated (same as C)  
Floored  
Python  Floored  
Truncated  
Q Sharp  Truncated  
R  Floored  
Racket  Floored  
Truncated  
Raku  Floored  
RealBasic  Truncated  
Reason  Truncated  
Rexx  Truncated  
RPG  Truncated  
Ruby  ,  Floored  
Truncated  
Rust  Truncated  
Euclidean  
SAS language  Truncated  
Scala  Truncated  
Scheme  Floored  
Truncated  
Scheme R^{6}RS  Euclidean r6rs.org  
Rounded  
Euclidean  
Rounded  
Scratch  Floored  
Truncated  
Seed7  Floored  
Truncated  
SenseTalk  Floored  
Truncated  
POSIX shell (includes bash, mksh, &c.)  Truncated (same as C)  
Smalltalk  Floored  
Truncated  
Snap!  Floored  
Spin  Floored  
Solidity  Floored  
SQL ()  Truncated  
SQL ()  Truncated  
Standard ML  Floored  
Truncated  
Truncated  
Stata  Euclidean  
Swift  Truncated  
Truncated  
Tcl  Floored  
Torque  Truncated  
Turing  Floored  
Verilog (2001)  Truncated  
VHDL  Floored  
Truncated  
Vimscript  Truncated  
Visual Basic  Truncated  
WebAssembly  ,  Truncated  
x86 assembly  Truncated  
XBase++  Truncated  
Floored  
Z3 theorem prover  ,  Euclidean 
In addition, many computer systems provide a functionality, which produces the quotient and the remainder at the same time. Examples include the x86 architecture's instruction, the C programming language's function, and Python's function.
(To see this, let $x\; =\; a\; \; n\; \backslash left\backslash lfloor\backslash frac\{ad\}\{n\}\backslash right\backslash rfloor$. We first show that . It is in general true that for all integers ; thus, this is true also in the particular case when $b\; =\; \backslash !\backslash left\backslash lfloor\backslash frac\{ad\}\{n\}\backslash right\backslash rfloor$; but that means that $x\; \backslash bmod\; n\; =\; \backslash left(a\; \; n\; \backslash left\backslash lfloor\backslash frac\{ad\}\{n\}\backslash right\backslash rfloor\backslash right)\backslash !\; \backslash bmod\; n\; =\; a\; \backslash bmod\; n$, which is what we wanted to prove. It remains to be shown that . Let and be the integers such that with (see Euclidean division). Then $\backslash left\backslash lfloor\backslash frac\{ad\}\{n\}\backslash right\backslash rfloor\; =\; k$, thus $x\; =\; a\; \; n\; \backslash left\backslash lfloor\backslash frac\{ad\}\{n\}\backslash right\backslash rfloor\; =\; a\; \; n\; k\; =\; d\; +r$. Now take and add to both sides, obtaining . But we've seen that , so we are done. □)
The modulo with offset is implemented in Mathematica as .
/* This structure is part of the C stdlib.h, but is reproduced here for clarity */ long int quot; long int rem;} ldiv_t;
/* Euclidean division */ inline ldiv_t ldivE(long numer, long denom) {
/* The C99 and C++11 languages define both of these as truncating. */ long q = numer / denom; long r = numer % denom; if (r < 0) { if (denom > 0) { q = q  1; r = r + denom; } else { q = q + 1; r = r  denom; } } return (ldiv_t){.quot = q, .rem = r};}
/* Floored division */ inline ldiv_t ldivF(long numer, long denom) {
long q = numer / denom; long r = numer % denom; if ((r > 0 && denom < 0)  (r < 0 && denom > 0)) { q = q  1; r = r + denom; } return (ldiv_t){.quot = q, .rem = r};}
Note that for both cases, the remainder can be calculated independently of the quotient, but not vice versa. The operations are combined here to save screen space, as the logical branches are the same.

