📋

Walk-through

How to Use This Calculator

3 steps

1

Enter the dividend and divisor

Type the dividend <code>a</code> (the number being divided) and the divisor <code>n</code> (the modulus). Both can be negative, and the divisor can be a large integer — the calculator keeps full precision with BigInt. The result updates instantly as you type.

2

Read all three remainders

The result card shows the remainder under each sign convention side by side: truncated (what JavaScript, C, Go, Rust and Java return), floored (what Python and Ruby return), and Euclidean (the always-non-negative mathematical answer). Each card also shows the matching quotient so the identity <code>a = q·n + r</code> holds.

3

Compare conventions or jump to modular exponentiation

Open the Convention Explainer tab to see exactly where each remainder lands on a number line and why they differ — the conventions only ever disagree when one operand is negative. For programming or cryptography, switch to the Modular Exponentiation tab to compute <code>(base^exp) mod m</code> for huge exponents using fast square-and-multiply.

⚡

Reference

Formula & Methodology

5 formulas

Truncated modulo (JavaScript, C, Go, Rust, Java)

q = trunc(a / n), r = a − n·q

The quotient rounds toward zero, so the remainder takes the sign of the dividend a. This is exactly what the % operator returns in most C-family languages: −7 % 3 = −1.

Floored modulo (Python, Ruby)

q = floor(a / n), r = a − n·q ⇒ r = ((a mod n) + n) mod n for n > 0

The quotient rounds toward negative infinity, so the remainder takes the sign of the divisor n. This is what Python's % returns: −7 % 3 = 2.

Euclidean modulo (number theory)

r = a − |n|·floor(a / |n|), with 0 ≤ r < |n|

The remainder is always non-negative regardless of the signs of a and n. This is the residue meant by 'a mod n' in modular arithmetic and congruences.

Division identity

a = q·n + r

Every convention satisfies this identity — they simply choose different (q, r) pairs. That is the whole reason a single 'remainder' can have three different values.

Modular exponentiation (fast square-and-multiply)

(base^exp) mod m = reduce mod m after every multiply

Process the exponent bit by bit, squaring a running base and multiplying it into the result whenever a bit is set — always reducing mod m. This computes results with hundreds of digits of exponent instantly and is the engine behind RSA and Diffie-Hellman.

📖

Glossary

Key Terms Explained

11 terms

Modulo (mod) The operation that returns the remainder left over after dividing one integer by another. 'a mod n' answers: what is left of a after taking out as many whole copies of n as possible?

Dividend (a) The number being divided — the left operand of a mod n. It may be positive, negative, or zero.

Divisor / Modulus (n) The number you divide by — the right operand and the size of the wrap-around. It must be non-zero; dividing by zero leaves the remainder undefined.

Quotient (q) How many whole times the divisor fits into the dividend. Each sign convention rounds the quotient differently (toward zero, toward −∞, or to keep r non-negative).

Remainder (r) What is left after the quotient is taken out: r = a − q·n. Its sign depends on which convention you use when a or n is negative.

Truncated division Rounds the quotient toward zero. The remainder then carries the sign of the dividend. Used by JavaScript, C, C++, Java, Go, Rust, and Swift.

Floored division Rounds the quotient toward negative infinity. The remainder then carries the sign of the divisor. Used by Python and Ruby.

Euclidean modulo Defines the remainder to always be in the range 0 ≤ r < |n|. This is the residue used in number theory, congruences, and clock arithmetic.

Congruence (a ≡ b mod n) Two integers are congruent modulo n when they leave the same Euclidean remainder — equivalently, when n divides their difference.

Modular inverse The number x such that a·x ≡ 1 (mod m). It exists only when a and m share no common factor (gcd = 1) and is found with the extended Euclidean algorithm.

Modular exponentiation Computing (base^exp) mod m efficiently without ever forming the full power, by reducing mod m after each squaring and multiplication.

👥

Scenarios

Real-World Examples

3 worked examples

🧮

Developer porting code

−7 mod 3 across languages

Dividend a -7 Divisor n 3

JavaScript and C return −1 (truncated: sign of the dividend). Python and Ruby return 2 (floored: sign of the divisor). The mathematical answer is also 2 (Euclidean). If you port a hashing or index-wrapping routine from Python to JavaScript without adjusting for this, negative inputs will silently produce out-of-range indices — the single most common modulo bug.

🕐

Clock arithmetic

What time is it 17 hours after midnight?

Dividend a 17 Divisor n 12

17 mod 12 = 5, so 17:00 in 12-hour terms is 5 o'clock. Because both operands are positive, all three conventions agree. Clock and calendar math is the everyday face of Euclidean modulo: hours wrap at 12, minutes at 60, weekdays at 7.

🔐

Cryptography student

RSA-style power: 4¹³ mod 497

Base 4 Exponent 13 Modulus m 497

4¹³ is 67,108,864 — but you never need that number. Fast square-and-multiply reduces mod 497 after every step and returns 445 in just a handful of operations. Real RSA does the same with 2048-bit exponents, which is why public-key cryptography is fast enough to use on every HTTPS connection.

📄

Deep Dive

Modulo, Remainders, and Why −7 mod 3 Has Three Answers

3 chapters · 5 min read

Modulo looks like the simplest operation in programming — just the remainder after division — until a negative number shows up and your language disagrees with the one next to it. This calculator shows every answer at once so you always know which convention you are looking at, and adds modular exponentiation for the cryptography and hashing cases where modulo really earns its keep.

The remainder is not unique — the quotient decides it

Division of integers produces a quotient and a remainder linked by one identity: a = q·n + r. The catch is that this single equation has more than one integer solution once signs get involved. Pin down how you round the quotient and the remainder follows automatically.

Round the quotient toward zero (truncated division) and the remainder ends up with the sign of the dividend a. Round it toward negative infinity (floored division) and the remainder takes the sign of the divisor n. Insist that the remainder be non-negative and you get the Euclidean convention used throughout mathematics. None of these is 'wrong' — they are three internally consistent answers to a genuinely ambiguous question.

Why JavaScript and Python disagree

-7 % 3 is -1 in JavaScript, C, C++, Java, Go, and Rust, but 2 in Python and Ruby. The C-family languages standardized on truncated division decades ago, so their % keeps the sign of the dividend. Python's designers chose floored division because it makes % behave nicely for the most common real use — wrapping an index into a fixed range — where you almost always want a non-negative result.

This is a frequent source of bugs when porting code or calling across language boundaries. A pattern like arr[i % len] is safe in Python even when i is negative, but in JavaScript it can index with a negative number. The portable fix is to force the Euclidean result explicitly: ((i % len) + len) % len.

Where modulo actually matters: clocks, hashing, and crypto

Wrap-around math. Clocks (mod 12 or 24), weekdays (mod 7), and angles (mod 360) are all Euclidean modulo. Anything that cycles is a modulo in disguise.

Hashing and load balancing. Hash tables place a key in bucket hash(key) mod numBuckets. Because hashes are often signed, this is exactly where the negative-remainder bug bites — and why the Euclidean convention is what you want for a valid bucket index.

Cryptography. RSA and Diffie-Hellman are built on modular exponentiation: raising a number to a large power modulo a large number. Computing the power directly is impossible (the intermediate values would have astronomically many digits), so the fast square-and-multiply method reduces modulo m after every step. The Modular Exponentiation tab in this calculator runs that exact algorithm over BigInt.

❓

Questions

Frequently Asked Questions

7 questions

Why do Python and JavaScript give different answers for −7 mod 3?+

They use different division conventions. JavaScript (like C, Java, Go, and Rust) uses truncated division, so the remainder takes the sign of the dividend: −7 % 3 = −1. Python (like Ruby) uses floored division, so the remainder takes the sign of the divisor: −7 % 3 = 2. Both satisfy a = q·n + r — they just pick different quotients. To get the Python-style non-negative result in JavaScript, use ((a % n) + n) % n.

What is −7 mod 3?+

It depends on the convention. Truncated (JavaScript/C): −1. Floored (Python/Ruby): 2. Euclidean (mathematics): 2. The Euclidean answer 2 is the one meant when mathematicians write −7 ≡ 2 (mod 3), because the Euclidean remainder is always between 0 and |n| − 1.

Is modulo the same as the remainder?+

For positive numbers, yes — they're identical. The distinction only appears with negative operands, where 'remainder' (often the truncated result your CPU produces) can be negative, while 'modulo' in the mathematical sense is the non-negative Euclidean residue. Because different languages use the word for different conventions, this calculator shows all of them so there's no ambiguity.

Can the divisor be zero or negative?+

The divisor cannot be zero — division by zero is undefined, so the calculator shows an error for n = 0. A negative divisor is perfectly valid and is exactly where the conventions diverge: with floored division the remainder follows the sign of the divisor, so the answer can be negative even when the dividend is positive (for example 7 mod −3 = −2 in Python).

What is modular exponentiation used for?+

It computes (base^exp) mod m efficiently and is the core operation of public-key cryptography. RSA encryption, decryption, and Diffie-Hellman key exchange all raise numbers to large powers modulo a large number. The fast square-and-multiply algorithm reduces modulo m after each step so intermediate values never explode — letting you handle thousand-bit exponents instantly. The Modular Exponentiation tab demonstrates this and even supports negative exponents via the modular inverse.

Does this calculator handle very large numbers?+

Yes. Both the divisor calculations and modular exponentiation use JavaScript BigInt internally, so integers with hundreds of digits are computed exactly with no floating-point rounding. Non-integer (decimal) inputs are supported too, but those are evaluated in floating point and flagged as such.

What is a modular inverse?+

The modular inverse of a modulo m is the number x with a·x ≡ 1 (mod m). It exists only when a and m are coprime (their greatest common divisor is 1) and is computed with the extended Euclidean algorithm. The Modular Exponentiation tab uses it to evaluate negative exponents — for example 3⁻¹ mod 11 = 4, because 3·4 = 12 ≡ 1 (mod 11). When no inverse exists (gcd ≠ 1), the calculator says so instead of returning a wrong answer.

Download a one-page PDF of your numbers instantly. Add your email to also get our occasional calculator tips — no spam, unsubscribe anytime. Privacy.

Modulo Calculator

Inputs

Result

(base ^exp) mod m

Result

Why conventions disagree

Where the remainder lands

How to Use This Calculator

Enter the dividend and divisor

Read all three remainders

Compare conventions or jump to modular exponentiation

Formula & Methodology

Key Terms Explained

Real-World Examples

Developer porting code

Clock arithmetic

Cryptography student

Modulo, Remainders, and Why −7 mod 3 Has Three Answers

The remainder is not unique — the quotient decides it

Why JavaScript and Python disagree

Where modulo actually matters: clocks, hashing, and crypto

Frequently Asked Questions

Get a branded PDF of your results

Modulo Calculator

Inputs

Result

(base exp) mod m

Result

Why conventions disagree

Where the remainder lands

How to Use This Calculator

Enter the dividend and divisor

Read all three remainders

Compare conventions or jump to modular exponentiation

Formula & Methodology

Key Terms Explained

Real-World Examples

Modulo, Remainders, and Why −7 mod 3 Has Three Answers

The remainder is not unique — the quotient decides it

Why JavaScript and Python disagree

Where modulo actually matters: clocks, hashing, and crypto

Frequently Asked Questions

Get a branded PDF of your results

Keep Exploring

Related calculators

Guides & articles

(base ^exp) mod m