If you have an equation like this:
x mod 7 = 3
x could be ... -4, 3, 10, 17, ..., or more formally:
x = 3 + k * 7
where k can be any integer. I don't know if a modulo operation is defined for math, but the factor ring certainly is.
In Python, you will always get non-negative values when you use %
with a positive m
:
m = 7
for i in range(-8, 10 + 1):
print(i % 7, end=" ")
results in:
6 0 1 2 3 4 5 6 0 1 2 3 4 5 6 0 1 2 3
#include <iostream>
int main()
{
int m = 7;
for (int i = -8; i <= 10; i++)
std::cout << (i % m) << " ";
}
will output:
-1 0 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 0 1 2 3
ISO/IEC 14882:2003(E) - 5.6 Multiplicative operators:
The binary / operator yields the quotient, and the binary % operator yields the remainder from the division of the first expression by the second. If the second operand of / or % is zero the behavior is undefined; otherwise (a/b)*b + a%b is equal to a. If both operands are nonnegative then the remainder is nonnegative; if not, the sign of the remainder is implementation-defined 74).
and
- According to work underway toward the revision of ISO C, the preferred algorithm for integer division follows the rules defined in the ISO Fortran standard, ISO/IEC 1539:1991, in which the quotient is always rounded toward zero.
Source: ISO/IEC 14882:2003(E)
(I couldn't find a free version of ISO/IEC 1539:1991
. Does anybody know where to get it from?)
The operation seems to be defined like this:
Question:
Does it make sense to define it like that?
What are arguments for this specification? Is there a place where the people who create such standards discuss about it? Where I can read something about the reasons why they decided to make it this way?
Most of the time when I use modulo, I want to access elements of a datastructure. In this case, I have to make sure that mod returns a non-negative value. So, for this case, it would be good of mod always returned a non-negative value. (Another usage is the Euclidean algorithm. As you could make both numbers positive before using this algorithm, the sign of modulo would matter.)
Additional material:
See Wikipedia for a long list of what modulo does in different languages.
On x86 (and other processor architectures), integer division and modulo are carried out by a single operation, idiv
(div
for unsigned values), which produces both quotient and remainder (for word-sized arguments, in AX
and DX
respectively). This is used in the C library function divmod
, which can be optimised by the compiler to a single instruction!
Integer division respects two rules:
dividend = quotient*divisor + remainder
is satisfied by the results.Accordingly, when dividing a negative number by a positive number, the quotient will be negative (or zero).
So this behaviour can be seen as the result of a chain of local decisions: