Smoothed zone changes

FxDart wins

Requirement

A temperature sensor reports twelve raw readings per day. Smooth them with a 3-reading moving average, classify each smoothed value into a zone (cool < 20° ≤ ok < 25° ≤ hot), and report every zone transition — which zone it left, which it entered, and the smoothed values on both sides. A day with no transitions prints a single stable line instead of nothing. The data for two July days is in the code; both versions must print the lines shown under Expected output.

Expected output

2026-07-14 (3-reading moving average):
  cool → ok (avg 18.6 → 21.2)
  ok → hot (avg 21.2 → 25.6)
  hot → ok (avg 25.6 → 24.9)
2026-07-15 (3-reading moving average):
  stable — no zone changes

Side by side

Native Dart

String zone(double t) => t < 20 ? 'cool' : (t < 25 ? 'ok' : 'hot');

List<String> zoneChanges(List<double> temps) {
  final smoothed = <double>[];
  for (var i = 0; i + 3 <= temps.length; i++) {
    var sum = 0.0;
    for (var j = i; j < i + 3; j++) {
      sum += temps[j];
    }
    smoothed.add(sum / 3);
  }
  final runStarts = <double>[];
  for (final s in smoothed) {
    if (runStarts.isEmpty || zone(s) != zone(runStarts.last)) {
      runStarts.add(s);
    }
  }
  final lines = <String>[];
  for (var i = 1; i < runStarts.length; i++) {
    final from = runStarts[i - 1];
    final to = runStarts[i];
    lines.add('${zone(from)} → ${zone(to)}'
        ' (avg ${from.toStringAsFixed(1)} → ${to.toStringAsFixed(1)})');
  }
  if (lines.isEmpty) {
    lines.add('stable — no zone changes');
  }
  return lines;
}

void main() {
  final days = {
    '2026-07-14': [18.0, 18.6, 19.2, 21.0, 23.4, 24.6, 25.8, 26.4, 25.2, 23.0, 21.8, 20.6],
    '2026-07-15': [21.4, 21.9, 22.3, 22.8, 23.1, 22.6, 22.2, 21.7, 21.3, 22.0, 22.5, 22.9],
  };
  days.forEach((day, temps) {
    print('$day (3-reading moving average):');
    for (final line in zoneChanges(temps)) {
      print('  $line');
    }
  });
}

FxDart

Why they differ

Every stage of this task needs to see neighboring elements, and that is exactly where native Dart runs out of vocabulary: no sliding window, no adjacent-dedup, no successor pairing — in the standard library or in package:collection (slices tiles without overlap). So the native version is three index loops, each carrying its own mutable state: a windowed sum, a runStarts list compared against its own tail, and an i - 1 lookback for the transition lines, plus a final isEmpty patch-up for the stable day.

The FxDart chain states the five stages in the order the data flows: windowed(3) → average per window, uniqAdjacentBy(zone) keeps the first smoothed value of each zone run, pairwise turns run-starts into (from, to) transitions, and ifEmpty supplies the stable-day line inside the pipeline instead of an if-check after it. Each fragment is independently testable, and none of it re-implements window bounds. These four operators are pull-model ports of the Rx windowing family.

Benchmark

Apple M1 Max, 32 GB RAM · Dart 3.12.2 (AOT-compiled) · 2026-08-24

N = 100

Time Tie

Native Dart 2.3 µs

FxDart 4.3 µs

Peak memory Tie

Native Dart 16.4 MB

FxDart 16.3 MB

N = 10,000

Time Tie

Native Dart 194 µs

FxDart 410 µs

Peak memory Tie

Native Dart 22.5 MB

FxDart 22.7 MB

N = 1,000,000

Time FxDart wins

Native Dart 39.4 ms

FxDart 37.4 ms

Peak memory FxDart wins

Native Dart 237.3 MB

FxDart 81.8 MB

Bars are medians of repeated timed iterations in fresh processes per side (small N is batched for timer resolution). Sides within 5% of each other — or within 0.6 ms, a difference no person can perceive — count as a tie; close relative races are re-measured up to 5 runs. In an app, anything under a few milliseconds is invisible to the user regardless of which bar is shorter. Memory is peak process RSS. The Dart VM and the dataset are identical on both sides, so the difference between the two bars is what the pipeline itself holds onto.