12

As most of us know, or should know, $-7 \equiv 1 \pmod 4$.

But if you use Java's modulus operator %, you get -3 for the answer, not 1. That's technically correct, but it can cause problems if you're not aware of this as you write a program. C# and Javascript are the same way.

Worse, there are varieties of BASIC which will give you the remainder of the absolute value, e.g., 3 for the example of $-7$; that's clearly wrong.

It looks like only Maple and Mathematica (and by extension, Wolfram Alpha) know better.

Why is this?

David R.
  • 1,316
  • 4
    -7 % 4 = -3 can be understood as: keep moving from -7 toward 0 in increments of 4 until you would pass 0 if you did it again. Return what you have at that point. It is a reasonable choice of a representative, all things said. The only problem is that it means that (n%4 : n in Z) has 7 elements when it "should" have 4. By the way, Haskell has separate rem and mod functions, so in a sense it "knows better". – Ian Aug 22 '17 at 21:32
  • 2
    I suspect it comes from hardware implementations that compute the quotient and remainder in one operation. For positive dividends, the quotient is rounded down, i.e. toward either 0 or $-\infty$. For negative dividends, those are not the same, so which should it be? If you choose to round toward zero, you get a negative remainder. – Nate Eldredge Aug 22 '17 at 21:33
  • 2
    Some languages, e.g. Pascal, want to keep the fundamental relation (x div y)*y + x mod y = x with $ 0 \le x \bmod y < y$ if $x \ge 0, y>0$. The situation really gets wierd if $y < 0!$ – gammatester Aug 22 '17 at 21:37
  • 1
    FWIW, in Python the % modulus operator returns a remainder with the same sign as the divisor, and it provides a // floor division operator (i.e., it rounds towards negative infinity). If you like, you can get both quotient & remainder in a single built-in function call: q, r = divmod(n, d); the division & modulus operators / function preserve the identity n = q * d + r. – PM 2Ring Aug 22 '17 at 21:40
  • 1
    @NateEldredge +1. It's also worth noting that the use of % for remainder is, to the best of my knowledge, inherited from the C language (or rather its predecessor, B) in the early 1970s. Since C is a systems-level programming language, it made a lot of sense for the software specification to follow the hardware. – Erick Wong Aug 22 '17 at 22:11
  • 1
    (-7)%4 is $1$ in Lua. Try print((-7)%4) in the Lua online demo. – lhf Aug 23 '17 at 00:36
  • 1
    I know your pain! I once managed to create an interesting bug in the DOS era, because I didn't know about this. Anyway, others already described the historical reasons.I wanted to add that processors such as Intel x86 family do it this way. Therefore it stands to reason that languages running on that hardware would follow the same convention (admittedly that is a chicken vs. egg situation). Mathematica is not so sold on speed, so they have probably inserted a check that removes this problem (warming the hearts of algebraists is of more concern to them) – Jyrki Lahtonen Aug 25 '17 at 21:57
  • There are fields of study where it is preferred that the residuals are "centered" about $0$; error free programming for example. It's a mistake not to at least glance at the specs of a function and do some case testing before you use it. – Steven Alexis Gregory Aug 27 '17 at 18:51
  • @stevengregory That's quite true in general for any programming. I suppose some people would notice how it works, account for it and move on. But others wonder: why is it this way? – David R. Aug 31 '17 at 21:17
  • @DavidR. I have to at least sort of say this. Hence they should $\text{RT}\bigstar \bigstar$ – Steven Alexis Gregory Sep 01 '17 at 06:59

3 Answers3

7

I believe that the primary justification for this is that division in these languages generally rounds towards 0 instead of towards -infinity when doing integer division (questionably) and they want to preserve the identity that (a // b) * b + (a mod b) = a (rightly). From a mathematical standpoint I completely agree that a mod b should always be in [0, b) and do question the original justification for this decision, however for compatibility it is unreasonable to try and change the standard now. Note that there are other languages beyond the ones you have mentioned, such as Python which do behave in this way.

KSab
  • 333
  • 4
    This was the opinion of Brian Kernighan: no matter what rounding rule was used, the C language insisted that x = (x%m)+(x/m)*m – kimchi lover Aug 22 '17 at 22:08
4

Hint: The paper The Euclidean Definition of the Functions $\mathrm{div}$ and $\mathrm{mod}$ by R.T. Boute provides an in-depth discussion of different definitions in mathematics and programming languages.

I'm a great fan of D.E. Knuth and since his F-definition (flooring the quotient and rounding toward negative infinity) is addressed in the paper as one of two preferred approaches, I also recommend reading section 3.4 '$\mathrm{MOD}$' - THE BINARY OPERATION in Concrete Mathematics.

Markus Scheuer
  • 112,413
3

Let there be given integers $m \lt 0$ and $b \gt 0$.

Proposition: There exist unique integers $q$ and $r$ satisfying the following conditions:

$\quad q \le 0$

$\quad0 \le -r \lt b\;$ (so $r$ is a nonpositive integer)

$\quad m = qb + r$

The proof is left as an exercise for the interested reader.

If you are working with mixed numbers/improper fractions, this might float your boat; see How to Convert a Negative Mixed Number Into an Improper Fraction : Fractions 101. So $-7/4 = -1 \frac{3}{4}$, and some might insist that $-7 \equiv -3 \pmod 4$ make sense.

CopyPasteIt
  • 11,870