When you work with *unsigned* types, ** modular arithmetic** (also known as

*"wrap around"*behavior) is taking place. To understand this

*modular arithmetic*, just have a look at these clocks:

**9 + 4 = 1** ( *13 mod 12* ), so to the other direction it is: **1 - 4 = 9** ( *-3 mod 12* ). The same principle is applied while working with unsigned types. If the **result type** is `unsigned`

, then modular arithmetic takes place.

Now look at the following operations storing the result as an `unsigned int`

:

```
unsigned int five = 5, seven = 7;
unsigned int a = five - seven; // a = (-2 % 2^32) = 4294967294
int one = 1, six = 6;
unsigned int b = one - six; // b = (-5 % 2^32) = 4294967291
```

When you want to make sure that the result is `signed`

, then stored it into `signed`

variable or cast it to `signed`

. When you want to get the difference between numbers and make sure that the modular arithmetic will not be applied, then you should consider using `abs()`

function defined in `stdlib.h`

:

```
int c = five - seven; // c = -2
int d = abs(five - seven); // d = 2
```

Be very careful, especially while writing conditions, because:

```
if (abs(five - seven) < seven) // = if (2 < 7)
// ...
if (five - seven < -1) // = if (-2 < -1)
// ...
if (one - six < 1) // = if (-5 < 1)
// ...
if ((int)(five - seven) < 1) // = if (-2 < 1)
// ...
```

**but**

```
if (five - seven < 1) // = if ((unsigned int)-2 < 1) = if (4294967294 < 1)
// ...
if (one - six < five) // = if ((unsigned int)-5 < 5) = if (4294967291 < 5)
// ...
```