Is it possible to divide an unsigned integer by 10 by using pure bit shifts, addition, subtraction and *maybe* multiply?  Using a processor with very limited resources and slow divide.

Divide by 10 using bit shifts?

Is there something like a modulo operator or instruction in x86 assembly?


Assembly Language - How to do Modulo?

For this code block:

    int num = 5;
    int denom = 7;
    double d = num / denom;

the value of `d` is `0.0`. It can be forced to work by casting:

    double d = ((double) num) / denom;

But is there another way to get the correct `double` result? I don&#39;t like casting primitives, who knows what may happen.

Integer division: How do you produce a double?

For example:

    9 / 5  #=&gt; 1

but I expected `1.8`. How can I get the correct decimal (non-integer) result? Why is it returning `1` at all?

Why is division in Ruby returning an integer instead of decimal value?

In **JavaScript**, how do I get:

 1. The whole number of times a given integer goes into another?
 2. The remainder?

How to perform an integer division, and separately get the remainder, in JavaScript?

For example,

    int result;
    
    result = 125/100;

or 

    result = 43/100;

Will result always be the floor of the division? What is the defined behavior?

What is the behavior of integer division?

I&#39;ve been reading about `div` and `mul` assembly operations, and I decided to see them in action by writing a simple program in C:

### File division.c

    #include &lt;stdlib.h&gt;
    #include &lt;stdio.h&gt;

    int main()
    {
        size_t i = 9;
        size_t j = i / 5;
        printf(&quot;%zu\n&quot;,j);
        return 0;
    }

And then generating assembly language code with:

    gcc -S division.c -O0 -masm=intel

But looking at generated `division.s` file, it doesn&#39;t contain any div operations! Instead, it does some kind of black magic with bit shifting and magic numbers. Here&#39;s a code snippet that computes `i/5`:

    mov     rax, QWORD PTR [rbp-16]   ; Move i (=9) to RAX
    movabs  rdx, -3689348814741910323 ; Move some magic number to RDX (?)
    mul     rdx                       ; Multiply 9 by magic number
    mov     rax, rdx                  ; Take only the upper 64 bits of the result
    shr     rax, 2                    ; Shift these bits 2 places to the right (?)
    mov     QWORD PTR [rbp-8], rax    ; Magically, RAX contains 9/5=1 now, 
                                      ; so we can assign it to j

What&#39;s going on here? Why doesn&#39;t GCC use div at all? How does it generate this magic number and why does everything work?


Why does GCC use multiplication by a strange number in implementing integer division?

How could I go about finding the division remainder of a number in Python?

For example:  
If the number is 26 and divided number is 7, then the division remainder is 5.  
(since 7+7+7=21 and 26-21=5.)

Find the division remainder of a number

Is there any function in Javascript that lets you do integer division, I mean getting division answer in int, not in floating point number.

    var x = 455/10;
    // Now x is 45.5
    // Expected x to be 45

But I want x to be 45. I am trying to eliminate last digit from the number.

How to do integer division in javascript (Getting division answer in int not float)?

I was writing this code:

    public static void main(String[] args) {
        double g = 1 / 3;
        System.out.printf(&quot;%.2f&quot;, g);
    }

The result is 0.  Why is this, and how do I solve this problem?


Int division: Why is the result of 1/3 == 0?

How come that in the following snippet

    int a = 7;
    int b = 3;
    double c = 0;
    c = a / b;

`c` ends up having the value 2, rather than 2.3333, as one would expect. If `a` and `b` are doubles, the answer does turn to 2.333. But surely because `c`  already is a double it should have worked with integers?

So how come `int/int=double` doesn&#39;t work?


Why does dividing two int not yield the right value when assigned to double?

I am trying to perform a simple division in Go.

    fmt.Println(3/10)

This prints 0 instead of 0.3. This is kind of weird. Could someone please share what is the reason behind this? i want to perform different arithmetic operations in Go.

Thanks

How to perform division in Go

I was curious to know how I can round a number to the nearest whole number. For instance, if I had:

    int a = 59 / 4;

which would be 14.75 if calculated in floating point; how can I store the result as 15 in &quot;a&quot;?



Rounding integer division (instead of truncating)

I know Python `//` rounds towards negative infinity and in C++ `/` is truncating, rounding towards 0.

And here&#39;s what I know so far:

```lang-none
               |remainder|
-12 / 10  = -1,   - 2      // C++
-12 // 10 = -2,   + 8      # Python

12 / -10  = -1,     2      // C++
12 // -10 = -2,   - 8      # Python

12 / 10  = 1,      2       // Both
12 // 10 = 1,      2

-12 / -10 = 1,    - 2      // Both
          = 2,    + 8

C++:
1. m%(-n) == m%n
2. -m%n == -(m%n)
3. (m/n)*n + m%n == m

Python:
1. m%(-n) == -8 == -(-m%n)
2. (m//n)*n + m%n == m
```

But why Python `//` choose to round towards negative infinity? I didn&#39;t find any resources explain that, but only find and hear people say vaguely: *&quot;for mathematics reasons&quot;*.

For example, in *https://stackoverflow.com/questions/22030342/why-is-1-2-evaluated-to-0-in-c-but-1-in-python*:

&gt; People dealing with these things in the abstract tend to feel that
&gt; rounding toward negative infinity makes more sense (**that means it&#39;s
&gt; compatible with the modulo function as defined in mathematics, rather
&gt; than % having a somewhat funny meaning**).

But I don&#39;t see C++ &#39;s `/` not being compatible with the modulo function. In C++, `(m/n)*n + m%n == m` also applies.

So what&#39;s the (mathematical) reason behind Python choosing rounding towards negative infinity?


----------

See also [Guido van Rossum&#39;s old blog post on the topic][1].

  [1]: http://python-history.blogspot.com/2010/08/why-pythons-integer-division-floors.html









What&#39;s the mathematical reason behind Python choosing to round integer division toward negative infinity?

&gt; **Possible Duplicate:**  
&gt; [Why can&amp;#39;t I return a double from two ints being divided](https://stackoverflow.com/questions/7571326/why-cant-i-return-a-double-from-two-ints-being-divided)  

&lt;!-- End of automatically inserted text --&gt;

My C++ program is truncating the output of my integer devision even when I try and place the output into a float. How can I prevent this whilst keeping those to variables (a &amp; b) as integers?

    user@box:~/c/precision$ cat precision.cpp
    #include &lt;iostream&gt;
    #include &lt;iomanip&gt;
    using namespace std;
    
    int main()
    {
      int a = 10, b = 3;
      float ans = (a/b);
      cout&lt;&lt;fixed&lt;&lt;setprecision(3);
      cout &lt;&lt; (a/b) &lt;&lt; endl;
      cout &lt;&lt; ans &lt;&lt; endl;
      return 0;
    }
    
    user@box:~/c/precision$ g++ -o precision precision.cpp 
    user@box:~/c/precision$ ./precision 
    3
    3.000


Dividing two integers to produce a float result

    int totalOptCount = 500;
    int totalRespCount=1500; 
    float percentage =(float)(totalOptCount/totalRespCount);

Why does this always return value 0.0? Also I want to format this into 00.00 format and convert into string?


Why does the division of two integers return 0.0 in Java?

What is a good way to **always** do integer division in Perl?

For example, I want:

    real / int = int
    
    int / real = int
    
    int / int = int

How should I do integer division in Perl?

I have recently noticed that [`int()`][1] rounds a float towards 0, while [integer division][2] rounds a float towards its floor.

for instance:
```
-7 // 2 == -4
int(-7/2) == -3
```

I have read the documentation which specifies:
&gt; class int(x, base=10)
&gt;
&gt;    Return an integer object constructed from a number or string x, or return 0 if no arguments are &gt;given. If x is a number, return `x.__int__()`. For floating point numbers, **this truncates towards zero.**

and:
&gt;floor division
&gt;
&gt;Mathematical division that rounds **down to nearest integer.** The floor division operator is `//`. For example, the expression `11 // 4` evaluates to 2 in contrast to the `2.75` returned by float true division. Note that `(-11) // 4` is `-3` because that is `-2.75` rounded downward. See [PEP 238][3].

But it seems illogical for me that 2 similar operations (float division to integer) should return different results.

Is there any motivation for the differences between the functions?


  [1]: https://docs.python.org/3/library/functions.html#int
  [2]: https://docs.python.org/3/glossary.html#term-floor-division
  [3]: https://www.python.org/dev/peps/pep-0238

What is the reason for difference between integer division and float to int conversion in python?

In my application I encountered the following and was surprised by the results:

`8/-7=-2` (both integers).

What does this mean?


All Integer Division Solutions on Gang of Coders

Total of 19 Integer Division Solutions