## Saturday, June 11, 2022

### Nicer arithmetic with Python

Beginning programmers are often surprised by floating point arithmetic inaccuracies. If they use Python, many will often write posts saying that Python is "broken" when the see results as follows:

```>>> 0.1 + 0.2
0.30000000000000004
```

This particular result is not limited to Python. In fact, it is so common that there exists a site with a name inspired by this example (0.30000000000000004.com/), devoted to explaining the origin of this puzzling result, followed by examples from many programming languages.

Python provides some alternatives to standard floating point operations. For example, one can use the decimal module to perform fixed point arithmetic operations. Here's an example.

```>>> from decimal import Decimal, getcontext
>>> getcontext().prec = 7
>>> Decimal(0.1) + Decimal(0.2)
Decimal('0.3000000')
>>> print(_)
0.3000000
```

While one can set the precision (number of decimals) with which operations are performed, printed values can carry extra zeros: 0.3000000 does not look as "nice" as 0.3.

Another alternative included with Python's standard library is the fractions module: it provides support for rational number arithmetic.

```>>> from fractions import Fraction
>>> Fraction("0.1") + Fraction("0.2")
Fraction(3, 10)
>>> print(_)
3/10
```

However, the fractions module can yield some surprising results if one does not use string arguments to represent floats, as was mentioned by Will McGugan (of Rich and Textual fame) in a recent tweet.

```>>> from fractions import Fraction as F
>>> F("0.1")
Fraction(1, 10)
>>> F(0.1)
Fraction(3602879701896397, 36028797018963968)
```

In the second case, 0.1 is a float which means that it carries some intrinsic inaccuracy. For the first case, some parsing is done by Python to determine the number of decimal places to use before converting the result into a rational number. A similar result can be achieved using the limit_denominator method of the Fraction class:

```>>> F(0.1).limit_denominator(10)
Fraction(1, 10)
```

In fact, we do not have to be as restrictive in the limitation imposed on the denominator to achieve the same result

```>>> F(0.1).limit_denominator(1_000_000_000)
Fraction(1, 10)
```

While we can achieve some "more intuitive" results for floating point arithmetic using special modules from Python, the notation that one has to use is not as simple as "0.1 + 0.2". As Raymond Hettinger often says: "There has to be a better way."

## Using ideas

As readers of this blog already know, I created a Python package named ideas to facilitate the creation of import hooks and to enable easy experimentation with modified Python syntax. ideas comes with its own console that support modified Python syntax. It can also be used with IPython (and thus with Jupyter notebooks).

Using ideas, one can "instruct" python to perform rational arithmetic.  For example, suppose I have a Python file containing the following:

```# simple_math.py

a = 0.2 + 0.1
b = 0.2 + 1/10
c = 2/10 + 1/10
print(a, b, c)```

I can run this with Python, getting the expected "unintuitive" result:

```> py simple_math.py
0.30000000000000004 0.30000000000000004 0.30000000000000004
```

Alternatively, using ideas, I can execute this file using rational arithmetic:

```> ideas simple_math -a rational_math
3/10 3/10 3/10
```

Using a different import hook, I can have the result shown with floating point notation.

```> ideas simple_math -a nicer_floats
0.3 0.3 0.3
```

Instead of executing a script, let's use the ideas console instead, starting with "nicer_float"

```ideas> 0.1 + 0.2
0.3

ideas> 1/10 + 2/10
0.3
```
For "nicer_float", I've also adopted the Pyret's notation: floating-point number immediately preceded by "~" are treated as "approximate" floating points i.e. with the regular inaccuracy.
```ideas> ~0.1 + 0.2
0.30000000000000004
```

And, as mentioned before, I can use ideas with IPython. Here's a very brief example

```IPython 8.0.0b1 -- An enhanced Interactive Python. Type '?' for help.

In [1]: from ideas.examples import rational_math