For many computer programs it is necessary to round numbers. For example an invoice amount should only have two decimal places and a tool for time management often does not have to be accurate to the millisecond. Fortunately you don‘t have to write a method for that yourself. In Java or JavaScript you can use *Math.round*, Python has a built-in function for rounding and the Kotlin Standard Library also contains a method for this purpose. Anyway some of these functions have a few surprises in store and violate the *principle of least astonishment*. The *principle of least astonishment* was first formulated by Geoffrey James in his book *The Tao of Programming*. It states that a program should always behave in the way the user expects it to, but it can also be applied to source code. Thus a method or a class should have a name that describes its behavior in a proper way.

So, what would you expect a method with the name *round* to do? The most common way to round numbers is the so called **round half up **method. It means that half-way values are always rounded up. For example 4.5 gets rounded to 5 and 3.5 gets rounded to 4. Negative numbers get rounded in the same way, for example -4.5 gets rounded to -4. In fact the *Math.round* functions in Java and JavaScript use this kind of rounding and thus behave in a way most people would expect.

But in other programming languages this can be different. Actually I used the Python built-in rounding function for some time without recognizing it does not always round half-way values up. For example round(3.5) results in 4 as you would expect, but round(4.5) also returns 4. That‘s because Python uses the so called **round half to even** method for rounding values. This means that half-way values are always rounded to the nearest even number. The advantage in this kind of rounding is that if you add mulitple rounded values the error gets minimized, so it can be beneficial for statistical calculations. If you still want to round half-way values up in Python, you can implement your own rounding function:

```
def round_half_up(number, decimals: int):
rounded_value = int(number * (10**decimals) + 0.5) / (10**decimals)
if rounded_value % 1 == 0:
rounded_value = int(rounded_value)
return rounded_value
round_half_up(4.5, decimals=0) # results in 5
```

A different way in Python to round half-way values up is to use the *decimal* module, which contains different rounding modes:

```
from decimal import *
Decimal("4.5").quantize(Decimal("1"), rounding=ROUND_HALF_UP) # results in 5
```

It should be noted that the *ROUND_HALF_UP* mode in this module does actually not use the round half up method as explained above, but the also very common **round half away from zero **method. So for positive numbers the results are the same, but -4.5 does not get rounded to -4, but -5.

Python is by the way not the only programming language that uses the round half to even method. For example Kotlin and R round half-way values to the nearest even number, too. However for Kotlin there are several easy ways to round half-way values up: you could use the methods *roundToInt* or *roundToLong* from the standard library or the *Math.round* method from Java instead of the method *round*.

It should also be noted that the explained methods for rounding are not the only ones. Instead of rounding half-way values up you could also use the **round half down** method, so rounding 3.5 would result in 3. And instead of rounding half to even you could use the **round half to odd** method and 4.5 would get rounded to 5, as would 5.5. There are some more methods and everyone of them has its use case, so you should always choose carefully.

To sum it up, rounding is not as easy as it seems. Although most programming languages have a method for rounding in their standard library you should always take a closer look and check if the rounding function you want to use behaves in the way you expect and want it to.

Sometimes you will be surprised.