Proposal: decimal floating-point types

[SaintCharlesCode]

What are your thoughts on Zig having decimal floating-point types built into the language? http://speleotrove.com/decimal/
They could have types df32 df64 df128 or something like that.

[JesseRMeyer]

There's also the general possibility of user-space defined Fixed Point storage.

[shawnl]

you should probably bring this up with llvm. This is a bunch of work (it needs a full soft float library) and that work would probably belong in llvm.

[SaintCharlesCode]

That's true. Also clang does not have "(_Decimal32 and friends)" according to the manual https://clang.llvm.org/docs/UsersManual.html It is probably too much of a niche feature.

[DanB91]

Came across this article and adding this in could maybe help in places where COBOL is used: https://medium.com/the-technical-archaeologist/is-cobol-holding-you-hostage-with-math-5498c0eb428b

[matu3ba]

This is identical to the more poorly named #1974.
Look especially at this nice comment, which elaborates quite alot: #1974 (comment)

Though I disagree that a separate type should be reserved for it, since the type consists of a tuple (and it could be also done in libstd). There may be eventually some news on this, since another project lowers a functional language to zig and uses something in zig for that.

[ghost]

At the moment, #1974 is only about binary fixed-point numbers, so it wouldn't help with this issue.

[matu3ba]

At the moment, #1974 is only about binary fixed-point numbers, so it wouldn't help with this issue.

They are very closely related: https://www.tutorialspoint.com/fixed-point-and-floating-point-number-representations,
so I dont see a special reason to separate them.
Since we have comptime, they could probably even be done together.

If you want to be fancy you could also use binary-coded decimals, thought thats less efficient (but might be useful for transformation etc).

Its quite a pity that wikipedia does not properly explain it.

[ghost]

@matu3ba,
Fixed vs floating point and binary vs decimal are orthogonal problems, as I understand them. The former trades range for uniformity of representable numbers (and sometimes also performance). The latter determines which fractional numbers are representable exactly and which aren't. E.g., 0.1 is not representable as a binary fraction, regardless of whether it is fixed or floating. Although the rounding errors are usually small, they sometimes do matter in financial and accounting software. And they can compound quickly, with the classic example being:

var x = 0.01; // type omitted
var i: i32 = 0;
while (i < 12) : (i += 1) {
    x = 1.0 - 99 * x;
}

At the end of the 12 iterations, x would have the value 0.01 if it is represented as a decimal fraction. But with a binary fraction, each step eats about 6 bits of precision. If x: f64, then the result is -79522. This is the kind of thing people are usually trying to prevent when calling for decimal number support.

To be clear, I'm highly skeptical of introducing native decimal fraction support in Zig. I'm just saying that if we do, then #1974 is not sufficient, unless it is extended to specify the base as well.

[haberman]

It looks like decimal floating point is an optional feature in C23: https://www.iso.org/standard/68882.html

GCC seems to have some amount of support for it: https://gcc.gnu.org/onlinedocs/gcc/Decimal-Float.html

Example usage: https://godbolt.org/z/d6EzqcrE6

There is talk of implementing this in Clang, but nothing tangible yet AFAICS: https://discourse.llvm.org/t/rfc-decimal-floating-point-support-iso-iec-ts-18661-2-and-c23/62152/1