# OCaml mod function returns different result compared with %

20,400

## Solution 1

Python is a bit different in its usage of the `%` operator, which really computes the modulo of two values, whereas other programming languages compute the remainder with the same operator. For example, the distinction is clear in Scheme:

``````(modulo -1 4)    ; modulo
=> 3
(remainder -1 4) ; remainder
=> -1
``````

In Python:

``````-1 % 4           # modulo
=> 3
math.fmod(-1, 4) # remainder
=> -1
``````

But in OCaml, there's only `mod` (which computes the integer remainder), according to this table and as stated in the documentation:

``````-1 mod 4 (* remainder *)
=> -1
``````

Of course, you can implement your own `modulo` operation in terms of `remainder`, like this:

``````let modulo x y =
let result = x mod y in
if result >= 0 then result
else result + y
``````

## Solution 2

The semantics of modulo are linked with the semantics of integer division (generally, if `Q` is the result of integer division `a / b`, and `R` is the result of `a mod b`, then `a = Q * b + R` must always be true), so different methods of rounding the result of integer division to an integer will produce different results for modulo.

The Wikipedia article Modulo operation has a very extensive table about how different languages handle modulo. There are a few common ways:

• In languages like C, Java, OCaml, and many others, integer division rounds towards 0, which causes the result of modulo to always have the same sign as the dividend. In this case, the dividend (-1) is negative, so the modulo is also negative (-1).

• In languages like Python, Ruby, and many others, integer division always rounds down (towards negative infinity), which causes the result of modulo to always have the same sign as the divisor. In this case, the divisor (4) is positive, so the modulo is also positive (3).

Share:
20,400 Author by

### ytobi

I am a practised Software Engineer and Application Developer with experience in developing AI technologies. I have experience with state-of-the-art machine learning models developing computer vision applications, natural language processing as well as reinforcement learning. My strongest skills lie within C++ and Python. I have experience developing critical software systems in C++. I have a sincere drive toward AI, having completed a couple of advance certifications in deep learning and deep reinforcement learning nanodegree and applying these in industry. I love automating routine tasks with a touch of AI.

Updated on October 16, 2020

• ytobi almost 2 years

The modulo function in OCaml `mod` return results different when compared with the modulo operator in python.

OCaml:

``````# -1 mod 4
- : int = -1
``````

Python:

``````>>> -1 % 4
3
``````

Why are the result different?.

Is there any standard module function that operate as `%` in OCaml?.