[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: Integer residue-classes [was: Questions about srfi-77 Generic Arithmetic]
About certain issues that have been raised recently on this list (and
some other random observations):
1. I now understand Egner et al.'s motivation of having (div x 0)
=> 0 and (mod x 0) => x. I still disagree with having it in a
programming language; see (2).
2. If someone passes 0 as the second argument to a division/quotient/
remainder/modulo/div/mod operator, I think it is infinitely more
likely to be an error than to mean return 0 (as div) or return the
first argument (as mod), because the programmer was thinking of the
result of the homomorphism of mapping the integers onto the quotient
ring of the integers by the zero ideal (which again happens to be
isomorphic to the integers).
3. I agree with Bawden and Egner et al. that there should be a
division operator associated with the modulo operation, in the same
way that current quotient is related to current remainder.
4. I cannot remember any argument to say that the modulo function
(mod x n) with representatives from -n/2 (inclusive) to n/2
(exclusive) is of use in programs. I can't think of any examples
where it's useful. Furthermore, the only reason I can remember which
end of the interval containing the result is inclusive is because of
an analogy with hardware implementations of twos complement
arithmetic, so I think that perhaps there is no natural choice of
which endpoint is inclusive.
5. I still really dislike choosing what operation is done by the
sign of the second argument.
6. I think (quotient x n) => (round-to-zero (/ x n)) is a natural
operator for those who've been taught long division in school; and so
I find no problem with the associated operator (remainder x n) => (-
x (* n (quotient x n))).
7. When n is positive, the (mathematical) modulo operation has the
definition (modulo x n) => (- x (* n (floor (/ x n)))). The current
definition in Scheme of modulo retains this definition for negative
n, which I have no problem with (but I'm open to considering other
options). So, like I said in (3) above, I would welcome a new
operator that implements the operation (/ (- x (modulo x n)) n),
whatever the definition of modulo.