In math we use the remainder for modular-arithmetic. That is given two numbers and we already saw that we can express as

where is in the range – and we call this the remainder of dividing by , so for negative numbers we have for example:

so .

But in F# we have:

**% (modulus, mod)**

**Returns the remainder of a division operation. The sign of the result is the same as the sign of the first operand**

So

> -14 % 5;;
val it : int = -4

So we have to change this if we want correct values for negative numbers.

There are a couple of options, ranging from checking the sign and using different formulas (cases) but the simples one is just using

let modulo n m = ((n % m) + m) % m

if .

> modulo -14 5;;
val it : int = 1

This should be sufficient for most problems but

let inline modulo n m =
let mod' = n % m
if sign mod' >= 0 then mod'
else abs m + mod'

might be more efficient if you deal with big integers (or some other kind of values where the %-operator is not easily computed).

Update:

After messing up a bit with the case, when I should make sure that all works as it should – here is the test validating the second version for those special occasions:

[<Test>]
member test.``modulo should respect the math way``() =
let testPairs =
[ for d in [-3..3] do
for r in [0..5] do
yield (d,r)
]
let testOnePair (d,r) =
let z = d*(-6)+r
let r' = modulo z (-6)
r |> should equal r'
testPairs |> List.iter testOnePair</pre>

### Like this:

Like Loading...