Why does C++ output negative numbers when using modulo?
===

**Math**:

If you have an equation like this:

    x = 3 mod 7

x could be ... -4, 3, 10, 17, ..., or more generally:

    x = 3 + k * 7

where k can be any integer. I don't know of a modulo operation is defined for math, but the  factor ring certainly is.

**Python**:

In Python, you will always get non-negative values when you use `%` with a positive `m`:

    #!/usr/bin/python
    # -*- coding: utf-8 -*-

    m = 7

    for i in xrange(-8, 10 + 1):
        print(i % 7)

Results in:

    6    0    1    2    3    4    5    6    0    1    2    3    4    5    6    0    1    2    3

**C++:**

    #include <iostream>

    using namespace std;

    int main(){
        int m = 7;

        for(int i=-8; i <= 10; i++) {
            cout << (i % m) << endl;
        }

        return 0;
    }

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

> 74) 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)][1] 

(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:

![enter image description here][2]

**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][3]. As you could make both numbers positive before using this algorithm, the sign of modulo would matter.)

**Additional material**: 

See [Wikipedia][4] for a long list of what modulo does in different languages.


  [1]: http://cs.nyu.edu/courses/summer12/CSCI-GA.2110-001/downloads/C++%20Standard%202003.pdf
  [2]: http://i.stack.imgur.com/8p2MN.png
  [3]: http://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
  [4]: http://en.wikipedia.org/wiki/Modulo_operation#Remainder_calculation_for_the_modulo_operation