integer-division

I know that similar questions has been asked in the past, but I have implemented after a long process the algorithm to find the quotient correctly using the division by repeated subtraction method. But I am not able to find out the remainder from this approach. Is there any quick and easy way for finding out remainder in 64bit/64bit division on 32bit processor. To be more precise I am trying to implement ulldiv_t __aeabi_uldivmod( unsigned long long n, unsigned long long d) Referenced in this document http://infocenter.arm.com/help/topic/com.arm.doc.ihi0043d/IHI0043D_rtabi.pdf What? If you do

I have been reading about division and integer division in Python and the differences between division in Python2 vs Python3. For the most part it all makes sense. Python 2 uses integer division only when both values are integers. Python 3 always performs true division. Python 2.2+ introduced the // operator for integer division. Examples other programmers have offered work out nice and neat, such as: >>> 1.0 // 2.0 # floors result, returns float 0.0 >>> -1 // 2 # negatives are still floored -1 How is // implemented? Why does the following happen: >>> import math >>> x = 0.5 >>> y = 0.1 >>> x

Is there is a simple, pythonic way of rounding to the nearest whole number without using floating point? I'd like to do the following but with integer arithmetic: skip = int(round(1.0 * total / surplus)) ============== @John: Floating point is not reproducible across platforms. If you want your code to pass tests across different platforms then you need to avoid floating point (or add some hacky espilon stuff to your tests and hope it works). The above may be simple enough that it would be the same on most/all platforms, but I'd rather not make that determination as it is easier to avoid

In C a floor division can be done, eg: int floor_div(int a, int b) { int d = a / b; if (a < 0 != b < 0) { /* negative output (check inputs since 'd' isn't floored) */ if (d * a != b) { /* avoid modulo, use multiply instead */ d -= 1; /* floor */ } } return d; } But this seems like it could be simplified. Is there a more efficient way to do this in C? Note that this is nearly the reverse of this question: Fast ceiling of an integer division in C / C++ Less assembly instructions in the generated code and quicker path to the result I think. For the RISC machines with huge numbers of registers