Hubbry Logo
ModuloModuloMain
Open search
Modulo
Community hub
Modulo
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Modulo
Modulo
Modulo
View on Wikipedia
from Wikipedia

In computing and mathematics, the modulo operation returns the remainder or signed remainder of a division, after one number is divided by another, the latter being called the modulus of the operation.

Given two positive numbers a and n, a modulo n (often abbreviated as a mod n) is the remainder of the Euclidean division of a by n, where a is the dividend and n is the divisor.[1]

For example, the expression "5 mod 2" evaluates 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 9 divided by 3 has a quotient of 3 and a remainder of 0.

Although typically performed with a and n both being integers, many computing systems now allow other types of numeric operands. The range of values for an integer modulo operation of n is 0 to n − 1. a mod 1 is always 0.

When exactly one of a or n is negative, the basic definition breaks down, and programming languages differ in how these values are defined.

Variants of the definition

[edit]

In mathematics, the result of the modulo operation is an equivalence class, and any member of the class may be chosen as representative; however, the usual representative is the least positive residue, the smallest non-negative integer that belongs to that class (i.e., the remainder of the Euclidean division).[2] However, other conventions are possible. Computers and calculators have various ways of storing and representing numbers; thus their definition of the modulo operation depends on the programming language or the underlying hardware.

In nearly all computing systems, the quotient q and the remainder r of a divided by satisfy the following conditions:

This still leaves a sign ambiguity if the remainder is non-zero: two possible choices for the remainder occur, one negative and the other positive; that choice determines which of the two consecutive quotients must be used to satisfy equation (1). In number theory, the positive remainder is always chosen, but in computing, programming languages choose depending on the language and the signs of a or n.[a] 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 n or a is negative (see the table under § In programming languages for details). Some systems leave a modulo 0 undefined, though others define it as a.

  •   Quotient (q) and   remainder (r) as functions of dividend (a), using truncated division

    Many implementations use truncated division, for which the quotient is defined by

    where is the integral part function (rounding toward zero), i.e. the truncation to zero significant digits. Thus according to equation (1), the remainder has the same sign as the dividend a so can take 2|n| − 1 values:

  • Quotient and remainder using floored division

    Donald Knuth[3] promotes floored division, for which the quotient is defined by

    where is the floor function (rounding down). Thus according to equation (1), the remainder has the same sign as the divisor n:

  • Quotient and remainder using Euclidean division

    Raymond T. Boute[4] promotes Euclidean division, for which the non-negative remainder is defined by

    . (Emphasis added.)

    Under this definition, we can say the following about the quotient :

    where sgn is the sign function, is the floor function (rounding down), and are rational numbers.

    Equivalently, one may instead define the quotient as follows:

    where is the ceiling function (rounding up). Thus according to equation (1), the remainder is non-negative:

  • Quotient and remainder using rounded division

    Common Lisp and IEEE 754 use rounded division, for which the quotient is defined by

    where round is the round function (rounding half to even). Thus according to equation (1), the remainder falls between and , and its sign depends on which side of zero it falls to be within these boundaries:

  • Quotient and remainder using ceiling division

    Common Lisp also uses ceiling division, for which the quotient is defined by

    where ⌈⌉ is the ceiling function (rounding up). Thus according to equation (1), the remainder has the opposite sign of that of the divisor:

If both the dividend and divisor are positive, then the truncated, floored, and Euclidean definitions agree. If the dividend is positive and the divisor is negative, then the truncated and Euclidean definitions agree. If the dividend is negative and the divisor is positive, then the floored and Euclidean definitions agree. If both the dividend and divisor are negative, then the truncated and floored definitions agree.

However, truncated division satisfies the identity .[5][6]

Notation

[edit]
This section is about the binary mod operation. For the (mod m) notation, see congruence relation.

Some calculators have a mod() function button, and many programming languages have a similar function, expressed as mod(a, n), for example. Some also support expressions that use "%", "mod", or "Mod" as a modulo or remainder operator, such as a % n or a mod n.

For environments lacking a similar function, any of the three definitions above can be used.

Common pitfalls

[edit]

When the result of a modulo operation has the sign of the dividend (truncated definition), it can lead to surprising mistakes.

For example, to test if an integer is odd, one might be inclined to test if the remainder by 2 is equal to 1: 

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

But in a language where modulo has the sign of the dividend, that is incorrect, because when n (the dividend) is negative and odd, n 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): 

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

Or with the binary arithmetic: 

bool is_odd(int n) {
    return n & 1;
}

Performance issues

[edit]

Modulo operations might be implemented such that a division with a remainder is calculated each time. For special cases, on some hardware, faster alternatives exist. For example, the modulo of powers of 2 can alternatively be expressed as a bitwise AND operation (assuming x is a positive integer, or using a non-truncating definition):

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

Examples:

x % 2 == x & 1
x % 4 == x & 3
x % 8 == x & 7

In devices and software that implement bitwise operations more efficiently than modulo, these alternative forms can result in faster calculations.[7]

Compiler optimizations may recognize expressions of the form expression % constant where constant is a power of two and automatically implement them as expression & (constant-1), 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 unsigned integer type. This is because, if the dividend is negative, the modulo will be negative, whereas expression & (constant-1) will always be positive. For these languages, the equivalence x % 2n == x < 0 ? x | ~(2n - 1) : x & (2n - 1) has to be used instead, expressed using bitwise OR, NOT and AND operations.

Optimizations for general constant-modulus operations also exist by calculating the division first using the constant-divisor optimization.

Properties (identities)

[edit]
See also: Modular arithmetic § Properties

Some modulo operations can be factored or expanded similarly to other mathematical operations. This may be useful in cryptography proofs, such as the Diffie–Hellman key exchange. The properties involving multiplication, division, and exponentiation generally require that a and n are integers.

  • Identity:
  • Inverse:
  • Distributive:
    • (a + b) mod n = [(a mod n) + (b mod n)] mod n.
    • ab mod n = [(a mod n)(b mod n)] mod n.
  • Division (definition): ⁠a/b⁠ mod n = [(a mod n)(b−1 mod n)] mod n, when the right hand side is defined (that is when b and n are coprime), and undefined otherwise.
  • Inverse multiplication: [(ab mod n)(b−1 mod n)] mod n = a mod n.

In programming languages

[edit]
Modulo operators in various programming languages
Language Operator Integer Floating-point Definition
ABAP MOD Yes Yes Euclidean
ActionScript % Yes No Truncated
Ada mod Yes No Floored[8]
rem Yes No Truncated[8]
ALGOL 68 ÷×, mod Yes No Euclidean
AMPL mod Yes No Truncated
APL |[b] Yes Yes Floored
AppleScript mod Yes No Truncated
AutoLISP (rem d n) Yes No Truncated
AWK % Yes No Truncated
bash % Yes No Truncated
BASIC Mod Yes No Varies by implementation
bc % Yes No Truncated
C
C++ 		%, div Yes No Truncated[c]
fmod (C)
std::fmod (C++) 		No Yes Truncated[11]
remainder (C)
std::remainder (C++) 		No Yes Rounded
C# % Yes Yes Truncated
Math.IEEERemainder No Yes Rounded[12]
Clarion % Yes No Truncated
Clean rem Yes No Truncated
Clojure mod Yes No Floored[13]
rem Yes No Truncated[14]
COBOL FUNCTION MOD Yes No Floored[15]
FUNCTION REM Yes Yes Truncated[15]
CoffeeScript % Yes No Truncated
%% Yes No Floored[16]
ColdFusion %, MOD Yes No Truncated
Common Intermediate Language rem (signed) Yes Yes Truncated[17]
rem.un (unsigned) Yes No —
Common Lisp mod Yes Yes Floored
rem Yes Yes Truncated
Crystal %, modulo Yes Yes Floored
remainder Yes Yes Truncated
CSS mod() Yes Yes Floored[18]
rem() Yes Yes Truncated[19]
D % Yes Yes Truncated[20]
Dart % Yes Yes Euclidean[21]
remainder() Yes Yes Truncated[22]
Eiffel \\ Yes No Truncated
Elixir rem/2 Yes No Truncated[23]
Integer.mod/2 Yes No Floored[24]
Elm modBy Yes No Floored[25]
remainderBy Yes No Truncated[26]
Erlang rem Yes No Truncated
math:fmod/2 No Yes Truncated (same as C)[27]
Euphoria mod Yes No Floored
remainder Yes No Truncated
F# % Yes Yes Truncated
Math.IEEERemainder No Yes Rounded[12]
Factor mod Yes No Truncated
FileMaker Mod Yes No Floored
Forth mod Yes No Implementation defined
fm/mod Yes No Floored
sm/rem Yes No Truncated
Fortran mod Yes Yes Truncated
modulo Yes Yes Floored
Frink mod Yes No Floored
Full BASIC MOD Yes Yes Floored[28]
REMAINDER Yes Yes Truncated[29]
GLSL % Yes No Undefined[30]
mod No Yes Floored[31]
GameMaker Studio (GML) mod, % Yes No Truncated
GDScript (Godot) % Yes No Truncated
fmod No Yes Truncated
posmod Yes No Euclidean
fposmod No Yes Euclidean
Go % Yes No Truncated[32]
math.Mod No Yes Truncated[33]
big.Int.Mod Yes No Euclidean[34]
big.Int.Rem Yes No Truncated[35]
Groovy % Yes No Truncated
Haskell mod Yes No Floored[36]
rem Yes No Truncated[36]
Data.Fixed.mod' (GHC) No Yes Floored
Haxe % Yes No Truncated
HLSL % Yes Yes Undefined[37]
J |[b] Yes No Floored
Java % Yes Yes Truncated
Math.floorMod Yes No Floored
JavaScript
TypeScript 		% Yes Yes Truncated
Julia mod Yes Yes Floored[38]
%, rem Yes Yes Truncated[39]
Kotlin %, rem Yes Yes Truncated[40]
mod Yes Yes Floored[41]
ksh % Yes No Truncated (same as POSIX sh)
fmod No Yes Truncated
LabVIEW mod Yes Yes Truncated
LibreOffice =MOD() Yes No Floored
Logo MODULO Yes No Floored
REMAINDER Yes No Truncated
Lua 5 % Yes Yes Floored
Lua 4 mod(x,y) Yes Yes Truncated
Liberty BASIC MOD Yes No Truncated
Mathcad mod(x,y) Yes No Floored
Maple e mod m (by default), modp(e, m) Yes No Euclidean
mods(e, m) Yes No Rounded
frem(e, m) Yes Yes Rounded
Mathematica Mod[a, b] Yes No Floored
MATLAB mod Yes Yes Floored
rem Yes Yes Truncated
Maxima mod Yes No Floored
remainder Yes No Truncated
Maya Embedded Language % Yes No Truncated
Microsoft Excel =MOD() Yes Yes Floored
Minitab MOD Yes No Floored
Modula-2 MOD Yes No Floored
REM Yes No Truncated
MUMPS # Yes No Floored
Netwide Assembler (NASM, NASMX) %, div (unsigned) Yes No —
%% (signed) Yes No Implementation-defined[42]
Nim mod Yes No Truncated
Oberon MOD Yes No Floored-like[d]
Objective-C % Yes No Truncated (same as C99)
Object Pascal, Delphi mod Yes No Truncated
OCaml mod Yes No Truncated[43]
mod_float No Yes Truncated[44]
Occam \ Yes No Truncated
Pascal (ISO-7185 and -10206) mod Yes No Euclidean-like[e]
Perl % Yes No Floored[f]
POSIX::fmod No Yes Truncated
Phix mod Yes No Floored
remainder Yes No Truncated
PHP % Yes No Truncated[46]
fmod No Yes Truncated[47]
PIC BASIC Pro \\ Yes No Truncated
PL/I mod Yes No Floored (ANSI PL/I)
PowerShell % Yes No Truncated
Programming Code (PRC) MATH.OP - 'MOD; (\)' Yes No Undefined
Progress modulo Yes No Truncated
Prolog (ISO 1995) mod Yes No Floored
rem Yes No Truncated
PureBasic %, Mod(x,y) Yes No Truncated
PureScript `mod` Yes No Euclidean[48]
Pure Data % Yes No Truncated (same as C)
mod Yes No Floored
Python % Yes Yes Floored
math.fmod No Yes Truncated
math.remainder No Yes Rounded
Q# % Yes No Truncated[49]
R %% Yes Yes Floored[50]
Racket modulo Yes No Floored
remainder Yes No Truncated
Raku % No Yes Floored
RealBasic MOD Yes No Truncated
Reason mod Yes No Truncated
Rexx // Yes Yes Truncated
RPG %REM Yes No Truncated
Ruby %, modulo() Yes Yes Floored
remainder() Yes Yes Truncated
Rust % Yes Yes Truncated
rem_euclid() Yes Yes Euclidean[51]
SAS MOD Yes No Truncated
Scala % Yes Yes Truncated
Scheme modulo Yes No Floored
remainder Yes No Truncated
Scheme R6RS mod Yes No Euclidean[52]
mod0 Yes No Rounded[52]
flmod No Yes Euclidean
flmod0 No Yes Rounded
Scratch mod Yes Yes Floored
Seed7 mod Yes Yes Floored
rem Yes Yes Truncated
SenseTalk modulo Yes No Floored
rem Yes No Truncated
sh (POSIX) (includes bash, mksh, &c.) % Yes No Truncated (same as C)[53]
Smalltalk \\ Yes No Floored
rem: Yes No Truncated
Snap! mod Yes No Floored
Spin // Yes No Floored
Solidity % Yes No Truncated[54]
SQL (SQL:1999) mod(x,y) Yes No Truncated
SQL (SQL:2011) % Yes No Truncated
Standard ML mod Yes No Floored
Int.rem Yes No Truncated
Real.rem No Yes Truncated
Stata mod(x,y) Yes No Euclidean
Swift % Yes No Truncated[55]
remainder(dividingBy:) No Yes Rounded[56]
truncatingRemainder(dividingBy:) No Yes Truncated[57]
Tcl % Yes No Floored
fmod() No Yes Truncated (as C)
tcsh % Yes No Truncated
Torque % Yes No Truncated
Turing mod Yes No Floored
Verilog (2001) % Yes No Truncated
VHDL mod Yes No Floored
rem Yes No Truncated
VimL % Yes No Truncated
Visual Basic Mod Yes No Truncated
WebAssembly i32.rem_u, i64.rem_u (unsigned) Yes No —[58]
i32.rem_s, i64.rem_s (signed) Yes No Truncated[58]
x86 assembly IDIV Yes No Truncated
XBase++ % Yes Yes Truncated
Mod() Yes Yes Floored
Zig %, @rem Yes Yes Truncated[59]
@mod Yes Yes Floored
Z3 theorem prover div, mod Yes No Euclidean

In addition, many computer systems provide a divmod functionality, which produces the quotient and the remainder at the same time. Examples include the x86 architecture's IDIV instruction, the C programming language's div() function, and Python's divmod() function.

Generalizations

[edit]

Modulo with offset

[edit]

Sometimes it is useful for the result of a modulo n to lie not between 0 and n − 1, but between some number d and d + n − 1. In that case, d is called an offset and d = 1 is particularly common.

There does not seem to be a standard notation for this operation, so let us tentatively use a modd n. We thus have the following definition:[60] x = a modd n just in case d ≤ x ≤ d + n − 1 and x mod n = a mod n. Clearly, the usual modulo operation corresponds to zero offset: a mod n = a mod0 n.

The operation of modulo with offset is related to the floor function as follows:

To see this, let . We first show that x mod n = a mod n. It is in general true that (a + bn) mod n = a mod n for all integers b; thus, this is true also in the particular case when ; but that means that , which is what we wanted to prove. It remains to be shown that d ≤ x ≤ d + n − 1. Let k and r be the integers such that a − d = kn + r with 0 ≤ r ≤ n − 1 (see Euclidean division). Then , thus . Now take 0 ≤ r ≤ n − 1 and add d to both sides, obtaining d ≤ d + r ≤ d + n − 1. But we've seen that x = d + r, so we are done.

The modulo with offset a modd n is implemented in Mathematica as Mod[a, n, d] .[60]

Implementing other modulo definitions using truncation

[edit]

Despite the mathematical elegance of Knuth's floored division and Euclidean division, it is generally much more common to find a truncated division-based modulo in programming languages. Leijen provides the following algorithms for calculating the two divisions given a truncated integer division: 

/* Euclidean and Floored divmod, in the style of C's ldiv() */
typedef struct {
  /* 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};
}

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.

See also

[edit]

Notes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Modulo

View on Grokipedia
from Grokipedia
The modulo operation, also known as modulus, is a binary operation in integer arithmetic that computes the remainder of the Euclidean division of one integer by another non-zero integer. For integers aa and bb with b>0b > 0, the result amod  b=ra \mod b = r satisfies 0≤r<b0 \leq r < b and a=qb+ra = qb + r for some integer quotient qq. This operation is denoted using the keyword "mod" or the symbol "%" in many programming languages and is fundamental to handling remainders in division. In mathematics, the modulo operation underpins modular arithmetic, a system where integers are considered equivalent if their difference is divisible by a fixed positive integer nn, called the modulus; this equivalence is denoted a≡b(modn)a \equiv b \pmod{n}. The relation ≡\equiv modulo nn is an equivalence relation, exhibiting properties of reflexivity (a≡a(modn)a \equiv a \pmod{n}), symmetry (if a≡b(modn)a \equiv b \pmod{n}, then b≡a(modn)b \equiv a \pmod{n}), and transitivity (if a≡b(modn)a \equiv b \pmod{n} and b≡c(modn)b \equiv c \pmod{n}, then a≡c(modn)a \equiv c \pmod{n}). These properties partition the integers into nn congruence classes, represented by residues 0,1,…,n−10, 1, \dots, n-1, enabling arithmetic operations that "wrap around" like a clock. The modulo operation has broad applications across disciplines, including number theory for solving Diophantine equations, where computations are reduced modulo a prime. In cryptography, it is essential for algorithms such as RSA encryption, which relies on modular exponentiation and the difficulty of factoring the modulus, a product of two large primes. In computer science, modulo facilitates hashing functions for data structures, cyclic indexing in arrays, and simulating periodic phenomena like time or calendars. Its efficiency and periodic nature make it indispensable for optimizing computations in both theoretical and practical contexts.

Basic Concepts and Definitions

Core Definition

The modulo operation is a fundamental concept in integer arithmetic that determines the remainder after dividing one integer by another. For integers aa and nn where n>0n > 0, the modulo operation, denoted conceptually as amod  na \mod n, yields the remainder rr such that a=qn+ra = qn + r for some integer quotient qq, with the condition 0≤r<n0 \leq r < n. This remainder rr represents the part of aa that cannot be evenly divided by nn, capturing the "leftover" value in the division process. Underlying the modulo operation is the division algorithm, a cornerstone theorem in number theory that asserts the existence and uniqueness of the quotient qq and remainder rr for any integers aa and n>0n > 0. The algorithm states that there are unique integers qq and rr satisfying a=qn+ra = qn + r and 0≤r<n0 \leq r < n, where qq is the integer part of the division (specifically, q=⌊a/n⌋q = \lfloor a/n \rfloor) and rr is always non-negative and strictly less than nn. This ensures a consistent, well-defined remainder regardless of the sign of aa, as the convention prioritizes a positive rr. For example, dividing 17 by 5 produces q=3q = 3 and r=2r = 2 since 17=3×5+217 = 3 \times 5 + 2, so 17mod  5=217 \mod 5 = 2. Similarly, for negative dividends, -7 divided by 3 gives q=−3q = -3 and r=2r = 2 because −7=−3×3+2-7 = -3 \times 3 + 2, yielding −7mod  3=2-7 \mod 3 = 2. The division algorithm presupposes basic integer division, where the goal is to express any integer aa as a multiple of nn plus a smaller non-negative component rr. This decomposition is unique and forms the basis for modular arithmetic, enabling analysis of integers based on their remainders rather than their full magnitude. This core remainder-based definition extends to various contexts in mathematics, though specialized variants may adjust the remainder convention for specific applications.

Historical Development

The division algorithm underlying the modulo operation was first formalized by Euclid in his Elements around 300 BC. The roots of the modulo concept trace back to ancient Chinese mathematics, where remainder problems were systematically addressed in Sunzi's Suanjing, a text dating to the 3rd or 4th century AD, featuring examples like divisions yielding specific remainders that anticipated solutions to systems of congruences. In parallel, Indian mathematician Brahmagupta advanced these ideas in the 7th century through his Brahmasphutasiddhanta, introducing the kuttaka method—a pulverizer technique for resolving linear remainder equations, which provided general solutions to Diophantine problems involving moduli. The formalization of modular arithmetic emerged in the early 19th century with Carl Friedrich Gauss's Disquisitiones Arithmeticae, published in 1801, where he introduced the notation of congruences to describe integers equivalent under division by a fixed number, building on prior remainder traditions to create a rigorous framework for number theory. Gauss coined the term "modulo" from the Latin modulus, signifying a measure or standard, to refer to this divisor in congruence relations, establishing it as a foundational element of arithmetic investigations. In the late 19th century, these concepts influenced abstract algebra, particularly through Richard Dedekind's 1871 introduction of ideals as substructures within rings of algebraic integers, which extended modular principles to address factorization failures in number fields. By the 20th century, modular arithmetic was fully integrated into ring theory, with Emmy Noether's axiomatic developments in the 1920s unifying commutative rings and emphasizing their role in broader algebraic structures.

Variants and Mathematical Foundations

Remainder-Based Variant

The remainder-based variant of the modulo operation, also known as the least non-negative residue, defines amod  na \mod n for integers aa and positive integer n>0n > 0 as the unique integer rr such that 0≤r<n0 \leq r < n and a≡r(modn)a \equiv r \pmod{n}, meaning nn divides a−ra - r. This variant ensures a canonical representative from the set {0,1,…,n−1}\{0, 1, \dots, n-1\} for each congruence class modulo nn. The uniqueness of rr follows directly from the division algorithm, which asserts that for any integers aa and n>0n > 0, there exist unique integers qq and rr satisfying a=qn+ra = qn + r with 0≤r<n0 \leq r < n. To see uniqueness, suppose there are two such pairs (q1,r1)(q_1, r_1) and (q2,r2)(q_2, r_2). Then q1n+r1=q2n+r2q_1 n + r_1 = q_2 n + r_2, so (q1−q2)n=r2−r1(q_1 - q_2)n = r_2 - r_1. Since 0≤r1,r2<n0 \leq r_1, r_2 < n, it follows that ∣r2−r1∣<n|r_2 - r_1| < n. The only integer multiple of nn with absolute value less than nn is 0, so r2−r1=0r_2 - r_1 = 0 and q1−q2=0q_1 - q_2 = 0, hence q1=q2q_1 = q_2 and r1=r2r_1 = r_2. When the dividend aa is negative, the convention maintains a non-negative remainder by adjusting the quotient accordingly, using q=⌊a/n⌋q = \lfloor a / n \rfloor. Specifically, for a<0a < 0, the remainder can be computed as r=n−((−a)mod  n)r = n - ((-a) \mod n) if (−a)mod  n≠0(-a) \mod n \neq 0, and r=0r = 0 otherwise, ensuring rr remains in [0,n−1][0, n-1]. For example, −17mod  5=3-17 \mod 5 = 3, since 17mod  5=217 \mod 5 = 2 and 5−2=35 - 2 = 3, corresponding to −17=5⋅(−4)+3-17 = 5 \cdot (-4) + 3. This approach differs from truncation toward zero, which might yield a negative remainder for negative aa, but prioritizes consistency with the non-negative residue system in mathematical number theory.

Symmetric and Other Variants

In contrast to the standard remainder-based variant, which is the default in pure mathematics where the remainder is always non-negative, alternative definitions of the modulo operation address scenarios involving negative numbers or require balanced representations. The symmetric variant, known as the least absolute remainder, selects the remainder rr such that a=qn+ra = q n + r and ∣r∣|r| is minimized, with rr ranging from −⌊(n−1)/2⌋-\lfloor (n-1)/2 \rfloor to ⌊n/2⌋\lfloor n/2 \rfloor. This ensures the residue is centered around zero for balanced distribution. For instance, 17mod  5=217 \mod 5 = 2 because 17=3⋅5+217 = 3 \cdot 5 + 2 and ∣2∣<∣−3∣|2| < |-3|, while −17mod  5=−2-17 \mod 5 = -2 since −17=−4⋅5+3-17 = -4 \cdot 5 + 3 gives ∣3∣=3>2|3| = 3 > 2, but adjusting to −17=−3⋅5−2-17 = -3 \cdot 5 - 2 minimizes the absolute value. This approach appears in algorithms like the Aryabhata method for efficient computation. Another variant is the truncated toward zero modulo, defined by a=qn+ra = q n + r where qq is the truncation of a/na / n toward zero, which can yield negative remainders when aa is negative and n>0n > 0. For example, −17mod  5=−2-17 \mod 5 = -2, as the truncation of the quotient leads to a signed residue matching the dividend's sign in this convention. This differs from the positive remainder standard by preserving the sign, useful in contexts requiring consistent directional behavior.
VariantRange of rr (for n>0n > 0)Example: 17mod  517 \mod 5Example: −17mod  5-17 \mod 5
Remainder-based0≤r<n0 \leq r < n23
Symmetric (least absolute)−⌊(n−1)/2⌋≤r≤⌊n/2⌋-\lfloor (n-1)/2 \rfloor \leq r \leq \lfloor n/2 \rfloor2-2
Truncated toward zero$r< n ,signfollows, sign follows a $
The symmetric variant is particularly common in signal processing for generating balanced residues in sequences, such as bipolar or ternary signals where centered remainders modulo LL avoid bias in periodic extensions.

Notation and Conventions

Mathematical Notation

In mathematical literature, the primary notation for congruence in modular arithmetic is a≡b(modm)a \equiv b \pmod{m}, where aa and bb are integers congruent modulo the positive integer mm, meaning mm divides a−ba - b. This symbol indicates that aa and bb leave the same remainder when divided by mm. For the modulo operation itself, which yields the remainder rr such that 0≤r<m0 \leq r < m and a=qm+ra = qm + r for some integer qq, the standard notation is amod  m=ra \mod m = r. The evolution of this notation traces back to Carl Friedrich Gauss's Disquisitiones Arithmeticae (1801), where he formalized modular arithmetic using the congruence relation originally expressed as a=b+kma = b + km for some integer kk, but innovated by introducing the triple-bar symbol ≡\equiv to denote congruence "modulo mm". Prior to Gauss, such relations were described verbally or through divisibility statements like "mm divides a−ba - b", without a dedicated symbolic form. The abbreviated "mod" for "modulo" emerged later in the 19th and 20th centuries as a concise infix or prefix operator, standardizing the remainder notation in modern texts. Conventions for typesetting the modulo notation emphasize clarity and consistency, particularly in professional mathematical publishing. The "mod" keyword is typically treated as an upright (roman) operator rather than italicized, distinguishing it from variables; for instance, in congruence, it appears as (modm)\pmod{m} to ensure proper spacing after the equivalence symbol. In LaTeX, commands like  mod \bmod (for inline binary use) or (mod)\pmod{} (for parenthesized modulo in congruences) enforce thin spaces around "mod" to align with its role as a relational operator, avoiding the italic slant reserved for identifiers. Some texts italicize "mod" only when functioning strictly as a binary operator in expressions like amod  ma \mod m, but upright form predominates in congruence contexts per international standards.

Programming and Applied Notation

In programming languages, the modulo operation is frequently denoted by the % symbol, which computes the remainder after integer division. In C, the % operator yields a result with the same sign as the dividend (the left operand), for example, (-7) % 3 equals -1. Java follows the same convention, where the remainder inherits the sign of the dividend. Python's % operator, however, implements floored modulo division, producing a non-negative result when the divisor is positive, such as (-7) % 3 equaling 2. Some languages employ keywords rather than symbols for modulo. Pascal uses the mod keyword to calculate the remainder, behaving similarly to C's % for positive operands but extending to handle negative values consistently with standard division. Variations exist in the semantics of these operations; Ruby's % operator adopts floored modulo like Python, ensuring the result's sign matches the divisor. In MATLAB, the built-in mod(a, b) function returns a remainder with the sign of the divisor b, always non-negative for positive b, as in mod(-7, 3) yielding 2. In applied contexts, modulo notation facilitates practical computations. Hash functions often use a % n to map a hash value a to one of n buckets in a hash table, distributing elements across storage slots. In engineering fields like signal processing, phases are expressed modulo 2π to wrap angular values into the interval [0, 2π), representing periodic cycles on the unit circle. For floating-point arithmetic under the IEEE 754 standard, dedicated functions handle modulo-like operations to ensure precision and consistency. The remainder function computes the IEEE remainder, defined as x - n * y where n is the nearest integer to x / y (ties rounding to even), differing from truncating divisions in languages like C's fmod. The modf function decomposes a floating-point number into its signed integer part (stored via pointer) and fractional part (returned), effectively isolating the component modulo 1. These draw briefly from mathematical notation for remainder but prioritize computational rounding modes and edge-case handling in hardware implementations.

Properties and Identities

Fundamental Properties

The modulo operation, denoted as amod  na \mod n for integers aa and positive integer nn, yields the non-negative remainder rr such that 0≤r<n0 \leq r < n and a=qn+ra = qn + r for some integer qq, as established by the division algorithm. This remainder is always non-negative when n>0n > 0, ensuring a consistent range for representatives in the residue classes. A key property is the periodicity of the modulo operation with period nn: for any integer kk, amod  n=(a+kn)mod  na \mod n = (a + kn) \mod n. This follows directly from the division algorithm; if a=qn+ra = qn + r with 0≤r<n0 \leq r < n, then a+kn=(q+k)n+ra + kn = (q + k)n + r, yielding the same remainder rr. The operation is compatible with addition: (a+b)mod  n=[(amod  n)+(bmod  n)]mod  n(a + b) \mod n = [(a \mod n) + (b \mod n)] \mod n. To see this, suppose a≡a′(modn)a \equiv a' \pmod{n} and b≡b′(modn)b \equiv b' \pmod{n} where a′=amod  na' = a \mod n and b′=bmod  nb' = b \mod n; then a+b≡a′+b′(modn)a + b \equiv a' + b' \pmod{n}, and applying the modulo again gives the remainder of the sum. The same holds for subtraction: (a−b)mod  n=[(amod  n)−(bmod  n)]mod  n(a - b) \mod n = [(a \mod n) - (b \mod n)] \mod n, proved analogously since if a≡a′(modn)a \equiv a' \pmod{n} and b≡b′(modn)b \equiv b' \pmod{n}, then a−b≡a′−b′(modn)a - b \equiv a' - b' \pmod{n}. Regarding zero divisors, 0mod  n=00 \mod n = 0 because 0=0⋅n+00 = 0 \cdot n + 0, fitting the division algorithm with remainder 0. Likewise, nmod  n=0n \mod n = 0 as n=1⋅n+0n = 1 \cdot n + 0. These properties underscore the role of multiples of nn as equivalents to zero in the modulo system.

Key Identities and Theorems

One fundamental identity in modular arithmetic is the multiplicative congruence property, which states that for any integers aa, bb, and positive integer nn, (ab)mod  n=[(amod  n)(bmod  n)]mod  n.(ab) \mod n = [(a \mod n)(b \mod n)] \mod n. This identity follows from the distributive property of integers and the definition of congruence, enabling efficient computation of products modulo nn by reducing operands first. Another key identity concerns the existence of modular multiplicative inverses. For integers aa and positive integer nn, an integer bb exists such that ab≡1mod  nab \equiv 1 \mod n if and only if gcd⁡(a,n)=1\gcd(a, n) = 1. This condition ensures aa is coprime to the modulus, allowing unique invertibility in the multiplicative group of integers modulo nn. Related properties include the additive inverse, where [(−amod  n)+(amod  n)]mod  n=0,[(-a \mod n) + (a \mod n)] \mod n = 0, and the inverse multiplication property, where [(abmod  n)(b−1mod  n)]mod  n=amod  n,[(ab \mod n)(b^{-1} \mod n)] \mod n = a \mod n, assuming bb and nn are coprime. Additionally, modular division is defined as a/bmod  n=[(amod  n)(b−1mod  n)]mod  na / b \mod n = [(a \mod n)(b^{-1} \mod n)] \mod n when bb and nn are coprime, and undefined otherwise. The Chinese Remainder Theorem provides a powerful result for systems of congruences with coprime moduli. Specifically, if mm and nn are coprime positive integers and a,ba, b are any integers, then the system x≡a(modm),x≡b(modn)x \equiv a \pmod{m}, \quad x \equiv b \pmod{n} has a unique solution modulo mnmn. This theorem decomposes problems modulo composite numbers into independent subproblems modulo their prime power factors. Fermat's Little Theorem states that if pp is a prime number and aa is an integer not divisible by pp, then ap−1≡1(modp).a^{p-1} \equiv 1 \pmod{p}. Originally stated by Pierre de Fermat in 1640, this theorem forms the basis for many primality tests and cryptographic algorithms. Euler's theorem generalizes Fermat's Little Theorem to composite moduli. If gcd⁡(a,n)=1\gcd(a, n) = 1, then aϕ(n)≡1(modn),a^{\phi(n)} \equiv 1 \pmod{n}, where ϕ(n)\phi(n) is Euler's totient function, counting the integers up to nn that are coprime to nn. First proved by Leonhard Euler in the 18th century, this identity underpins efficient exponentiation in modular arithmetic. Wilson's Theorem offers a characterization of primes via factorials: for a prime pp, (p−1)!≡−1(modp).(p-1)! \equiv -1 \pmod{p}. Proposed by John Wilson in the 18th century and first proved by Joseph-Louis Lagrange in 1773, this theorem provides a primality criterion based on factorial congruences.

Applications in Mathematics

Modular Arithmetic

Modular arithmetic provides a foundational framework for performing arithmetic operations on integers under the equivalence relation defined by the modulo operation. The set of integers modulo nn, denoted ℤ/nℤ, consists of the equivalence classes ={m∈Z∣m≡k(modn)} = \{ m \in \mathbb{Z} \mid m \equiv k \pmod{n} \} for k=0,1,…,n−1k = 0, 1, \dots, n-1, where two integers are equivalent if their difference is divisible by nn. This structure forms a commutative ring with unity under addition and multiplication defined modulo nn: +=[a+b] + = [a + b] and ⋅=[a⋅b] \cdot = [a \cdot b], both taken modulo nn. The basic operations in ℤ/nℤ mirror those in the integers but wrap around at nn. For example, consider n=5n = 5; the addition table is as follows:
+01234
001234
112340
223401
334012
440123
The multiplication table for the same modulus is:
×01234
000000
101234
202413
303142
404321
In this ring, the additive identity is {{grok:render&&&type=render_inline_citation&&&citation_id=0&&&citation_type=wikipedia}}, satisfying + {{grok:render&&&type=render_inline_citation&&&citation_id=0&&&citation_type=wikipedia}} = for all , and the multiplicative identity is ${{grok:render&&&type=render_inline_citation&&&citation_id=1&&&citation_type=wikipedia}}$, satisfying $ \cdot {{grok:render&&&type=render_inline_citation&&&citation_id=1&&&citation_type=wikipedia}} = $ for all . Elements in ℤ/nℤ that are invertible under multiplication—known as units—are those forwhichthereexistsfor which there exists such that \cdot = {{grok:render&&&type=render_inline_citation&&&citation_id=1&&&citation_type=wikipedia}}; this holds precisely when gcd(k, n) = 1. Non-units include zero divisors, which are non-zero elements andand such that \cdot = {{grok:render&&&type=render_inline_citation&&&citation_id=0&&&citation_type=wikipedia}}, occurring when nn is composite. A key structural property arises when nn is prime: ℤ/nℤ becomes a field, meaning every non-zero element is a unit, allowing division by any non-zero element within the system. Properties such as distributivity hold in this ring, ensuring that addition distributes over multiplication as in the integers.

Number Theory Uses

In number theory, the modulo operation facilitates efficient divisibility tests for specific integers, allowing determination of whether a number is divisible by another without full division. For divisibility by 10, a number is divisible if its last digit is 0, equivalent to the number being congruent to 0 modulo 10, since powers of 10 are multiples of 10. For divisibility by 11, the alternating sum of the digits must be congruent to 0 modulo 11; this follows from the fact that 10≡−1(mod11)10 \equiv -1 \pmod{11}, so the number's decimal expansion dk10k+⋯+d0d_k 10^k + \cdots + d_0 simplifies to dk(−1)k+⋯+d0(mod11)d_k (-1)^k + \cdots + d_0 \pmod{11}. The modulo operation plays a crucial role in primality testing and integer factorization. Wilson's Theorem states that for a prime p>1p > 1, (p−1)!≡−1(modp)(p-1)! \equiv -1 \pmod{p}, providing a primality criterion: compute the factorial modulo pp and check if it equals p−1p-1; this is exact but computationally intensive for large pp. In factorization, the RSA cryptosystem relies on the difficulty of factoring a modulus n=pqn = pq where pp and qq are large primes; encryption uses modular exponentiation c=me(modn)c = m^e \pmod{n}, and decryption requires the private key derived from the factorization. Solving linear congruences of the form ax≡b(modn)ax \equiv b \pmod{n} is a fundamental application, where solutions exist if gcd⁡(a,n)\gcd(a, n) divides bb. The extended Euclidean algorithm finds such solutions by computing integers x0,y0x_0, y_0 such that ax0+ny0=gcd⁡(a,n)ax_0 + ny_0 = \gcd(a, n), then scaling to solve for xx; the general solution is x=x0+(n/d)kx = x_0 + (n/d)k for integer kk, where d=gcd⁡(a,n)d = \gcd(a, n). Modulo is essential in studying quadratic residues, where an integer aa is a quadratic residue modulo an odd prime pp (with gcd⁡(a,p)=1\gcd(a, p) = 1) if there exists xx such that x2≡a(modp)x^2 \equiv a \pmod{p}. The Legendre symbol (a/p)(a/p) indicates this: (a/p)=a(p−1)/2(modp)(a/p) = a^{(p-1)/2} \pmod{p}, equaling 1 if aa is a quadratic residue, -1 if not, and 0 if pp divides aa.

Computing and Implementation

In Programming Languages

In programming languages, the modulo operation is commonly implemented via the % operator for integers and dedicated functions for floating-point or specialized types, with semantics that can differ across languages, especially regarding the handling of negative numbers. In C and C++, the % operator yields the remainder from truncated division toward zero, such that for operands a and b, the result satisfies a == (a / b) * b + (a % b). For negative dividends, the remainder inherits the sign of the dividend; for instance, -5 % 3 equals -2 since -5 / 3 truncates to -1. Python's % operator, in contrast, pairs with floored division (//), producing a remainder with the sign of the divisor to align with mathematical modulo conventions. Thus, -5 % 3 yields 1, as -5 // 3 floors to -2 and -5 - (-2) * 3 = 1. This ensures the result is non-negative when the divisor is positive. For floating-point numbers, Java's Math.fmod(a, b) computes the remainder congruent to a modulo b, with the sign matching a and absolute value less than |b|, akin to truncated division. By comparison, Math.IEEEremainder(a, b) adheres to IEEE 754 by rounding the quotient to the nearest integer (ties to even), also signing the result like a but prioritizing minimal magnitude. Both handle edge cases consistently, such as 0.0 % n == 0.0 for finite nonzero n, and n % n == 0.0 for finite nonzero n. Specialized libraries enhance modulo capabilities beyond built-in types. The GNU Multiple Precision Arithmetic Library (GMP) offers mpz_mod for arbitrary-precision integers, setting the result r such that 0 ≤ r < |b| and a ≡ r \pmod{b}, with r always non-negative regardless of the sign of b. NumPy extends Python's modulo to arrays via the % operator or numpy.mod/numpy.remainder functions, performing element-wise computation with broadcasting support and inheriting Python's floored semantics, where the remainder's sign matches the divisor. In SQL, the MOD function computes the remainder of division. In standard implementations like Oracle and MySQL, it uses truncated division toward zero, yielding a remainder with the sign of the dividend; for example, MOD(-5, 3) returns -2. Variations exist across DBMS; for instance, PostgreSQL uses floored division, yielding a positive remainder such that MOD(-5, 3) returns 1.

Performance and Optimization

In hardware implementations, the modulo operation is frequently obtained as a byproduct of integer division instructions. On x86 architectures, the unsigned DIV instruction divides the dividend in the appropriate register pair (e.g., EDX:EAX) by the divisor and stores the quotient in EAX and the remainder (modulo result) in EDX, enabling efficient computation without separate modulo hardware. For divisions by constant values, optimization techniques employ "magic numbers"—precomputed multipliers that transform the operation into a series of multiplications, shifts, and subtractions, reducing reliance on the slower division unit; this approach, originating from early compiler optimizations, can achieve near-multiplication speeds for fixed moduli. Software optimizations further enhance modulo performance for specific cases. When the modulus nn is a power of 2, the operation amod  na \mod n simplifies to a bitwise AND with n−1n-1, masking the lower bits of aa and avoiding division entirely; this bitwise trick executes in a single cycle on most processors, offering substantial speedup over general modulo. For small constant moduli, lookup tables precompute remainders for input ranges, trading memory for reduced computation; multi-level table designs minimize access latency while supporting modular reductions up to certain bit widths. For big-integer arithmetic, particularly in cryptographic applications, advanced algorithms integrate modulo with multiplication. The Karatsuba algorithm accelerates large multiplications by reducing elementary operations from quadratic to O(n1.58)O(n^{1.58}), often combined with Montgomery reduction, which avoids explicit division by representing numbers in a Montgomery form and performing reductions via shifts and adds. This pairing yields efficient modular multiplication for elliptic curve cryptography and RSA, with implementations showing 20-50% latency improvements over naive methods on 64-bit platforms. On modern CPUs (e.g., Intel Raptor Lake and AMD Zen 5 as of 2024), the latency of a general 64-bit integer modulo operation typically ranges from 12-90 cycles depending on the divisor, signed/unsigned operation, and architecture (e.g., ~12-36 cycles on Zen 5; 20-92 cycles on Raptor Lake), contrasting sharply with the sub-cycle throughput of addition, which underscores the need for these optimizations in performance-critical code. While AVX-512 provides vectorized floating-point division, integer modulo requires custom implementations (e.g., using reciprocal multiplication approximations), enabling SIMD processing across multiple lanes but without native instructions, achieving up to 8x speedup for batched operations in polynomial evaluations with careful alignment to avoid scalar fallbacks. These hardware and software techniques build upon baseline modulo implementations in programming languages to deliver scalable efficiency.

Common Challenges and Generalizations

Frequent Pitfalls

One common pitfall in using the modulo operation arises from differing behaviors with negative numbers across mathematical definitions and programming implementations. In mathematics, the modulo operation typically yields a non-negative remainder between 0 and m−1m-1 for divisor m>0m > 0, such that for a=qm+ra = qm + r with 0≤r<m0 \leq r < m; for example, −7mod  3=2-7 \mod 3 = 2 because −7=3×(−3)+2-7 = 3 \times (-3) + 2. However, in languages like C, the % operator computes the remainder with the sign of the dividend using truncated division toward zero, resulting in −7%3=−1-7 \% 3 = -1. This discrepancy can lead to incorrect assumptions about positive outputs, causing bugs in algorithms expecting mathematical modulo, such as hashing or cyclic indexing. Variant implementations in other languages, like Python's positive remainder for negatives, further contribute to confusion during cross-platform development. Division by zero in modulo operations is undefined and triggers runtime errors in most programming environments. Attempting a%0a \% 0 results in a floating-point exception (SIGFPE) in C/C++, or a ZeroDivisionError in Python, halting execution and requiring explicit checks to prevent crashes. In loops using modulo for conditions, such as checking multiples with i%n==0i \% n == 0, failing to handle edge cases like n=0n = 0 can propagate errors unexpectedly. Off-by-one errors frequently occur when using modulo for array indexing or cycling in loops, where the condition i%n==0i \% n == 0 identifies multiples but may be misinterpreted at boundaries. For instance, in a loop from i=0i = 0 to nn, n%n=0n \% n = 0 maps to index 0, potentially skipping or duplicating the first element if the loop intent excludes the endpoint, leading to incorrect iterations. Floating-point modulo introduces precision issues due to binary representation limitations, where numbers like 0.1 cannot be exactly stored. For example, 1.0%0.11.0 \% 0.1 should ideally be 0 but computes as approximately 0.09999999999999995 in double precision, causing failures in equality checks or accumulations. Operations with non-integer divisors exacerbate this, as rounding errors in the underlying division propagate to the remainder. In cryptography, incorrect modulo implementations, particularly non-constant-time modular reductions in exponentiation, enable side-channel timing attacks that leak private keys. For RSA, variations in execution time during modular multiplications reveal bit patterns of the exponent, as demonstrated in attacks recovering full keys from measured timings.

Extended Forms and Implementations

Extended forms of the modulo operation allow for adjustments to the standard remainder computation, accommodating shifted ranges through the inclusion of an offset. A common generalization is the offset modulo, expressed as (a−c)mod  n+c(a - c) \mod n + c, where cc represents the desired shift in the representative set of remainders. This form preserves the periodic nature of the operation while relocating the zero point, ensuring remainders fall within a customized interval such as [c,c+n−1][c, c + n - 1]. For example, in determining days of the week, the standard dmod  7d \mod 7 yields remainders from 0 to 6, but applying an offset of 1—via (dmod  7)+1(d \mod 7) + 1—produces values from 1 to 7, aligning with conventional labeling from Sunday to Saturday. Variants of the modulo operation can be implemented from the floored version by post-processing the remainder to achieve desired truncation behaviors, such as symmetry. The symmetric modulo, also called centered or balanced modulo, returns values in the approximate interval [−n/2,n/2)[-n/2, n/2), which is useful for applications requiring centered residues around zero, like balanced ternary systems or error analysis. One implementation derives it from the floored modulo as follows: sym_mod(a,n)=((amod  n)+n2)mod  n−n2\text{sym\_mod}(a, n) = \left( (a \mod n) + \frac{n}{2} \right) \mod n - \frac{n}{2} For even nn, adjustments may be needed at the midpoint to resolve ambiguity, ensuring the result aligns with the centered definition xmod∗n=x−n⌊xn+12⌋x \mathrm{mod}^{*} n = x - n \left\lfloor \frac{x}{n} + \frac{1}{2} \right\rfloor. Beyond these adaptations, the modulo operation generalizes to more advanced mathematical structures. Modular exponentiation, denoted pow(a,b,n)=abmod  n\text{pow}(a, b, n) = a^b \mod n, efficiently computes large powers modulo nn using algorithms like binary exponentiation, reducing intermediate values through repeated squaring and multiplication modulo nn; this is foundational in cryptography for operations like RSA encryption. In p-adic analysis, modulo extends to p-adic numbers Qp\mathbb{Q}_p, where congruences modulo powers of a prime pp (i.e., a≡bmod  pka \equiv b \mod p^k) define the topology and completion of the rationals under the p-adic valuation, enabling interpolation and continuity in number-theoretic contexts. In computational environments, particularly on graphics processing units (GPUs), the modulo operation for non-integers is adapted for efficiency in specialized hardware. The CUDA programming model implements floating-point modulo via the fmod function (or fmodf for single precision), which computes the remainder of x/yx / y according to IEEE-754 standards with zero ULP error, making it suitable for periodic simulations such as molecular dynamics where positions are wrapped using offsets to enforce boundary conditions.

References

  1. https://www.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/what-is-modular-arithmetic
  2. https://pi.math.cornell.edu/~morris/135/mod.pdf
  3. https://kconrad.math.uconn.edu/blurbs/ugradnumthy/modarith.pdf
  4. https://crypto.stanford.edu/pbc/notes/numbertheory/arith.html
  5. https://www.uvm.edu/~cbcafier/cs1210/book/04_variables%2C_statements%2C_and_expressions/modulo_and_floor.html
  6. https://web.ma.utexas.edu/users/shirley/a325k/Epp_4e_sec-8.4-1.pdf
  7. https://reference.wolfram.com/language/ref/Mod.html
  8. https://www.britannica.com/science/Euclidean-algorithm
  9. https://shs.hal.science/halshs-00663292v1/document
  10. https://archive.org/details/disquisitionesa00gaus
  11. https://mathshistory.st-andrews.ac.uk/HistTopics/Ring_theory/
  12. https://planetmath.org/residuesystems
  13. https://math.libretexts.org/Bookshelves/Algebra/Abstract_and_Linear_Algebra/Elementary_Abstract_Algebra_%28Clark%29/01:_Chapters/1.05:_The_Division_Algorithm
  14. https://www.math.fsu.edu/~pkirby/mad2104/SlideShow/s5_1.pdf
  15. https://mfleck.cs.illinois.edu/building-blocks/version-1.0/number-theory.pdf
  16. https://arxiv.org/pdf/cs/0604012
  17. https://arxiv.org/pdf/1311.7171
  18. https://stackoverflow.com/questions/11720656/modulo-operation-with-negative-numbers
  19. https://link.springer.com/content/pdf/10.1007/978-0-387-30441-0.pdf
  20. https://www.britannica.com/science/modular-arithmetic
  21. https://hsm.stackexchange.com/questions/3340/is-gauss-the-first-who-introduced-congruences
  22. https://cdn.standards.iteh.ai/samples/64973/329519100abd447ea0d49747258d1094/ISO-80000-2-2019.pdf
  23. https://www.highpoint.edu/physics/files/2014/08/short-math-guide.pdf
  24. https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op1.html
  25. https://docs.python.org/3/reference/expressions.html
  26. https://www.freepascal.org/docs-html/ref/refsu44.html
  27. https://web.stanford.edu/class/archive/cs/cs106b/cs106b.1238/lectures/25-hashing/8_9_Lecture_25.pdf
  28. https://www2.math.upenn.edu/~mlazar/math170/notes06-2.pdf
  29. https://kconrad.math.uconn.edu/blurbs/ugradnumthy/crt.pdf
  30. https://link.springer.com/chapter/10.1007/978-1-4419-9479-0_28
  31. https://kconrad.math.uconn.edu/blurbs/ugradnumthy/eulerthm.pdf
  32. https://digitalcommons.ursinus.edu/cgi/viewcontent.cgi?article=1013&context=triumphs_number
  33. https://www.cs.nmt.edu/~ckoch/public/intro-mod.pdf
  34. https://math.mit.edu/~dav/finitefields.pdf
  35. https://math.libretexts.org/Bookshelves/Mathematical_Logic_and_Proof/Proofs_and_Concepts_-_The_Fundamentals_of_Abstract_Mathematics_%28Morris_and_Morris%29/05%253A_Sample_Topics/5.01%253A_Number_theory-_divisibility_and_congruence
  36. https://artofproblemsolving.com/wiki/index.php/Divisibility_rules/Rule_for_11_proof
  37. https://mathworld.wolfram.com/WilsonsTheorem.html
  38. https://people.csail.mit.edu/rivest/Rsapaper.pdf
  39. https://sites.math.rutgers.edu/~zeilberg/numtheory/L10.pdf
  40. https://www.math.uci.edu/~ndonalds/math180a/7quadres.pdf
  41. https://en.cppreference.com/w/cpp/language/operator_arithmetic
  42. https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations
  43. https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#fmod-double-double-
  44. https://gmplib.org/manual/Integer-Division.html
  45. https://numpy.org/doc/stable/reference/generated/numpy.mod.html
  46. https://docs.oracle.com/en/database/oracle/oracle-database/26/sqlrf/MOD.html
  47. https://www.postgresql.org/docs/current/functions-math.html
  48. https://www.felixcloutier.com/x86/div
  49. https://cp-algorithms.com/algebra/bit-manipulation.html
  50. https://web.ece.ucsb.edu/~parhami/pubs_folder/parh97-mwscas-mod-red-table.pdf
  51. https://eprint.iacr.org/2021/185.pdf
  52. https://www.doc.ic.ac.uk/~wl/papers/10/fpl10gc.pdf
  53. https://www.agner.org/optimize/microarchitecture.pdf
  54. https://hal.science/hal-02552673/document
  55. https://engineering.purdue.edu/kak/compsec/NewLectures/Lecture5.pdf
  56. https://www.geeksforgeeks.org/modulus-on-negative-numbers/
  57. https://stackoverflow.com/questions/2939869/what-is-an-off-by-one-error-and-how-do-i-fix-it
  58. https://stackoverflow.com/questions/2925223/floating-point-arithmetic-modulo-operator-on-double-type
  59. https://paulkocher.com/doc/TimingAttacks.pdf
  60. https://almanac.oremus.org/easter/computus/modulo.html
  61. https://crypto.stanford.edu/pbc/notes/numbertheory/exp.html
  62. http://math.uchicago.edu/~may/REU2020/REUPapers/Pomerantz.pdf
  63. https://edoras.sdsu.edu/~mthomas/docs/cuda/CUDA_C_Programming_Guide.pdf
  64. https://www.geeksforgeeks.org/c/fmod-function-in-c/
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.