Merge a51b65f into d2c3709

Author: FlyCloudC

bench/bench.mbt

@@ -42,13 +42,12 @@ fn iter_count(name? : String, inner : () -> Unit, count : UInt) -> Summary {
   } else {
     target_batch_size.ceil().to_int()
   }
-  let samples = Array::new(capacity=count)
-  samples.resize(count, 0.0)
-  for i in 0..<count {
-    samples[i] = iter_n_microseconds(inner, batch_size) / batch_size.to_double()
-  }
-  winsorize(samples, 5.0)
-  Summary::new(name?, samples, batch_size)
+  let samples = Array::makei(count, fn(_) {
+    iter_n_microseconds(inner, batch_size) / batch_size.to_double()
+  })
+  samples.sort()
+  winsorize(sorted_data=samples, 5.0)
+  Summary::new(name?, sorted_data=samples, batch_size)
 }
 
 ///|

bench/stats.mbt

@@ -37,21 +37,21 @@ struct Summary {
 ///|
 fn Summary::new(
   name? : String,
-  data : Array[Double],
+  sorted_data~ : Array[Double],
   batch_size : Int
 ) -> Summary {
-  let sum = sum(data)
-  let min = min(data)
-  let max = max(data)
-  let mean = mean(data)
-  let median = median(data)
-  let var = var(data)
-  let std_dev = std_dev(data)
-  let std_dev_pct = std_dev_pct(data)
-  let median_abs_dev = median_abs_dev(data)
-  let median_abs_dev_pct = median_abs_dev_pct(data)
-  let quartiles = quartiles(data)
-  let iqr = iqr(data)
+  let sum = sum(sorted_data)
+  let min = min(sorted_data~)
+  let max = max(sorted_data~)
+  let mean = mean(sorted_data, sum~)
+  let median = median(sorted_data~)
+  let var = var(sorted_data, mean~)
+  let std_dev = std_dev(var~)
+  let std_dev_pct = std_dev_pct(mean~, std_dev~)
+  let median_abs_dev = median_abs_dev(sorted_data, median_=median)
+  let median_abs_dev_pct = median_abs_dev_pct(median~, median_abs_dev~)
+  let quartiles = quartiles(sorted_data~)
+  let iqr = iqr(quartiles~)
   {
     name,
     sum,
@@ -67,7 +67,7 @@ fn Summary::new(
     quartiles,
     iqr,
     batch_size,
-    runs: data.length(),
+    runs: sorted_data.length(),
   }
 }
 
@@ -81,45 +81,31 @@ fn sum(data : Array[Double]) -> Double {
 }
 
 ///|
-fn min(data : Array[Double]) -> Double {
-  let mut min = data[0]
-  for i in data {
-    if i < min {
-      min = i
-    }
-  }
-  min
+fn min(sorted_data~ : Array[Double]) -> Double {
+  sorted_data[0]
 }
 
 ///|
-fn max(data : Array[Double]) -> Double {
-  let mut max = data[0]
-  for i in data {
-    if i > max {
-      max = i
-    }
-  }
-  max
+fn max(sorted_data~ : Array[Double]) -> Double {
+  sorted_data[sorted_data.length() - 1]
 }
 
 ///|
-fn mean(data : Array[Double]) -> Double {
-  let sum = sum(data)
+fn mean(data : Array[Double], sum~ : Double) -> Double {
   let count = data.length()
   sum / count.to_double()
 }
 
 ///|
-fn median(data : Array[Double]) -> Double {
-  percentile(data, 50.0)
+fn median(sorted_data~ : Array[Double]) -> Double {
+  percentile(sorted_data~, pct=50.0)
 }
 
 ///|
-fn var(data : Array[Double]) -> Double {
+fn var(data : Array[Double], mean~ : Double) -> Double {
   if data.length() < 2 {
     return 0.0
   }
-  let mean = mean(data)
   let mut v = 0.0
   for i in data {
     let d = i - mean
@@ -129,102 +115,101 @@ fn var(data : Array[Double]) -> Double {
 }
 
 ///|
-fn std_dev(data : Array[Double]) -> Double {
-  var(data).sqrt()
+fn std_dev(var~ : Double) -> Double {
+  var.sqrt()
 }
 
 ///|
-fn std_dev_pct(data : Array[Double]) -> Double {
-  let mean = mean(data)
-  let std_dev = std_dev(data)
+fn std_dev_pct(mean~ : Double, std_dev~ : Double) -> Double {
   if mean == 0.0 {
     return 0.0
   }
   std_dev / mean * 100.0
 }
 
 ///|
-fn median_abs_dev(data : Array[Double]) -> Double {
-  let med = median(data)
-  let abs_devs = data.map(fn(x) { (med - x).abs() })
+fn median_abs_dev(data : Array[Double], median_~ : Double) -> Double {
+  let abs_devs = data.map(fn(x) { (median_ - x).abs() })
+  abs_devs.sort()
   // https://en.wikipedia.org/wiki/Median_absolute_deviation
-  median(abs_devs) * 1.4826
+  median(sorted_data=abs_devs) * 1.4826
 }
 
 ///|
-fn median_abs_dev_pct(data : Array[Double]) -> Double {
-  let med = median(data)
-  let mad = median_abs_dev(data)
-  if med == 0.0 {
+fn median_abs_dev_pct(median~ : Double, median_abs_dev~ : Double) -> Double {
+  if median == 0.0 {
     return 0.0
   }
-  mad / med * 100.0
+  median_abs_dev / median * 100.0
 }
 
 ///|
-fn quartiles(data : Array[Double]) -> (Double, Double, Double) {
-  let sorted = data.copy()
-  sorted.sort()
-  try {
-    let q1 = percentile_of_sorted(sorted, 25.0)
-    let q2 = percentile_of_sorted(sorted, 50.0)
-    let q3 = percentile_of_sorted(sorted, 75.0)
-    (q1, q2, q3)
-  } catch {
-    _ => panic()
-  }
+fn quartiles(sorted_data~ : Array[Double]) -> (Double, Double, Double) {
+  let q1 = percentile(sorted_data~, pct=25.0)
+  let q2 = percentile(sorted_data~, pct=50.0)
+  let q3 = percentile(sorted_data~, pct=75.0)
+  (q1, q2, q3)
 }
 
 ///|
-fn iqr(data : Array[Double]) -> Double {
-  let (q1, _, q3) = quartiles(data)
+fn iqr(quartiles~ : (Double, Double, Double)) -> Double {
+  let (q1, _, q3) = quartiles
   q3 - q1
 }
 
 ///|
-fn percentile_of_sorted(data : Array[Double], pct : Double) -> Double! {
-  assert_false(data.is_empty())
-  assert_true(pct >= 0.0 && pct <= 100.0)
-  if data.length() == 1 {
-    return data[0]
+fn percentile(sorted_data~ : Array[Double], pct~ : Double) -> Double {
+  guard sorted_data.length() > 0
+  guard pct >= 0.0 && pct <= 100.0
+  if sorted_data.length() == 1 {
+    return sorted_data[0]
   }
   if pct == 100.0 {
-    return data[data.length() - 1]
+    return sorted_data[sorted_data.length() - 1]
   }
-  let length = (data.length() - 1).to_double()
+  let length = (sorted_data.length() - 1).to_double()
   let rank = pct / 100 * length
   let lrank = rank.floor()
   let d = rank - lrank
   let n = lrank.to_int()
-  let lo = data[n]
-  let hi = data[n + 1]
+  let lo = sorted_data[n]
+  let hi = sorted_data[n + 1]
   lo + (hi - lo) * d
 }
 
 ///|
-fn percentile(data : Array[Double], pct : Double) -> Double {
-  let sorted = data.copy()
-  sorted.sort()
-  try percentile_of_sorted(sorted, pct) catch {
-    _ => panic()
+fn winsorize(sorted_data~ : Array[Double], pct : Double) -> Unit {
+  let lo = percentile(sorted_data~, pct~)
+  let hi = percentile(sorted_data~, pct=100.0 - pct)
+  for i, samp in sorted_data {
+    if samp > hi {
+      sorted_data[i] = hi
+    } else if samp < lo {
+      sorted_data[i] = lo
+    }
   }
 }
 
 ///|
-fn winsorize(data : Array[Double], pct : Double) -> Unit {
-  let sorted = data.copy()
-  sorted.sort()
-  try {
-    let lo = percentile_of_sorted(sorted, pct)
-    let hi = percentile_of_sorted(sorted, 100.0 - pct)
-    for i, samp in data {
-      if samp > hi {
-        data[i] = hi
-      } else if samp < lo {
-        data[i] = lo
-      }
-    }
-  } catch {
-    _ => panic()
-  }
+test {
+  let data = [1.1, 21.4, 2.2, 3.3, 4.5, 12.5, 33.3, 14.4]
+  data.sort()
+  let summary = Summary::new(sorted_data=data, 3)
+  assert_true(summary.sum.is_close(92.7))
+  assert_true(summary.min.is_close(1.1))
+  assert_true(summary.max.is_close(33.3))
+  assert_true(summary.mean.is_close(11.5875))
+  assert_true(summary.median.is_close(8.5))
+  assert_true(summary.var.is_close(127.64125))
+  assert_true(summary.std_dev.is_close(11.297842714430043))
+  assert_true(summary.std_dev_pct.is_close(97.50026075020534))
+  assert_true(summary.median_abs_dev.is_close(9.04386))
+  assert_true(summary.median_abs_dev_pct.is_close(106.39835294117646))
+  let (q1, q2, q3) = summary.quartiles
+  assert_true(q1.is_close(3.025))
+  assert_true(q2.is_close(8.5))
+  assert_true(q3.is_close(16.15))
+  assert_true(summary.iqr.is_close(13.125))
+  assert_true(summary.batch_size == 3)
+  assert_true(summary.runs == 8)
 }