Integer division

G?ran Brostr?m 
    on Mon, 19 Dec 2022 14:22:00 +0100 writes:

G?ran Brostr?m
     on Mon, 19 Dec 2022 14:22:00 +0100 writes:

     > I have a long vector x with five-digit codes where the
     > first digit of each is of special interest, so I extracted
     > them through

     >> y <- x %/% 10000

     > but to my surprise y contained the value -1 in some
     > places. It turned out that x contains -1 as a symbol for
     > 'missing value' so in effect I found that

     >> -1 %/% 10000 == -1

     > Had to check the help page for "%/%", and the first
     > relevant comment I found was:

     > "Users are sometimes surprised by the value returned".

     > No surprise there. Further down:

     > ?%%? indicates ?x mod y? (?x modulo y?) and ?%/%?
     > indicates integer division.  It is guaranteed that

     >       ? x == (x %% y) + y * (x %/% y) ? (up to rounding
     > error)

     > I did expect (a %/% b) to return round(a / b), like
     > gfortran and gcc,

What???  I cannot believe you.

No time for checking now, but I bet that
8 / 3  gives 2 and not 3  in C and Fortran
(and hence gcc, etc)

     > but instead I get floor(a / b) in
     > R. What is the reason for these different definitions? And
     > shouldn't R's definition be documented?

     > Thanks, G?ran

     > ______________________________________________

Den 2022-12-19 kl. 15:41, skrev Martin Maechler:

G?ran Brostr?m
     on Mon, 19 Dec 2022 14:22:00 +0100 writes:

     > I have a long vector x with five-digit codes where the
     > first digit of each is of special interest, so I extracted
     > them through

     >> y <- x %/% 10000

     > but to my surprise y contained the value -1 in some
     > places. It turned out that x contains -1 as a symbol for
     > 'missing value' so in effect I found that

     >> -1 %/% 10000 == -1

     > Had to check the help page for "%/%", and the first
     > relevant comment I found was:

     > "Users are sometimes surprised by the value returned".

     > No surprise there. Further down:

     > ?%%? indicates ?x mod y? (?x modulo y?) and ?%/%?
     > indicates integer division.  It is guaranteed that

     >       ? x == (x %% y) + y * (x %/% y) ? (up to rounding
     > error)

     > I did expect (a %/% b) to return round(a / b), like
     > gfortran and gcc,

What???  I cannot believe you.

Well, you shouldn't, I generalized too far.

No time for checking now, but I bet that
8 / 3  gives 2 and not 3  in C and Fortran
(and hence gcc, etc)

But compare -8 %/% 3 in R and -8 / 3 in C/Fortran.

G,

     > but instead I get floor(a / b) in
     > R. What is the reason for these different definitions? And
     > shouldn't R's definition be documented?

     > Thanks, G?ran

     > ______________________________________________

Den 2022-12-19 kl. 15:41, skrev Martin Maechler:

G?ran Brostr?m
     on Mon, 19 Dec 2022 14:22:00 +0100 writes:

     > I have a long vector x with five-digit codes where the
     > first digit of each is of special interest, so I extracted
     > them through

     >> y <- x %/% 10000

     > but to my surprise y contained the value -1 in some
     > places. It turned out that x contains -1 as a symbol for
     > 'missing value' so in effect I found that

     >> -1 %/% 10000 == -1

     > Had to check the help page for "%/%", and the first
     > relevant comment I found was:

     > "Users are sometimes surprised by the value returned".

     > No surprise there. Further down:

     > ?%%? indicates ?x mod y? (?x modulo y?) and ?%/%?
     > indicates integer division.  It is guaranteed that

     >       ? x == (x %% y) + y * (x %/% y) ? (up to rounding
     > error)

     > I did expect (a %/% b) to return round(a / b), like
     > gfortran and gcc,

What???  I cannot believe you.

Well, you shouldn't, I generalized too far.

No time for checking now, but I bet that
8 / 3  gives 2 and not 3  in C and Fortran
(and hence gcc, etc)

But compare -8 %/% 3 in R and -8 / 3 in C/Fortran.

G,

     > but instead I get floor(a / b) in
     > R. What is the reason for these different definitions? And
     > shouldn't R's definition be documented?

     > Thanks, G?ran

     > ______________________________________________

Jeff Newmiller 
    on Mon, 19 Dec 2022 08:37:32 -0800 writes:

5 %% 3

5 %% -3

-5 %% 3

-5 %% -3

Jeff Newmiller
    on Mon, 19 Dec 2022 08:37:32 -0800 writes:

    > See https://en.m.wikipedia.org/wiki/Modulo_operation,
    > Variants of the definition, esp the point that Knuth
    > recommended the floor definition. The behavior of %/%
    > follows from the definition of %% given the documented
    > relation in ?Arithmetic.

    > R is not obligated to repeat the mistakes of C or Fortran.

Fortune nomination!  ==> BCC:  maintainer("fortunes")

The Wikipedia page is indeed revealing amazing facts about how
differently this has been implemented in computer languages.

Then, after all,  G?ran still got a point to make here, given that
not anymore are all R users equipped with a Ph.D in math or equivalent..:

It would probably be helpful to add a short paragraph to  ?Arithmetic
about the fact that R's %% uses the "floored" version, as
recommended by Donald Knuth and as documented on the above
Wikipedia page.

Martin

    > On December 19, 2022 7:15:01 AM PST, "G?ran Brostr?m"
    > <gb at ehar.se> wrote:

    >>
    >>
    >> Den 2022-12-19 kl. 15:41, skrev Martin Maechler:

    >>>>>>>> G?ran Brostr?m on Mon, 19 Dec 2022 14:22:00 +0100
    >>>>>>>> writes:

    >>>

    >>> > I have a long vector x with five-digit codes where the
    >>> > first digit of each is of special interest, so I

    >>> extracted > them through
    >>>

    >>> >> y <- x %/% 10000

    >>>

    >>> > but to my surprise y contained the value -1 in some >

    >>> places. It turned out that x contains -1 as a symbol for

    >>> > 'missing value' so in effect I found that

    >>>

    >>> >> -1 %/% 10000 == -1

    >>>

    >>> > Had to check the help page for "%/%", and the first >

    >>> relevant comment I found was:
    >>>

    >>> > "Users are sometimes surprised by the value returned".

    >>>

    >>> > No surprise there. Further down:

    >>>

    >>> > ?%%? indicates ?x mod y? (?x modulo y?) and ?%/%? >

    >>> indicates integer division.  It is guaranteed that
    >>>

    >>> > ? x == (x %% y) + y * (x %/% y) ? (up to rounding >

    >>> error)
    >>>

    >>> > I did expect (a %/% b) to return round(a / b), like >

    >>> gfortran and gcc,
    >>>
    >>> What???  I cannot believe you.

    >>
    >> Well, you shouldn't, I generalized too far.

    >>>
    >>> No time for checking now, but I bet that 8 / 3 gives 2
    >>> and not 3 in C and Fortran (and hence gcc, etc)

    >>
    >> But compare -8 %/% 3 in R and -8 / 3 in C/Fortran.
    >>
    >> G,
    >>

    >>>
    >>>

    >>> > but instead I get floor(a / b) in > R. What is the

    >>> reason for these different definitions? And > shouldn't
    >>> R's definition be documented?
    >>>
    >>>
    >>>

    >>> > Thanks, G?ran

    >>>

    >>> > ______________________________________________ >

    >>
    >> ______________________________________________

    > --
    > Sent from my phone. Please excuse my brevity.

c(-8,8) %/% 3

I have a long vector x with five-digit codes where the first digit of
each is of special interest, so I extracted them through

 > y <- x %/% 10000

but to my surprise y contained the value -1 in some places. It turned
out that x contains -1 as a symbol for 'missing value' so in effect I
found that

 > -1 %/% 10000 == -1

Had to check the help page for "%/%", and the first relevant comment I
found was:

"Users are sometimes surprised by the value returned".

No surprise there. Further down:

?%%? indicates ?x mod y? (?x modulo y?) and ?%/%? indicates
      integer division.  It is guaranteed that

      ? x == (x %% y) + y * (x %/% y) ? (up to rounding error)

I did expect  (a %/% b) to return round(a / b), like gfortran and gcc,
but instead I get floor(a / b) in R. What is the reason for these
different definitions? And shouldn't R's definition be documented?

Thanks, G?ran

The Fortran '08 standard says <<
One operand of type integer may be divided by another operand of type 
integer. Although the mathematical
quotient of two integers is not necessarily an integer, Table 7.2 
specifies that an expression involving the division
operator with two operands of type integer is interpreted as an 
expression of type integer. The result of such an
operation is the integer closest to the mathematical quotient and 
between zero and the mathematical quotient
inclusively. >>
Another way to say this is that integer division in
Fortran TRUNCATES towards zero.? It does not round and
never has.

C carefully left the behaviour of integer division (/)
unspecified, but introduced the div(,) function with the
same effect as Fortran (/).? Later versions of the C
standard tightened this up, and the C17 standard reads <<
The result of the / operator is the quotient from the division of the 
first operand by the second; the
result of the % operator is the remainder. In both operations, if the 
value of the second operand is
zero, the behavior is undefined.
When integers are divided, the result of the / operator is the algebraic 
quotient with any fractional
part discarded. 107) If the quotient a/b is representable, the 
expression (a/b)*b + a%b shall equal a ;
otherwise, the behavior of both a/b and a%b is undefined.>>

That is, C17 TRUNCATES the result of division towards
zero.? I don't know of any C compiler that rounds,
certainly gcc does not.


The Java 15 Language Specification says
<< Integer division rounds toward 0. >>
which also specified truncating division.


The help for ?"%/%" does not say what the result is.
Or if it does, I can't find it.? Either way, this is
a defect in the documentation.? It needs to be spelled
out very clearly.
R version 4.2.2 Patched (2022-11-10 r83330) -- "Innocent and Trusting"

 > c(-8,8) %/% 3

[1] -3 ?2
so we deduce that R *neither* rounds *not* truncates,
but returns the floor of the quotient.
It is widely argued that flooring division is more
generally useful than rounding or truncating division,
but it is admittedly surprising.

On Tue, 20 Dec 2022 at 02:51, G?ran Brostr?m <gb at ehar.se 
<mailto:gb at ehar.se>> wrote:

    I have a long vector x with five-digit codes where the first digit of
    each is of special interest, so I extracted them through

     ?> y <- x %/% 10000

    but to my surprise y contained the value -1 in some places. It turned
    out that x contains -1 as a symbol for 'missing value' so in effect I
    found that

     ?> -1 %/% 10000 == -1

    Had to check the help page for "%/%", and the first relevant comment I
    found was:

    "Users are sometimes surprised by the value returned".

    No surprise there. Further down:

    ?%%? indicates ?x mod y? (?x modulo y?) and ?%/%? indicates
     ? ? ? integer division.? It is guaranteed that

     ? ? ? ? x == (x %% y) + y * (x %/% y) ? (up to rounding error)

    I did expect? (a %/% b) to return round(a / b), like gfortran and gcc,
    but instead I get floor(a / b) in R. What is the reason for these
    different definitions? And shouldn't R's definition be documented?

    Thanks, G?ran

The Fortran '08 standard says <<
One operand of type integer may be divided by another operand of type 
integer. Although the mathematical quotient of two integers is not 
necessarily an integer, Table 7.2 specifies that an expression 
involving the division operator with two operands of type integer is 
interpreted as an expression of type integer. The result of such an 
operation is the integer closest to the mathematical quotient and 
between zero and the mathematical quotient inclusively. >> Another way 
to say this is that integer division in Fortran TRUNCATES towards 
zero.  It does not round and never has.

C carefully left the behaviour of integer division (/) unspecified, 
but introduced the div(,) function with the same effect as Fortran 
(/).  Later versions of the C standard tightened this up, and the C17 
standard reads << The result of the / operator is the quotient from 
the division of the first operand by the second; the result of the % 
operator is the remainder. In both operations, if the value of the 
second operand is zero, the behavior is undefined.
When integers are divided, the result of the / operator is the 
algebraic quotient with any fractional part discarded. 107) If the 
quotient a/b is representable, the expression (a/b)*b + a%b shall 
equal a ; otherwise, the behavior of both a/b and a%b is undefined.>>

That is, C17 TRUNCATES the result of division towards zero.  I don't 
know of any C compiler that rounds, certainly gcc does not.


The Java 15 Language Specification says << Integer division rounds 
toward 0. >> which also specified truncating division.


The help for ?"%/%" does not say what the result is.
Or if it does, I can't find it.  Either way, this is a defect in the 
documentation.  It needs to be spelled out very clearly.
R version 4.2.2 Patched (2022-11-10 r83330) -- "Innocent and Trusting"

 > c(-8,8) %/% 3

[1] -3  2
so we deduce that R *neither* rounds *not* truncates, but returns the 
floor of the quotient.
It is widely argued that flooring division is more generally useful 
than rounding or truncating division, but it is admittedly surprising.

On Tue, 20 Dec 2022 at 02:51, G?ran Brostr?m <gb at ehar.se 
<mailto:gb at ehar.se>> wrote:

    I have a long vector x with five-digit codes where the first digit of
    each is of special interest, so I extracted them through

      > y <- x %/% 10000

    but to my surprise y contained the value -1 in some places. It turned
    out that x contains -1 as a symbol for 'missing value' so in effect I
    found that

      > -1 %/% 10000 == -1

    Had to check the help page for "%/%", and the first relevant comment I
    found was:

    "Users are sometimes surprised by the value returned".

    No surprise there. Further down:

    ?%%? indicates ?x mod y? (?x modulo y?) and ?%/%? indicates
           integer division.  It is guaranteed that

           ? x == (x %% y) + y * (x %/% y) ? (up to rounding error)

    I did expect  (a %/% b) to return round(a / b), like gfortran and gcc,
    but instead I get floor(a / b) in R. What is the reason for these
    different definitions? And shouldn't R's definition be documented?

    Thanks, G?ran

(-8:7)%%4

Thanks Richard,

the "rounding claim" was my mistake (as I replied to Martin), I should
said "truncates toward zero" as you explain.

However, my point was that these two mathematical functions should be
defined in the documentation, as you also say. And I was surprised that
there is no consensus regarding the definition of such elementary
functions.

G?ran

On 2022-12-20 03:01, Richard O'Keefe wrote:

The Fortran '08 standard says <<
One operand of type integer may be divided by another operand of type
integer. Although the mathematical
quotient of two integers is not necessarily an integer, Table 7.2
specifies that an expression involving the division
operator with two operands of type integer is interpreted as an
expression of type integer. The result of such an
operation is the integer closest to the mathematical quotient and
between zero and the mathematical quotient
inclusively. >>
Another way to say this is that integer division in
Fortran TRUNCATES towards zero.  It does not round and
never has.

C carefully left the behaviour of integer division (/)
unspecified, but introduced the div(,) function with the
same effect as Fortran (/).  Later versions of the C
standard tightened this up, and the C17 standard reads <<
The result of the / operator is the quotient from the division of the
first operand by the second; the
result of the % operator is the remainder. In both operations, if the
value of the second operand is
zero, the behavior is undefined.
When integers are divided, the result of the / operator is the algebraic
quotient with any fractional
part discarded. 107) If the quotient a/b is representable, the
expression (a/b)*b + a%b shall equal a ;
otherwise, the behavior of both a/b and a%b is undefined.>>

That is, C17 TRUNCATES the result of division towards
zero.  I don't know of any C compiler that rounds,
certainly gcc does not.


The Java 15 Language Specification says
<< Integer division rounds toward 0. >>
which also specified truncating division.


The help for ?"%/%" does not say what the result is.
Or if it does, I can't find it.  Either way, this is
a defect in the documentation.  It needs to be spelled
out very clearly.
R version 4.2.2 Patched (2022-11-10 r83330) -- "Innocent and Trusting"

 > c(-8,8) %/% 3

[1] -3  2
so we deduce that R *neither* rounds *not* truncates,
but returns the floor of the quotient.
It is widely argued that flooring division is more
generally useful than rounding or truncating division,
but it is admittedly surprising.

On Tue, 20 Dec 2022 at 02:51, G?ran Brostr?m <gb at ehar.se
<mailto:gb at ehar.se>> wrote:

    I have a long vector x with five-digit codes where the first digit of
    each is of special interest, so I extracted them through

      > y <- x %/% 10000

    but to my surprise y contained the value -1 in some places. It turned
    out that x contains -1 as a symbol for 'missing value' so in effect I
    found that

      > -1 %/% 10000 == -1

    Had to check the help page for "%/%", and the first relevant comment

I

    found was:

    "Users are sometimes surprised by the value returned".

    No surprise there. Further down:

    ?%%? indicates ?x mod y? (?x modulo y?) and ?%/%? indicates
           integer division.  It is guaranteed that

           ? x == (x %% y) + y * (x %/% y) ? (up to rounding error)

    I did expect  (a %/% b) to return round(a / b), like gfortran and

gcc,

    but instead I get floor(a / b) in R. What is the reason for these
    different definitions? And shouldn't R's definition be documented?

    Thanks, G?ran

Richard O'Keefe 
    on Wed, 21 Dec 2022 16:44:51 +1300 writes: