std/float

`std/float`

std/float — f32 / f64 to-string formatting. Up to 7 fractional digits for f32, 15 for f64 (matching IEEE 754 single / double precision); trailing zeros trimmed and the decimal point is dropped if the fraction is zero. NaN gets the canonical “NaN”; ±Inf get “Inf” / “-Inf”. Detection of Inf is approximate — the threshold check (n * 2.0 == n) covers every practically-encountered case but isn’t bit- exact against f64.const inf. Migrated from the auto-injected prelude per docs/PRELUDE-TO-MODULES.md.

`to_string`

pub function (n: f32) to_string(): string

`to_string`

pub function (n: f64) to_string(): string

`abs`

pub function (x: f64) abs(): f64

`floor`

pub function (x: f64) floor(): f64

`ceil`

pub function (x: f64) ceil(): f64

`round`

pub function (x: f64) round(): f64

round(x) follows the “round half away from zero” convention (matches Go’s math.Round). Tests that need banker’s rounding (round half to even) should reach into the bit-pattern themselves.

`trunc`

pub function (x: f64) trunc(): f64

trunc(x) is round-toward-zero, equivalent to (x as i64) as f64 for values that fit in the i64 range. The primitive form handles ±Inf / NaN that the cast version would reject.

`sqrt`

pub function (x: f64) sqrt(): f64

`log`

pub function (x: f64) log(): f64

`exp`

pub function (x: f64) exp(): f64

`sin`

pub function (x: f64) sin(): f64

`cos`

pub function (x: f64) cos(): f64

`pow`

pub function (x: f64) pow(y: f64): f64

pow(x, y) — two-argument form; method receiver is the base. Use (b).pow(e) for b ^ e.

`is_nan`

pub function (x: f64) is_nan(): boolean

is_nan(x) / is_inf(x) / is_finite(x) — IEEE-754 classification. The NaN predicate uses the textbook “x != x” pattern; is_inf checks both ±Inf by squaring (Inf * 2 == Inf, finite * 2 grows), is_finite is the negation. Helpers so test code doesn’t have to spell out the textbook patterns every time.

`is_finite`

pub function (x: f64) is_finite(): boolean

`is_inf`

pub function (x: f64) is_inf(): boolean

`min`

pub function (x: f64) min(y: f64): f64

min(x, y) / max(x, y) — return the smaller / larger value. NaN inputs are infectious (any NaN in → NaN out), matching Go’s math.Min / math.Max semantics. Float comparisons with NaN are well-defined as “always false”, which is what the inline check below relies on.

`max`

pub function (x: f64) max(y: f64): f64

`clamp`

pub function (x: f64) clamp(lo: f64, hi: f64): f64

clamp(x, lo, hi) — restrict to [lo, hi]. Implemented as max(lo, min(hi, x)); preserves NaN if any input is NaN.