I noticed that I am currently facinated by decimals. So

not to polute the other thread, here a collection what came

to my mind so far, and what I could find:

In Java they mainly bundle the Java class BigDecimal because

of their java.sql JDBC adapter. The class delivers CR_XXX

functionality, you have a couple of rounding modes available,

and can do arithmetic just like crlibm. Whats not provided

is trigonometry etc… i.e. functions above the basic operations.

It has also a flexible mode for some basic operations, where no

precision needs to be specified, and where precision can grow,

like for example these two rules, I have sketeched them a little

simplfied, since for addition the place of the period is also important:

```
precision(a+b) = max(precision(a), precision(b))
precision(a*b) = precision(a)+precision(b)
```

Having binary p=52 not fixed requires possibly a slightly **different
mindset**. What should the architectual decision be? Some new

flag for the precision? What if a database row has columns from

a diversity of precisions? Anyway its amazing, that the most demand

for flexible precision comes from the commercial domain, and not

from some computation in physics, chemistry, etc…

**Edit 22.10.2022**

BTW: Here you see an alternative to rational/1. It is based

on the observation that 1/2^n has a finite decimal expansion.

You can check yourself, it grows more and more but you can

prove that it terminates for each n:

```
?- between(1,5,N), X is 1/2^N, write(N), write(': '),
write(X), nl, fail; true.
1: 0.5
2: 0.25
3: 0.125
4: 0.0625
5: 0.03125
true.
```

So you can use this to convert a binary floating point value into

a decimal, and this conversion is exact, just like the rational

conversion. Here you see two binary floating point values near

to each other, exactly decimal expanded to their maximum

needed digits to identify them in a decimal system, after

this expansion, digits going farther than what is shown,

only zeros in the digits:

```
/* Binary Floating Point Value from f64 */
?- X is decimal(1.4262129449486016).
X = 0d1.42621294494860162416216553538106381893157958984375.
?- X is decimal(1.4262129449486018).
X = 0d1.4262129449486018462067704604123719036579132080078125.
```

Problem is you cannot convert rational numbers like this,

there is no way rational to radix=10 always. But you have a bridge

between radix=2 → radix=10. But also the other way doesn’t

work exact radix=10 → radix=2, since 1/5 is not exact in

radix=2 with finite amount of binary digits. So rational numbers

are a quite amazing middle ground. If some floating point

values F2 have radix=2 and some floating point values F10 have

radix=10, then we have both F2 ⊆ Q and F10 ⊆ Q, where Q

are the rational numbers. But the reverse direction doesn’t work,

we have neither Q ⊆ F2 nor Q ⊆ F10, even if we look at arbitrary

but finite precision. And the only bridge is, we have F2 ⊆ F10 if

we look at arbitrary but finite precision, but not F10 ⊆ F2.