Rounding with Div and Mod operators

Dear Newsgroup


I'm writing a compiler for a new language which is to include the
integer division and integer remainder operators (div and mod). I have
some questions about the way these operators do rounding with negative
operands and would appreciate any feedback.


As I understand it div and mod (please excuse the Pascal notation)
should always conform to a Fundamental Rule that for an integer
numerator (n) and integer divisor (d) with d <> 0:


    n = (n div d) * d + (n mod d)


What is interesting about this rule is there seem to be two ways of
rounding that satisfy it when n or d are negative - either we round
integers to the next lowest value or we round towards zero. The
following table shows some positive and negative values of n and d
under both systems:


-------------------------------------------------
                    (div rounds down (div rounds
                    to next lower int) towards zero)
  n d n div d n mod d n div d n mod d
-------------------------------------------------
  3 2 1 1 1 1
  2 2 1 0 1 0
  1 2 0 1 0 1
  0 2 0 0 0 0
-1 2 -1 1 0 -1
-2 2 -1 0 -1 0
-3 2 -2 1 -1 -1


  3 -2 -2 -1 -1 1
  2 -2 -1 0 -1 0
  1 -2 -1 -1 0 1
  0 -2 0 0 0 0
-1 -2 0 -1 0 -1
-2 -2 1 0 1 0
-3 -2 1 -1 1 -1
-------------------------------------------------


The middle two columns show a rounding system that goes to the next
lowest integer, and the rightmost two columns show a system that
rounds towards zero. The two systems are different when n and d have
different signs, as you can see by comparing the n div d columns. Both
systems meet the Fundamental Rule.


My question is: which rounding system is preferred and does it matter?
So far my thoughts and investigations have come up with the following:


(1) The middle columns looks neater as div goes in steps of two,
1,1,0,0,-1,-1 etc. Also mod looks neater as it does not suddenly
change sign as we pass through zero. Thus rounding to the lower
integer is best...


(2) Borland Pascal (Delphi v1) and Microsoft C (VC 1.5, 4) round
according to the righthand columns, ie towards zero. I think this is
because on the PC the default rounding of the Intel IDIV opcode is
towards zero. Thus for compatibility and performance on the PC
rounding towards zero is best...


(3) The language I'm developing also includes an "int" operator which
takes a real number operand and returns an integer which is the
operand rounded down to the next lowest integer (if the operand is an
exact integer value it is unaltered). Thus if I define div using next
lowest integer rounding, it is redundant as (n div d = int(n/d))
always. Thus rounding to the lower integer is redundant...


Any thoughts would be most welcome. So far the only relevant
information I have found on Usenet is a posting from 1994 which
discusses rounding in the context of Pascal and concluded the
Fundamental Rule only applied for n >= 0 and d > 0.


Sincerely
William Rayer
lingolanguage@hotmail.com
[This has been debated at length over the years, and I've found the
argument to be similar to the byte order argument in that there are
advantages and disadvantages to both, but none strong enough to tip
the scales firmly in favor of one or the other. For what it's worth,
Fortran 90 uses round toward zero. -John]

Return to the comp.compilers page.
Search the comp.compilers archives again.