C not mathematically conforming? 
Author Message
 C not mathematically conforming?


: > Just out of curiosity, why does C not have a mathematically accurate mod (%)
: > and integer divide? It works for positive numbers just fine, of course, but
: > when you get into negative numbers, it does it the "common sense" way,
: which is
: > not the best way. (In my opinion, at least). The mathematical mod and div are
: > based upon the division algorithm, or a=bq+r, where q is an integer, and
: > 0<=r<b. a%b then should return r, and a/b should return q. However, when I do
: > something like -22%6, it gives -4, instead of 2. ( -22=6(-4)+2 ). This
: has been
: > annoying at times, especially when I was trying to implement a large integer
: > class, and I had to creat a special mod function for the large subtraction
: > function. Creating the new function wasn't that difficult, but it just seems
: > strange that C doesn't do it the standard mathematical way. I noticed
: that it's
: > the same in Pascal (at least Turbo Pascal). I tested the C in both Turbo C and
: > gcc/g++. Is this defined by ANSI by any change?

: There are two reasons:

: First, there is no universal agreement what (-5) / 3 should be. There are
: in my opinion two very reasonable definitions: One is that integer
: division should always round towards zero, the other is that integer
: division should always round down (another is that integer division should
: round according to the sign of the divisor). Actually I prefer rounding
: down if the divisor is positive, and have no opinion if the divisor is
: negative.

: Second, most processors have a divide instruction which gives the right
: results for positive numbers and works in some fixed way for negative
: numbers. If you divide x / y, the compiler doesnt know the signs of x and
: y. So if the standard defines what the results should be, and the
: processor happens to do it different, every single divide operation has to
: check the signs of the operands and do a lot of work. Actually, many
: processors I know do round towards zero, which is not the behavior we both
: would prefer. By leaving division of negative numbers implementation
: defined, these processors have a chance to use a single divide assembler
: instruction to implement the / operator.

: -- For email responses, please remove the last emm from my address.

--
*************begin r.s. response*****************

        very interesting ...

        cast to unsigned type may be
        done directly ... or indirectly
        ...

        directly ...
                ((unsigned) joevar )

        indirectly ...
                joeunsignedvar = joevar
        ( at least traditionally ... )
         ( then work with joeunsignedvar )
        .

*************end r.s. response*******************
Ralph Silverman



Mon, 30 Aug 1999 03:00:00 GMT  
 
 [ 1 post ] 

 Relevant Pages 

1. to CS: or not to CS: in F-PC assembler

2. Standards conforming or not?

3. http package does not conform HTTP/1.0

4. Believe or not, Forth in CS!

5. VWNC: vwnc@cs.uiuc.edu not working?

6. Why can't mutation be expressed mathematically??

7. Mathematically equivalent

8. LINKing to Language-Environment conforming routine

9. Non conforming numerics

10. Problems with non-conforming Create?!

11. Conforming to a deferred class

12. ANN: Logging Module for Python conforming to PEP 282, first release

 

 
Powered by phpBB® Forum Software