Float.toText only displays 6 fractional digits - we probably want a representation that would roundtrip as a literal.

[crusso]

see rts/float.c

[crusso]

Using specifier "%.16g" not "%f" yields better result, but I don't know if that's good enough.

rts/float.c

export as_ptr float_fmt(double a) {
  extern int snprintf(char *__restrict, size_t, const char *__restrict, ...);
  char buf[50]; // corresponds to 150 bits of pure floatness, room for 64 bits needed
  //  const int chars = snprintf(buf, sizeof buf, "%f", a);
  const int chars = snprintf(buf, sizeof buf, "%.17g", a);
  return text_of_ptr_size(buf, chars);
}

[crusso]

@rossberg any advice here?

[rossberg]

Yes, %.17g is enough to roundtrip, I've used that in the Wasm interpreter, and it works for all the many corner cases in the test suite that exercise bit-precise rounding behaviour (at least OCaml's implementation of the formatting, which I assume is inherited from C).

However, in practice, users may not want to see umteen zeroes all the time. We'll have to add some richer formatting functions; toText should probably default to %f.

There's also %h, of course.

[ggreif]

Something like toText(f : Float, prec : ?Nat8) would be easily realisable (in the compiler, for the interpreter probably hairier).

[rossberg]

@ggreif, I think it should be a separate function from toText, though. But then we'd probably want s.th like SML's realfmt type, maybe extended with a hex case for %h.

In the interpreter that ought to be trivial (using OCaml's Printf).

[ggreif]

@rossberg In OCaml we can't build the format string dynamically, can we?

val fmt : string = "%.9g"
# Printf.sprintf fmt 3.14159;;
Error: This expression has type string but an expression was expected of type
         ('a -> 'b, unit, string) format =
           ('a -> 'b, unit, string, string, string, string)
           CamlinternalFormatBasics.format6

[rossberg]

Following SML's basis library, here is what I propose: a function Float.toFormattedText : (Float, Format) -> Text, where the type Float.Format is defined as follows:

type Format = {
  #fix : Nat;  // like "%.*f"
  #exp : Nat;  // like "%.*e"
  #gen : Nat;  // like "%.*g"
  #hex : Nat;  // like "%.*h" a.k.a. "%.*a"
  #exact;  // like "%.17g"
}

(Making precision non-optional, since that doesn't buy you much in this form of description.)

[rossberg]

@ggreif, no, but a simple switch over the 4 or 5 formats is enough. The precision can be turned into a dynamic argument by using *.

[ggreif]

That's what I mean by "hairier".

[rossberg]

How is that "hairy"?

[ggreif]

It has more hair :-)

[ggreif]

But we'll still need some supporting primitives for this to fly, right? (I'll come up with a PR in dfinity/motoko soon.)

[rossberg]

Perhaps just extend float_fmt with a mode and a precision arg?

[crusso]

Great, thanks guys. I'll leave that in your hands then @ggreif.

[ggreif]

I totally misunderstood what "%.*f" means. I thought that the * is purely meta-notation. Another thing learned...

[rossberg]

Now I see why you considered it hairy. :)

[ggreif]

Now I see why you considered it hairy. :)

Precisely.

[ehoogerbeets]

Is there any way we can not have toFormattedText at all and make it very very clear in the documentation that a simple toText is not for displaying to users? Formatting floating point numbers for human consumption is a locale-dependent function, as there are many different ways that different cultures format numbers with varying thousands separators, digit groupings, decimal separators, rounding rules, etc. A separate number formatter class that takes a locale would be ideal and would keep floats and natural numbers clean and small.