Joseph Ferano
b5e7351c7e
f64->bytes is snprintf "%g": six significant digits, exponent notation of its own accord, and no precision to pass it. A frame time of 1/60 comes back as 0.0166667 and a score past a million as 1.23457e+06. format-f64 returns a Vec instead, so it inherits neither that nor the shared static scratch buffer -- and it is the reason append-i64! exists, because it renders the integer part and the fraction through that one buffer in strict sequence. Half away from zero at the last digit kept, which is round-f32's rule and not printf's. 0.125 at two places is 0.13 here and 0.12 there; matching printf would mean pinning a particular libc's nearest-even on the binary value, and that answer is not the same on every target anyway. The three cases that ship broken are each one line and each tested: the carry, where the rounded fraction equals the scale and is the next integer (0.999995 at five places prints "0.100000" without it); the zero padding, without which 1.005 at three places prints "1.5"; and the sign, which belongs to the number rather than to its integer part, since -0.5 has an integer part of 0 and 0 carries no sign. The clamp on the precision is spelled (min 9 (max 0 prec)) and not with the clamp macro, and the reason is a finding: the prelude is never macro-expanded. macro.ml's pass runs over the file being compiled, and the prelude arrives at the checker through Check.program's own prepend, so a prelude function calling a prelude macro resolves the macro's underlying defn -- the one that takes a [Form] -- and reports an arity error.
87 lines
3.8 KiB
Plaintext
87 lines
3.8 KiB
Plaintext
;;;; format-f64: a number rendered to a fixed number of decimal places.
|
|
;;;;
|
|
;;;; The runtime's f64->bytes is snprintf "%g" and there is no precision to
|
|
;;;; pass it, so this is the first number formatter in the language that a
|
|
;;;; caller can steer. Every case below is one a plausible wrong version gets
|
|
;;;; wrong, and three of them are the ones that actually ship broken: the
|
|
;;;; carry, where the rounded fraction equals the scale and is not a fraction
|
|
;;;; at all; the zero padding, without which 1.005 prints as "1.5"; and the
|
|
;;;; sign, which belongs to the number and not to its integer part, because
|
|
;;;; -0.5 has an integer part of 0 and 0 carries no sign.
|
|
|
|
(defn show [x f64 p i32]
|
|
(let [v (format-f64 x p)]
|
|
(println (string (as-slice v)))
|
|
(free v)))
|
|
|
|
(defn main [] i32
|
|
;; The ordinary cases, and the one %g cannot do at all: 1/60 wanted to two
|
|
;; places is a frame time, and "%g" answers 0.0166667.
|
|
(show 3.14159 2) ; 3.14
|
|
(show 0.0166667 2) ; 0.02
|
|
(show 1234.5 1) ; 1234.5
|
|
(show 2.0 0) ; 2
|
|
(show 2.0 3) ; 2.000
|
|
|
|
;; Rounding is half away from zero at the last digit kept, on both signs.
|
|
(show 0.125 2) ; 0.13
|
|
(show -0.125 2) ; -0.13
|
|
(show 2.5 0) ; 3
|
|
(show -2.5 0) ; -3
|
|
|
|
;; The carry. 0.999995 scaled by 10^5 rounds to exactly 100000, which is the
|
|
;; next integer; without the carry this prints "0.100000".
|
|
(show 0.999995 5) ; 1.00000
|
|
(show 9.99 1) ; 10.0
|
|
(show -9.99 1) ; -10.0
|
|
(show 0.99 0) ; 1
|
|
|
|
;; Zero padding. The fraction of 1.005 at three places is 5, and five digits
|
|
;; is not the same number as 005.
|
|
(show 1.005 3) ; 1.005
|
|
(show 1.0001 4) ; 1.0001
|
|
(show 7.0 6) ; 7.000000
|
|
|
|
;; The sign lives on the number, not on the integer part: both of these have
|
|
;; an integer part of 0, which i64->bytes renders without a sign.
|
|
(show -0.5 2) ; -0.50
|
|
(show -0.004 2) ; -0.00
|
|
|
|
;; -0.0 prints as a plain zero. The sign test is (< x 0.0), which -0.0 fails,
|
|
;; and text is not where the sign of a zero should be read from.
|
|
(show 0.0 2) ; 0.00
|
|
(show -0.0 2) ; 0.00
|
|
|
|
;; Precision is clamped rather than refused, at both ends.
|
|
(show 1.5 -3) ; 2
|
|
(show 1.5 40) ; 1.500000000
|
|
|
|
;; The three inputs with no decimal expansion.
|
|
(show (/ 0.0 0.0) 2) ; nan
|
|
(show (/ 1.0 0.0) 2) ; inf
|
|
(show (/ -1.0 0.0) 2) ; -inf
|
|
|
|
;; Past 9e18 an f64 has no fractional bits and the integer part does not fit
|
|
;; in an i64, so this falls back to %g rather than approximating.
|
|
(show 1e20 2) ; 1e+20
|
|
|
|
;; A large magnitude that does fit, where the fraction is genuinely gone: an
|
|
;; f64 has no bits below 1 up there, so the padding produces the zeros.
|
|
(show 1234567890123.0 2) ; 1234567890123.00
|
|
|
|
;; And the thing it is for: a formatted number inside a built string, which
|
|
;; needs the integer part copied out before the fraction is rendered, because
|
|
;; both come through the runtime's one shared scratch buffer.
|
|
(let [b (vec-new u8)]
|
|
(append! (addr b) (bytes "fps "))
|
|
(let [f (format-f64 59.94 1)]
|
|
(append! (addr b) (as-slice f))
|
|
(free f))
|
|
(append! (addr b) (bytes " / frame "))
|
|
(let [f (format-f64 0.0166667 4)]
|
|
(append! (addr b) (as-slice f))
|
|
(free f))
|
|
(println (string (as-slice b))) ; fps 59.9 / frame 0.0167
|
|
(free b))
|
|
0)
|