# Modulus on Negative Numbers in C

In this tutorial, we will explore some examples of modulus on negative number.

### What is Modulus of Negative number?

By omitting the minus sign, one can determine the modulus of a negative number. Adding vertical lines all around a number indicates the modulus of that number. Also keep in mind that multiplying a negative number by one will produce its modulus, like in the case of the expression (-9) = 9.

### Modulus means:

The remainder of a division is represented by the modulo, or simply "mod." Gauss wrote a treatise on modular arithmetic that was released in 1801. Later, Donald Knuth provided a mathematical definition that is now universally recognised.

The result of a division is returned by the modulo operator. But when negative numbers are added, things become a little bit more complicated.

Let’s look at some examples on modulus of negative numbers. And see the output of the programs.

**Example 1:**

**C Program**

```
#include <stdio.h>
// Main function
int main ()
{
// Declaring and initializing the variables
int x = 7, y = - 11, z = 2;
// Calculating and printing
printf ( "%d", x % y / z );
}
```

**C++ Program**

```
#include <iostream>
using namespace std;
// Main function
int main ()
{
// Declaring and initializing the variables
int x = 7, y = - 11, z = 2;
// Calculating and printing
cout << x % y / z ;
}
```

**Output:**

3

The precedence for % and / is the same. % and / present left-to-right associativity. Therefore, percent is carried out initially. The significance is that, in the case of the modulus operator, a sign of a left operand is attached to the result.

**Example 2:**

**C Program**

```
#include <stdio.h>
// Main function
int main ()
{
// Declaring and initializing the variables
// x is positive and y is negative.
int x = 4, y = -9 ;
// Calculating and printing
printf ("%d" , x % y ) ;
}
```

**C++ Program**

```
#include <iostream>
using namespace std;
// Main function
int main ()
{
// Declaring and initializing the variables
// x is positive and y is negative.
int x = 4, y = -9 ;
// Calculating and printing
cout << x % y ;
}
```

**Output:**

4

**Example 3:**

**C Program**

```
#include <stdio.h>
// Main function
int main ()
{
// Declaring and initializing the variables
// x is negative and y is positive.
int x = -4, y = 9 ;
// Calculating and printing
printf ("%d" , x % y ) ;
}
```

**C++ Program**

```
#include <iostream>
using namespace std;
// Main function
int main ()
{
// Declaring and initializing the variables
// x is negative and y is positive.
int x = -4, y = 9 ;
// Calculating and printing
cout << x % y ;
}
```

**Output:**

-4

However, according to the meaning of the term, the remainder is always an integer that should be subtracted from x to make it divisible by y.

Therefore, since -4 is negative, it is not the genuine remainder in the case above.

To avoid negative remainder, we must always find the remainder in the C/C++ language as (x % y + y) % y (add quotient to remainder and again take remainder).

**Example 4:**

**C Program**

```
#include <stdio.h>
// Main function
int main ()
{
// Declaring and initializing the variables
// x is negative and y is negative.
int x = -4, y = -9 ;
// Calculating and printing
printf ("%d" , x % y ) ;
}
```

**C++ Program**

```
#include <iostream>
using namespace std;
// Main function
int main ()
{
// Declaring and initializing the variables
// x is negative and y is negative.
int x = -4, y = -9 ;
// Calculating and printing
cout << x % y ;
}
```

**Output:**

-4

When both operands are positive, all can guess what a modulus operator would generate. But different languages provide different results when it comes to negative numbers.

The modulus in C is calculated as,

```
x % n = x – ( n * trunc( x / n ) ).
For example,
9 % -4 = 9 – ( -4 * trunc ( 9 / -4 ) )
= 9 – ( -4 * trunc ( -2.25 ) )
= 9 – ( -4 * -2 ) { rounded off }
= 9 – 6
= 3
```

**Chart:**

Numerator | Denominator | ||

X | Y | X / Y | X % Y |

+ | + | + | + |

+ | - | - | + |

- | + | - | - |

- | - | + | - |

We can learn from the above chart that the % operator always takes a numerator's sign into account.