iOS rounds a stress level with printf where Android uses arithmetic, diverging on three exact values

[ryanbr]

What

Android and iOS round a 0-3 stress level with two different functions. They agree on every level either platform can realistically produce, so this is a latent parity gap rather than a live bug, filed because the codebase has already been bitten by this exact difference once.

	how a level reaches one decimal
Android	(value * 10).roundToInt(), arithmetic, half away from zero on the product
iOS	String(format: "%.1f", lvl), C printf, half to even on the binary value

StressView.swift uses String(format:) at every level display (peak, avg, today, the trend rows). Android settled on arithmetic in #2165.

The divergence, exactly

Only values that are exact binary fractions can disagree, and inside 0-3 there are three:

value   iOS     Android
0.25    0.2     0.3
1.25    1.2     1.3
2.25    2.2     2.3

0.75, 1.75 and 2.75 agree, half to even landing on the same digit half up does.

Over two million continuous levels drawn across the domain: zero disagreements. A logistic squash lands within an ulp of a .x5 boundary about never, so on iOS, where the level stays a raw double all the way to the formatter, this cannot be reached in practice.

Why file it anyway

SleepStagerTrace.round1 documents this precise difference and records a harness catching the two sides disagreeing on a real number, Kotlin 64.1 against Swift 64.0, on a value produced by a multiplicative band rather than a logistic. Its conclusion was to do the arithmetic on both platforms rather than let one side use printf:

Multiplying and rounding is IEEE-deterministic, so both platforms do the same arithmetic to the same bits and cannot disagree, whichever side of .5 the product lands on.

Stress has not adopted that on the Swift side. The parity contract wants the analytic surfaces byte-identical, and "identical except on three values nothing currently generates" is a thing that stops being true the moment the level stops coming straight from a logistic.

Note that #2166 makes exactly 2.25 reachable on Android, since the widget's snapshot quantises to two decimals. It does not make it reachable on iOS, which has no equivalent step, so the two do not currently meet. Whichever way #2166 goes is worth deciding before this one.

What to change

Give StressTrace.swift a formatLevel doing the same arithmetic as the Kotlin twin, clamped the same way, and route StressView.swift and StressWidget.swift through it instead of String(format:). That is the shape round1 already established, and it would give the level one spelling across all four surfaces rather than the separator-only agreement #2165 reached.

Low priority. No user currently sees a wrong number from this.

[ryanbr]

Related, and the more likely of the two to be what was actually seen: #2166. The widget's snapshot rounds a level to two decimals before the display rounds it to one, so the widget and the card differ by a tenth about one time in twenty on identical data, with no staleness involved.

That one is Android-only and reachable now. This one is cross-platform and, on current data, is not.

[ayiskakov]

Went to implement this and found the filed gap already closed on main: StressTrace.formatLevel exists on both platforms with exactly the shape proposed here, StressView.swift routes every level display through it (peak, avg, today, the trend rows), StressWidget.swift and the Glance widget likewise, and project.yml deliberately compiles StrandiOSShared/StressTrace.swift into the macOS app module so the shared screen prints through the parity formatter there too. The Swift suite pins the three exact quarters (StressTraceTests.swift). As far as I can tell, nothing on the level surfaces still goes through String(format:).

Two follow-ups came out of verifying that, both in #2369:

1. The Kotlin suite never pinned the exact-quarter trio — only Swift did, and a pin only guards the direction it is written in.
2. The LF/HF ratio tile one line below the level tiles still prints through the two printf families, and those disagree in opposite directions: Java's %.1f rounds half up where C's rounds half to even, so an exact quotient such as 9/4 spells "2.3" on Android and "2.2" on iOS. Unlike the logistic-squashed level, a quotient genuinely can land on an exact binary fraction. formatRatio now shares the tenths arithmetic without the level's domain ceiling.

Field context: verified on a WHOOP MG running a build-from-source iOS install; the level surfaces all print identically, and the ratio divergence is reachable only through the exact-binary route described above.