Hi,
can anybody help with the following problem?
In C++
i = 5 / 10 and
i = 5 / 10 both have the same result 0.
In python
i = 5 / 10 gives me 0 as expected, but
i = 5 / 10 gives 1 as result.
Is this a feature or a bug? I remember Delphi gave me the same result as
C++.
TIA,
Frank
[Python] Integer math question
Tweet 

Search Discussions

John Roth at Jan 3, 2004 at 5:45 pm ⇧ "Frank" <mersmann at szut.unibremen.de> wrote in message
news:3987e01c.0401030832.114c6f2a at posting.google.com...Hi,That's a feature. Integer division is explicitly defined in
can anybody help with the following problem?
In C++
i = 5 / 10 and
i = 5 / 10 both have the same result 0.
In python
i = 5 / 10 gives me 0 as expected, but
i = 5 / 10 gives 1 as result.
Is this a feature or a bug? I remember Delphi gave me the same result as
C++.
Python to do exactly that.
The basic thing to remember is that the *correct*
mathematical result of dividing one integer by
another integer is a rational. Python does not
have a rational data type, so it has to pick one
of the multitude of possible ways of rounding a
nonintegral result to an integer.
There is no universally right answer to this process:
the "right" answer to any rounding problem is
what the customer wants it to be.
John RothTIA,
Frank 
Sean Ross at Jan 3, 2004 at 6:42 pm ⇧ "Frank" <mersmann at szut.unibremen.de> wrote in message
news:3987e01c.0401030832.114c6f2a at posting.google.com...Hi,
can anybody help with the following problem?
In C++
i = 5 / 10 and
i = 5 / 10 both have the same result 0.
In python
i = 5 / 10 gives me 0 as expected, but
i = 5 / 10 gives 1 as result.
Is this a feature or a bug? I remember Delphi gave me the same result as
C++.
TIA,
Frank
Using the division algorithm:
Let a,b be integers with b>0. Then there exist unique integers q and r such
that:
a = bq + r and 0<=r<b [1]
If we let a=5 and b, then a/b is represented by [1] as
a = bq + r
5 = (10) q + r
... skipping some steps, we find that q=0 and r=5
5 = 10(0) + 5
5 = 0 + 5
5 = 5
LHS = RHS
so, 5/10 = 0 in integer division (with no remainder).
Now, let a = 5 and b = 10
5 = (10)q + r
If we have q = 1, then
5 = (10)(1) + r
5 = 10 + r
Recall [1] above, 0 <= r < b. r must be nonnegative.
In this case r=5,
5 = 10 + 5
5 = 5
LHS = RHS
So, q = 1, and r=5, in which case 5/10 = 1 in integer division (without
remainder).
Suppose we let q=0 for the second problem above. Then
5 = (10)(0) + r
5 = 0 + r
5 = r
or
r = 5
But, by [1], r must be nonnegative. So, we have a contradiction. In which
case we can say that q cannot equal 0 in the algorithm above.
So, I suppose the answer to your question would be,
"This is a feature  Python does it properly, where the others do not."
HTH
Sean

Rainer Deyke at Jan 3, 2004 at 7:38 pm ⇧ 
Sean Ross at Jan 3, 2004 at 7:57 pm ⇧ "Rainer Deyke" <rainerd at eldwood.com> wrote in message
news:kTEJb.724242$HS4.5376202 at attbi_s01...Sean Ross wrote:Right. But, the division algorithm states "Let a,b be integers with b>0"a = bq + r and 0<=r<b [1]But 0 <= r < b is a contradiction when b < 0.
(which I mentioned in that post).

Sean Ross at Jan 3, 2004 at 8:20 pm ⇧ "Rainer Deyke" <rainerd at eldwood.com> wrote in message
news:kTEJb.724242$HS4.5376202 at attbi_s01...Sean Ross wrote:Hmm....a = bq + r and 0<=r<b [1]But 0 <= r < b is a contradiction when b < 0.

Rainer Deyke  rainerd at eldwood.com  http://eldwood.com1a = 5
b = 10
q,r = divmod(a,b)
q5r
>>>
Here, the division algorithm does not apply (b is a negative integer).
Perhaps there's some other theorem for this case?
b<r<=0, when b < 0? I don't know.

Sean Ross at Jan 3, 2004 at 9:31 pm ⇧ "Sean Ross" <sross at connectmail.carleton.ca> wrote in message
news:5sFJb.20923$Vl6.3818930 at news20.bellglobal.com..."Rainer Deyke" <rainerd at eldwood.com> wrote in messageI think you're supposed to do something like this
news:kTEJb.724242$HS4.5376202 at attbi_s01...1a = 5
b = 10
q,r = divmod(a,b)
q5rHere, the division algorithm does not apply (b is a negative integer).
Perhaps there's some other theorem for this case?
b<r<=0, when b < 0? I don't know.
a = bq + r, 0<= r < b
5 = (10)q + r
5 = (10)q  r
5 = 10q  r
But, then, q would be 0 and r would be 5. <shrug>

Samuel Walters at Jan 5, 2004 at 5:55 pm ⇧ It is, indeed, 0 <= r < abs(b)Thus Spake Sean Ross On the now historical date of Sat, 03 Jan 2004
16:31:17 0500
I think you're supposed to do something like this a = bq + r, 0<= r <b
"If a and b are integers such that b != 0, then there exist unique
integers r and q such that a = q*b + r and 0 <= r < abs(b)"
For nonmathematical spectators, the divmod() function is defined so that
q, r = divmod(a, b) by the definition above.
Sam Walters

Never forget the halloween documents.
http://www.opensource.org/halloween/
""" Where will Microsoft try to drag you today?
Do you really want to go there?""" 
Sean Ross at Jan 6, 2004 at 1:04 am ⇧ "Samuel Walters" <swalters_usenet at yahoo.com> wrote in message
news:pan.2004.01.05.17.54.22.894833 at yahoo.com..."If a and b are integers such that b != 0, then there exist uniqueRight. The only thing that was still mildly interesting to me was why does
integers r and q such that a = q*b + r and 0 <= r < abs(b)"
For nonmathematical spectators, the divmod() function is defined so that
q, r = divmod(a, b) by the definition above.
divmod() return a negative remainder?1a = 5
b = 10
q,r = divmod(a,b)
q5r
If divmod() where defined based on the definition above, then divmod(5, 10)
should return (0, 5).
Well ... that's too strong. The above is a theorem  it doesn't say
remainders have to be nonnegative,
it only says that there exist yada yada yada ... whatever, I'm not that
interested.

Elaine Jackson at Jan 4, 2004 at 6:45 am ⇧ C rounds toward the nearest integer and Python rounds down. The behavior is
consistent in each case.
"Frank" <mersmann at szut.unibremen.de> wrote in message
news:3987e01c.0401030832.114c6f2a at posting.google.com...Hi,
can anybody help with the following problem?
In C++
i = 5 / 10 and
i = 5 / 10 both have the same result 0.
In python
i = 5 / 10 gives me 0 as expected, but
i = 5 / 10 gives 1 as result.
Is this a feature or a bug? I remember Delphi gave me the same result as
C++.
TIA,
Frank 
Elaine Jackson at Jan 4, 2004 at 6:50 am ⇧ Sorry, I should have said "C rounds toward zero". In other words, the result of
casting x to integer type is sgn(x)*floor(abs(x)).
"Elaine Jackson" <elainejackson7355 at home.com> wrote in message
news:uEOJb.933787$pl3.753391 at pd7tw3no...C rounds toward the nearest integer and Python rounds down. The behavior is
consistent in each case.
"Frank" <mersmann at szut.unibremen.de> wrote in message
news:3987e01c.0401030832.114c6f2a at posting.google.com...Hi,
can anybody help with the following problem?
In C++
i = 5 / 10 and
i = 5 / 10 both have the same result 0.
In python
i = 5 / 10 gives me 0 as expected, but
i = 5 / 10 gives 1 as result.
Is this a feature or a bug? I remember Delphi gave me the same result as
C++.
TIA,
Frank 
Derek Ledbetter at Jan 4, 2004 at 11:02 am ⇧ On Sat, 3 Jan 2004 8:32:07 0800, Frank wrote
(in message <3987e01c.0401030832.114c6f2a at posting.google.com>):In C++Actually this is implementation defined in C89 and standard C++. Either
i = 5 / 10 and
i = 5 / 10 both have the same result 0.
5/10 == 0 and 5%10 == 5, as in your implementation, or 5/10 == 1
and 5%10 == 5, like Python. In C99, and possibly a future version of
C++, it's always done the first way (rounding towards zero).

Derek Ledbetter
derekl at serve.com
Heavy boots of lead
fills his victims full of dread
Running as fast as they can
Iron Man lives again! 
Dan Bishop at Jan 5, 2004 at 12:59 am ⇧ mersmann at szut.unibremen.de (Frank) wrote in message news:<3987e01c.0401030832.114c6f2a at posting.google.com>...Hi,The problem is that you aren't using "from __future__ import division"
can anybody help with the following problem? ...
i = 5 / 10 gives me 0 as expected, but
i = 5 / 10 gives 1 as result.
;) (This causes the results to be 0.5 and 0.5, and will be the
default division semantics in Python 3.0. If you want integer
division, use the // operator.)Is this a feature or a bug?It's a feature. The advantage of defining x // y as floor(x / y) is
that x % y is always nonnegative.
As as example of why this is useful, consider the
datetime.date.weekday method. This could be implemented as
def weekday(self):
return (self.fromordinal()  1) % 7
If the datetime module was changed to allow BC(E) dates (which have
nonpositive Rata Die numbers), the weekday method would still work.
In C++, you'd have to treat such dates as a special case.

Bengt Richter at Jan 8, 2004 at 6:53 pm ⇧ It is a feature. Python does the more useful thing IMO.On 3 Jan 2004 08:32:07 0800, mersmann at szut.unibremen.de (Frank) wrote:
Hi,
can anybody help with the following problem?
In C++
i = 5 / 10 and
i = 5 / 10 both have the same result 0.
In python
i = 5 / 10 gives me 0 as expected, but
i = 5 / 10 gives 1 as result.
Is this a feature or a bug? I remember Delphi gave me the same result as
C++.
If you look on / (or now //) as a denominatordefined mapping
of integer intervals to integers, it is clearer.
I.e., the mappings that python implements are
[denom*k, denom*k+denom) => k for denom >0
and
[denom*k+denom, denom*k) => k for denom <0
The C version is ugly, because it maps a unique extrasized interval
around zero to zero, i.e., for denom>0
[denom+1, denom) => 0
which contains 2*denom1 source integers, and all the rest of the
intervals go symmetrically in both directions from there, containing
denom integers. Python's source intervals are all the same size.
====< showintdiv.cpp >=====================================
#include <stdio.h>
#include <stdlib.h>
void main(int argc, char* argv[]){
if(argc<4){ printf("Usage: %s xlo xhi den\n", argv[0]); return; }
int xlo = atoi(argv[1]);
int xhi = atoi(argv[2]);
int den = atoi(argv[3]);
int x;
for(x=xlo; x<xhi; ++x) printf("%3d", x); printf("\n");
for(x=xlo; x<xhi; ++x) printf("%3d", x/den); printf("\n");
}
===========================================================
We'll do a weird printf JFTHOI and to match program lines better:
====< showintdiv.py >======================================
printf = (lambda wso, fmt, *args: wso(fmt%args)).__get__(
__import__('sys').stdout.write)
def main(argv):
if len(argv)<4: printf("Usage: %s xlo xhi den\n" % argv[0]); return
xlo = int(argv[1])
xhi = int(argv[2])
den = int(argv[3])
for x in xrange(xlo, xhi): printf("%3d", x)
printf("\n");
for x in xrange(xlo, xhi): printf("%3d", x/den)
printf("\n");
if __name__== '__main__':
import sys
main(sys.argv)
===========================================================
Python maps successive equal sized intervals to successive integers from inf to +inf
[10:38] C:\pywk\clp>showintdiv.py 15 16 5
151413121110 9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
3 3 3 3 3 2 2 2 2 2 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3
But C maps symmetrically across zero, causing 2*denom1 points to map to zero
[10:38] C:\pywk\clp>showintdiv.exe 15 16 5
151413121110 9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
3 2 2 2 2 2 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3
With a negative denominator, python still maps successive intervals, but going the other
direction from (and including) zero.
[10:38] C:\pywk\clp>showintdiv.py 15 16 5
151413121110 9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
3 2 2 2 2 2 1 1 1 1 1 0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
Whereas C is still symmetric with the 2n1 points going to zero:
[10:38] C:\pywk\clp>showintdiv.exe 15 16 5
151413121110 9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
3 2 2 2 2 2 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3
The extrasized interval across zero makes for a hiccup in the use of the mapping as a function.
E.g., you can't translate the input by k*denom and get a uniformly translated (by k) output
unless you stay away from the zero interval.
Ok, back to the grind...
Regards,
Bengt Richter
Related Discussions
Discussion Navigation
view  thread  post 
Discussion Overview
group  pythonlist 
categories  python 
posted  Jan 3, '04 at 4:32p 
active  Jan 8, '04 at 6:53p 
posts  17 
users  9 
website  python.org 