I have seen this question asked a lot but never seen a true concrete answer to it. So I am going to post one here which will hopefully help people understand why exactly there is &quot;modulo bias&quot; when using a random number generator, like `rand()` in C++.

Why do people say there is modulo bias when using a random number generator?

Apparently, x86 (and probably a lot of other instruction sets) put both the quotient and the remainder of a divide operation in separate registers.

Now, we can probably trust compilers to optimize a code such as this to use only one call to divide:

    ( x / 6 )
    ( x % 6 )

And they probably do. Still, do any **languages** (or libraries, but mainly looking for languages) support giving both the divide and modulo results at the same time? If so, what are they, and What does the syntax look like?

Divide and Get Remainder at the same time?

I have a 128-bit unsigned integer A and a 64-bit unsigned integer B. What&#39;s the fastest way to calculate `A % B` - that is the (64-bit) remainder from dividing A by B?

I&#39;m looking to do this in either C or assembly language, but I need to target the 32-bit x86 platform. This unfortunately means that I cannot take advantage of compiler support for 128-bit integers, nor of the x64 architecture&#39;s ability to perform the required operation in a single instruction.

**Edit:**

Thank you for the answers so far. However, it appears to me that the suggested algorithms would be quite slow - wouldn&#39;t the fastest way to perform a 128-bit by 64-bit division be to leverage the processor&#39;s native support for 64-bit by 32-bit division? Does anyone know if there is a way to perform the larger division in terms of a few smaller divisions?

**Re: How often does B change?**

Primarily I&#39;m interested in a general solution - what calculation would you perform if A and B are likely to be different every time?

However, a second possible situation is that B does not vary as often as A - there may be as many as 200 As to divide by each B. How would your answer differ in this case?

Fastest way to calculate a 128-bit integer modulo a 64-bit integer

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


Assembly Language - How to do Modulo?

What does modulo in the following piece of code do?

    from math import *
    3.14 % 2 * pi

How do we calculate modulo on a floating point number?



Modulo operator in Python

I&#39;m creating an RPN calculator for a school project and having trouble with the modulus operator. Since we&#39;re using the double data type, modulus won&#39;t work on floating-point numbers. For example, 0.5 % 0.3 should return 0.2, but I&#39;m getting a division by zero exception.

The instruction says to use `fmod()`. I&#39;ve looked everywhere for `fmod()`, including javadoc, but I can&#39;t find it. I&#39;m starting to think it&#39;s a method I&#39;m going to have to create?

Edit: Hmmm, strange. I just plugged in those numbers again and it seems to be working fine… but just in case. Do I need to watch out for using the mod operator in Java when using floating types? I know something like this can&#39;t be done in C++ (I think).

How do I use modulus for float/double?

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?

What does the `%` in a calculation? I can&#39;t seem to work out what it does.

Does it work out a percent of the calculation for example: `4 % 2` is apparently equal to 0. How?


What is the result of % in Python?

In a C program I was trying the below operations (Just to check the behavior)

     x = 5 % (-3);
     y = (-5) % (3);
     z = (-5) % (-3); 
    
    printf(&quot;%d ,%d ,%d&quot;, x, y, z); 

It gave me output as `(2, -2 , -2)` in gcc. I was expecting a positive result every time. Can a modulus be negative? Can anybody explain this behavior?

Modulo operation with negative numbers

As an example in pseudocode:

    if ((a mod 2) == 0)
    {
        isEven = true;
    }
    else
    {
        isEven = false;
    }


What&#39;s the syntax for mod in java

I&#39;m trying to mod an integer to get an array position so that it will loop round. Doing `i % 
arrayLength` works fine for positive numbers but for negative numbers it all goes wrong.

     4 % 3 == 1
     3 % 3 == 0
     2 % 3 == 2
     1 % 3 == 1
     0 % 3 == 0
    -1 % 3 == -1
    -2 % 3 == -2
    -3 % 3 == 0
    -4 % 3 == -1


so i need an implementation of

    int GetArrayIndex(int i, int arrayLength)

such that

    GetArrayIndex( 4, 3) == 1
    GetArrayIndex( 3, 3) == 0
    GetArrayIndex( 2, 3) == 2
    GetArrayIndex( 1, 3) == 1
    GetArrayIndex( 0, 3) == 0
    GetArrayIndex(-1, 3) == 2
    GetArrayIndex(-2, 3) == 1
    GetArrayIndex(-3, 3) == 0
    GetArrayIndex(-4, 3) == 2

I&#39;ve done this before but for some reason it&#39;s melting my brain today :( 


  [1]: http://stackoverflow.com/questions/989943/weird-objective-c-mod-behavior

Mod of negative number is melting my brain

I have a program in C++ (compiled using g++). I&#39;m trying to apply two doubles as operands to the modulus function, but I get the following error:

&gt; error: invalid operands of types &#39;double&#39; and &#39;double&#39; to binary &#39;operator%&#39;

Here&#39;s the code:

    int main() {
        double x = 6.3;
        double y = 2;
        double z = x % y;
    }

Can&#39;t use modulus on doubles?

I&#39;m trying a line like this:

    for i in {1..600}; do wget http://example.com/search/link $i % 5; done;

What I&#39;m trying to get as output is:

    wget http://example.com/search/link0
    wget http://example.com/search/link1
    wget http://example.com/search/link2
    wget http://example.com/search/link3
    wget http://example.com/search/link4
    wget http://example.com/search/link0

But what I&#39;m actually getting is just:

        wget http://example.com/search/link

How to use mod operator in bash?

I have numbers like 1100, 1002, 1022 etc. I would like to have the individual digits, for example for the first number 1100 I want to have 1, 1, 0, 0.

How can I get it in Java?

How to get the separate digits of an int number?

I need to test whether each number from 1 to 1000 is a multiple of 3 or a multiple of 5. The way I thought I&#39;d do this would be to divide the number by 3, and if the result is an integer then it would be a multiple of 3. Same with 5. 

How do I test whether the number is an integer?

Here is my current code:

    n = 0
    s = 0
    
    while (n &lt; 1001):
        x = n/3
        if isinstance(x, (int, long)):
            print &#39;Multiple of 3!&#39;
            s = s + n
        if False:
            y = n/5
            if isinstance(y, (int, long)):
                s = s + n
    
        print &#39;Number: &#39;
        print n
        print &#39;Sum:&#39;
        print s
        n = n + 1

How do you check whether a number is divisible by another number?

I&#39;m embarrassed to ask such a simple question. My term does not start for two more weeks so I can&#39;t ask a professor, and the suspense would kill me.

Why does 2 mod 4 = 2?


Why does 2 mod 4 = 2?

How do I figure out if a variable is divisible by 2? Furthermore I need do a function if it is and do a different function if it is not.

Find if variable is divisible by 2

I&#39;ve found some strange behaviour in Python regarding negative numbers:

    &gt;&gt;&gt; -5 % 4
    3

Could anyone explain what&#39;s going on?


The modulo operation on negative numbers in Python

In java when you do

    a % b

If a is negative, it will return a negative result, instead of wrapping around to b like it should. What&#39;s the best way to fix this? Only way I can think is

    a &lt; 0 ? b + a : a % b

Best way to make Java&#39;s modulus behave like it should with negative numbers?

I have a table `software` and columns in it as `dev_cost`, `sell_cost`. If `dev_cost` is 16000 and `sell_cost` is 7500.

How do I find the quantity of software to be sold in order to recover the `dev_cost`? 

I have queried as below:

    select dev_cost / sell_cost from software ;

It is returning 2 as the answer. But we need to get 3, right?

What would be the query for that? Thanks in advance.

Division ( / ) not giving my answer in postgresql

I don&#39;t really understand how modulus division works.
I was calculating `27 % 16` and wound up with `11` and I don&#39;t understand why.

I can&#39;t seem to find an explanation in layman&#39;s terms online.
Can someone elaborate on a very high level as to what&#39;s going on here?

How Does Modulus Divison Work

I&#39;m looking for an explanation of how a hash table works - in plain English for a simpleton like me! 

For example, I know it takes the key, calculates the hash (I am looking for an explanation how) and then performs some kind of modulo to work out where it lies in the array where the value is stored, but that&#39;s where my knowledge stops.

Could anyone clarify the process?

**Edit:** I&#39;m not asking specifically about how hash codes are calculated, but a general overview of how a hash table works.

How does a hash table work?

Am I doing modulus wrong? Because in Java `-13 % 64` evaluates to `-13` but I want to get `51`.


How does java do modulus calculations with negative numbers?

How can I calculate division and modulo for integer numbers in C#?


How can I calculate divide and modulo for integers in C#?

In Rust (like most programming languages), the `%` operator performs the *remainder* operation, not the *modulus* operation. These [operations have different results for negative numbers](https://stackoverflow.com/q/13683563/155423):

&lt;!-- language: none --&gt;

    -21 modulus 4 =&gt; 3
    -21 remainder 4 =&gt; -1

&lt;!-- --&gt;

    println!(&quot;{}&quot;, -21 % 4); // -1

However, I **want** the modulus.

I found a workaround `((a % b) + b) % b`, but I don&#39;t want to reinvent the wheel if there&#39;s already a function for that!

Is there a modulus (not remainder) function / operation?

One of my pet hates of C-derived languages (as a mathematician)  is that

    (-1) % 8 // comes out as -1, and not 7
    
    fmodf(-1,8) // fails similarly

What&#39;s the best solution?  

C++ allows the possibility of templates and operator overloading, but both of these are murky waters for me. examples gratefully received.

How to code a modulo (%) operator in C/C++/Obj-C that handles negative numbers

I am encrypting the user&#39;s input for generating a string for password. But a line of code gives different results in different versions of the framework. Partial code with value of key pressed by user:

Key pressed: 1. Variable `ascii` is 49. Value of &#39;e&#39; and &#39;n&#39; after some calculation:

    e = 103, 
    n = 143,

    Math.Pow(ascii, e) % n

Result of above code:

- In .NET 3.5 (C#)

        Math.Pow(ascii, e) % n

 gives `9.0`.

- In .NET 4 (C#)

        Math.Pow(ascii, e) % n

 gives `77.0`.

`Math.Pow()` gives the correct (same) result in both versions.

What is the cause, and is there a solution?


The modulo operator (%) gives a different result for different .NET versions in C#

I have two CGFloat values, and want to calculate the modulo result. Or in other words: I want to know what&#39;s left if valueA is placed as much as possible into valueB.

So I just tried:

    CGFloat moduloResult = valueB % valueA;

the compiler complains about the % and tells me: &quot;invalid operands to binary %&quot;. Any idea?

How to make a modulo operation in objective-c / cocoa touch?

How to calculate modulus of 5^55 modulus 221 without much use of calculator?

I guess there are some simple principles in number theory in cryptography to calculate such things.

How to calculate modulus of large numbers?

In the tutorial there is an example for finding prime numbers:

    &gt;&gt;&gt; for n in range(2, 10):
    ...     for x in range(2, n):
    ...         if n % x == 0:
    ...             print(n, &#39;equals&#39;, x, &#39;*&#39;, n//x)
    ...             break
    ...     else:
    ...         # loop fell through without finding a factor
    ...         print(n, &#39;is a prime number&#39;)
    ...

I understand that the double `==` is a test for equality, but I don&#39;t understand the `if n % x` part. Like I can verbally walk through each part and say what the statement does for the example. But I don&#39;t understand how the percentage sign falls in. 

What does `if n % x` actually say?

What does the percentage sign mean in Python

I have found that the same mod operation produces different results depending on what language is being used.

In Python:

    -1 % 10

produces **9**

In C it produces **-1** !

1. Which one is the right modulo? &lt;br&gt;
2. How to make mod operation in C to be the same like in Python?

C and Python - different behaviour of the modulo (%) operation

**Math**:

If you have an equation like this:

    x = 3 mod 7

x could be ... -4, 3, 10, 17, ..., or more generally:

    x = 3 + k * 7

where k can be any integer. I don&#39;t know of a modulo operation is defined for math, but the  factor ring certainly is.

**Python**:

In Python, you will always get non-negative values when you use `%` with a positive `m`:

    #!/usr/bin/python
    # -*- coding: utf-8 -*-

    m = 7

    for i in xrange(-8, 10 + 1):
        print(i % 7)

Results in:

    6    0    1    2    3    4    5    6    0    1    2    3    4    5    6    0    1    2    3

**C++:**

    #include &lt;iostream&gt;

    using namespace std;

    int main(){
        int m = 7;

        for(int i=-8; i &lt;= 10; i++) {
            cout &lt;&lt; (i % m) &lt;&lt; endl;
        }

        return 0;
    }

Will output:

    -1    0    -6    -5    -4    -3    -2    -1    0    1    2    3    4    5    6    0    1    2    3    

**ISO/IEC 14882:2003(E) - 5.6 Multiplicative operators:**
&gt; The binary / operator yields the quotient, and the binary % operator
&gt; yields the remainder from the division of the first expression by the
&gt; second. If the second operand of / or % is zero the behavior is
&gt; undefined; otherwise (a/b)*b + a%b is equal to a. If both operands are
&gt; nonnegative then the remainder is nonnegative; if not, **the sign of the
&gt; remainder is implementation-defined 74)**.

and

&gt; 74) According to work underway toward the revision of ISO C, the
&gt; preferred algorithm for integer division follows the rules defined in
&gt; the ISO Fortran standard, ISO/IEC 1539:1991, in which the quotient is
&gt; always rounded toward zero.

Source: [ISO/IEC 14882:2003(E)][1] 

(I couldn&#39;t find a free version of `ISO/IEC 1539:1991`. Does anybody know where to get it from?)

The operation seems to be defined like this:

![enter image description here][2]

**Question**: 

Does it make sense to define it like that? 

What are arguments for this specification? Is there a place where the people who create such standards discuss about it? Where I can read something about the reasons why they decided to make it this way?

Most of the time when I use modulo, I want to access elements of a datastructure. In this case, I have to make sure that mod returns a non-negative value. So, for this case, it would be good of mod always returned a non-negative value. 
(Another usage is the [Euclidean algorithm][3]. As you could make both numbers positive before using this algorithm, the sign of modulo would matter.)

**Additional material**: 

See [Wikipedia][4] for a long list of what modulo does in different languages.


  [1]: http://cs.nyu.edu/courses/summer12/CSCI-GA.2110-001/downloads/C++%20Standard%202003.pdf
  [2]: http://i.stack.imgur.com/8p2MN.png
  [3]: http://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
  [4]: http://en.wikipedia.org/wiki/Modulo_operation#Remainder_calculation_for_the_modulo_operation

Why does C++ output negative numbers when using modulo?

I&#39;m messing with the modulo operation in python and I understand that it will spit back what the remainder is.

But what if the first number is smaller than the second?

for instance

2 % 5  the answer is 2.

How does that work?

2/5 = .4





How does a modulo operation work when the first number is smaller?

I know the [modulus][1] (%) operator calculates the remainder of a division. How can I identify a situation where I would need to use the modulus operator?

I know I can use the modulus operator to see whether a number is even or odd and prime or composite, but that&#39;s about it. I don&#39;t often think in terms of remainders. I&#39;m sure the modulus operator is useful, and I would like to learn to take advantage of it. 

I just have problems identifying where the modulus operator is applicable. In various programming situations, it is difficult for me to see a problem and realize &quot;Hey! The remainder of division would work here!&quot;.

  [1]: http://en.wikipedia.org/wiki/Modulo_operation


Recognizing when to use the modulus operator

Why is `X % 0` an invalid expression?

I always thought `X % 0` should equal X. Since you can&#39;t divide by zero, shouldn&#39;t the answer naturally be the remainder, X (everything left over)?

Can&#39;t Mod Zero?

I assume that calculating the modulus of a number is a somewhat expensive operation, at least compared to simple arithmetic tests (such as seeing if a number exceeds the length of an array). If this is indeed the case, is it more efficient to replace, for example, the following code:

    res = array[(i + 1) % len];

with the following? :

    res = array[(i + 1 == len) ? 0 : i + 1];

The first one is easier on the eyes, but I wonder if the second might be more efficient. If so, might I expect an optimizing compiler to replace the first snippet with the second when a compiled language is used?

Of course, this &quot;optimization&quot; (if it is indeed an optimization) doesn&#39;t work in all cases (in this case, it only works if `i+1` is never more than `len`).

Is it better to avoid using the mod operator when possible?

According to [Google Calculator][1] `(-13) % 64` is `51`.

According to Javascript (see this [JSBin](http://jsbin.com/uzake5/2/edit)) it is `-13`.

How do I fix this?


  [1]: http://www.google.com/search?q=-13+%25+64

All Modulo Solutions on Gang of Coders

Total of 37 Modulo Solutions