@3dsource/angular-unreal-module 0.0.184 → 0.0.185

package/fesm2022/3dsource-angular-unreal-module.mjs

@@ -7703,19 +7703,35 @@ class StreamStatusTelemetryService2 {
     }
     aggregate(values) {
         if (values.length === 0)
-            return { p50: 0, p95: 0, min: 0, max: 0 };
+            return { p50: 0, p95: 0, p05: 0, min: 0, max: 0 };
         const sorted = [...values].sort((a, b) => a - b);
-        // Nearest-rank method: p-th percentile ≡ sorted[ceil(p/100 * n) - 1].
-        // Using `floor` would make p95 collapse to `max` for n=20
-        // (floor(0.95*20) = 19 = max index), hiding the max line behind p95
-        // in charts. `ceil - 1` keeps them distinct: p. 95 = sorted[18], max = sorted[19].
+        // Linear interpolation between order statistics (the "type 7" method:
+        // Excel's PERCENTILE, NumPy's default, and — deliberately — the same
+        // maths the telemetry viewer's PHP `percentile()` uses, so a window
+        // percentile and a population percentile are never two different
+        // definitions of the word.
+        //
+        // This replaced nearest-rank (`sorted[ceil(p/100 * n) - 1]`), which
+        // cannot express a low tail at these window sizes: ceil(0.05 * n) is 1
+        // for every n ≤ 20, so p05 would have been an alias for `min` — one
+        // dropped frame defining the whole window, which is the thing p05 exists
+        // to avoid. It also biased p50 high by half a rank (sorted[9] of 20
+        // rather than the midpoint of sorted[9] and sorted[10]).
+        //
+        // p95 stays distinct from `max`, which was the reason nearest-rank used
+        // `ceil - 1`: at n = 20 the rank is 18.05, i.e. just above sorted[18].
         const pick = (p) => {
-            const idx = Math.ceil((p / 100) * sorted.length) - 1;
-            return sorted[Math.max(0, Math.min(sorted.length - 1, idx))];
+            const rank = (p / 100) * (sorted.length - 1);
+            const lo = Math.floor(rank);
+            const hi = Math.ceil(rank);
+            if (lo === hi)
+                return sorted[lo];
+            return sorted[lo] + (sorted[hi] - sorted[lo]) * (rank - lo);
         };
         return {
             p50: pick(50),
             p95: pick(95),
+            p05: pick(5),
             min: sorted[0],
             max: sorted[sorted.length - 1],
         };