Why does integer division round down in many scripting languages?

Solution 1:

Ideally, we would like to have two operations div and mod, satisfying, for each b>0:

1. (a div b) * b + (a mod b) = a
2. 0 <= (a mod b) < b
3. (-a) div b = -(a div b)

This is, however, a mathematical impossibility. If all the above were true, we would have

1 div 2 = 0
1 mod 2 = 1

since this is the unique integer solution to (1) and (2). Hence, we would also have, by (3),

0 = -0 = -(1 div 2) = (-1) div 2

which, by (1), implies

-1 = ((-1) div 2) * 2 + ((-1) mod 2) = 0 * 2 + ((-1) mod 2) = (-1) mod 2

making (-1) mod 2 < 0 which contradicts (2).

Hence, we need to give up some property among (1), (2), and (3).

Some programming languages give up (3), and make div round down (Python, Ruby).

In some (rare) cases the language offers multiple division operators. For instance, in Haskell we have div,mod satisfying only (1) and (2), similarly to Python, and we also have quot,rem satisfying only (1) and (3). The latter pair of operators rounds division towards zero, at the price of returning negative remainders, e.g., we have (-1) `quot` 2 = 0 and (-1) `rem` 2 = (-1).

C# also gives up (2), and allows % to return a negative remainder. Coherently, integer division rounds towards zero. Java, Scala, Pascal, and C, starting from C99, also adopt this strategy.

Solution 2:

Floating-point operations are defined by IEEE754 with numeric applications in mind and, by default, round to the nearest representable value in a very strictly-defined manner.

Integer operations in computers are not defined by general international standards. The operations granted by languages (especially those of the C family) tend to follow whatever the underlying computer provides. Some languages define certain operations more robustly than others, but to avoid excessively difficult or slow implementations on the available (and popular) computers of their time, will choose a definition that follows its behaviour quite closely.

For this reason, integer operations tend to wrap around on overflow (for addition, multiplication, and shifting-left), and round towards negative infinity when producing an inexact result (for division, and shifting-right). Both of these are simple truncation at their respective end of the integer in two's-complement binary arithmetic; the simplest way to handle a corner-case.

Other answers discuss the relationship with the remainder or modulus operator that a language might provide alongside division. Unfortunately they have it backwards. Remainder depends on the definition of division, not the other way around, while modulus can be defined independently of division - if both arguments happen to be positive and division rounds down, they work out to be the same, so people rarely notice.

Most modern languages provide either a remainder operator or a modulus operator, rarely both. A library function may provide the other operation for people who care about the difference, which is that remainder retains the sign of the dividend, while modulus retains the sign of the divisor.

Solution 3:

Because the implication of integer division is that the full answer includes a remainder.