nano-benchmark 1.0.0

package/src/stats.js

@@ -0,0 +1,116 @@
+export const mean = data => {
+  let m = 0;
+  const size = data.length;
+  for (let i = 0; i < size; ++i) {
+    m += data[i] / size;
+  }
+  return m;
+};
+
+export const variance = (data, meanValue = mean(data)) => {
+  let s = 0;
+  const size = data.length;
+  for (let i = 0; i < size; ++i) {
+    const diff = data[i] - meanValue;
+    s += (diff * diff) / size;
+  }
+  return s;
+};
+
+export const stdDev = (data, meanValue = mean(data)) => Math.sqrt(variance(data, meanValue));
+
+export const zScore = (x, mean, stdDev) => (x - mean) / stdDev;
+
+export const makeZScoreFn = data => {
+  const m = mean(data),
+    s = stdDev(data, m);
+  return x => (x - m) / s;
+};
+
+export const skewness = (data, meanValue = mean(data), stdDevValue = stdDev(data, meanValue)) => {
+  let s = 0;
+  const size = data.length;
+  for (let i = 0; i < size; ++i) {
+    const z = (data[i] - meanValue) / stdDevValue;
+    s += (z * z * z) / size;
+  }
+  return s;
+};
+
+export const adjustedSkewness = (
+  data,
+  meanValue = mean(data),
+  stdDevValue = stdDev(data, meanValue)
+) => {
+  const size = data.length;
+  return (Math.sqrt(size * (size - 1)) / (size - 2)) * skewness(data, meanValue, stdDevValue);
+};
+
+export const kurtosis = (data, meanValue = mean(data), stdDevValue = stdDev(data, meanValue)) => {
+  let s = 0;
+  const size = data.length;
+  for (let i = 0; i < size; ++i) {
+    const z = (data[i] - meanValue) / stdDevValue,
+      z2 = z * z;
+    s += (z2 * z2) / size;
+  }
+  return s;
+};
+
+export const excessKurtosis = (
+  data,
+  meanValue = mean(data),
+  stdDevValue = stdDev(data, meanValue)
+) => kurtosis(data, meanValue, stdDevValue) - 3;
+
+export const getPercentile = (sortedArray, value) => {
+  // getting percentile (index) by value
+  let lowerIndex = 0,
+    upperIndex = sortedArray.length - 1;
+  while (lowerIndex < upperIndex) {
+    let middleIndex = (lowerIndex + upperIndex) >> 1;
+    if (sortedArray[middleIndex] < value) {
+      lowerIndex = middleIndex + 1;
+    } else {
+      upperIndex = middleIndex;
+    }
+  }
+  return lowerIndex < sortedArray.length && value < sortedArray[lowerIndex]
+    ? lowerIndex
+    : lowerIndex + 1;
+};
+
+export const getWeightedValue = (sortedArray, weight = 0.5) => {
+  // getting weighted data from a sorted array
+  let pos = weight * (sortedArray.length - 1),
+    upperIndex = Math.ceil(pos),
+    lowerIndex = upperIndex - 1;
+  if (lowerIndex <= 0) {
+    // return first element
+    return sortedArray[0];
+  }
+  if (upperIndex >= sortedArray.length) {
+    // return last element
+    return sortedArray[sortedArray.length - 1];
+  }
+  // linear approximation
+  return (
+    sortedArray[lowerIndex] * (upperIndex - pos) + sortedArray[upperIndex] * (pos - lowerIndex)
+  );
+};
+
+export const bootstrap = (fn, data, n = 1000) => {
+  const size = data.length,
+    samples = new Array(data.length),
+    results = new Array(n);
+
+  for (let i = 0; i < n; ++i) {
+    // resample
+    for (let j = 0; j < size; ++j) {
+      samples[j] = data[Math.floor(Math.random() * size)];
+    }
+    results[i] = fn(samples);
+  }
+
+  return results;
+};

package/src/stream-median.js

@@ -0,0 +1,93 @@
+export class MedianCounter {
+  constructor(limit = 10) {
+    this.limit = limit;
+    this.array = [];
+  }
+
+  add(value) {
+    for (let i = 0; i < this.array.length; ++i) {
+      const counter = this.array[i];
+
+      if (counter.length < 3) {
+        counter.push(value);
+        return;
+      }
+
+      this.array[i] = [value];
+
+      const a = counter[0],
+        b = counter[1],
+        c = counter[2];
+      if (a < b) {
+        value = b < c ? b : a < c ? c : a;
+      } else {
+        value = a < c ? a : b < c ? c : b;
+      }
+    }
+
+    if (this.array.length < this.limit) {
+      this.array.push([value]);
+    } else {
+      this.add(value);
+    }
+  }
+
+  get() {
+    const copy = this.clone();
+
+    let value;
+
+    while (copy.array.length) {
+      const counter = copy.array.shift();
+
+      switch (counter.length) {
+        case 1:
+          value = counter[0];
+          break;
+        case 2:
+          {
+            const a = counter[0],
+              b = counter[1];
+            value = a < b ? a : b;
+          }
+          break;
+        case 3:
+          {
+            const a = counter[0],
+              b = counter[1],
+              c = counter[2];
+            if (a < b) {
+              value = b < c ? b : a < c ? c : a;
+            } else {
+              value = a < c ? a : b < c ? c : b;
+            }
+          }
+          break;
+      }
+
+      if (!copy.array.length) break;
+
+      copy.add(value);
+    }
+
+    return value;
+  }
+
+  clone() {
+    const newMedian = new MedianCounter();
+    for (const counter of this.array) {
+      newMedian.array.push(counter.slice());
+    }
+    return newMedian;
+  }
+}
+
+export const streamMedian = iterable => {
+  const medianCounter = new MedianCounter();
+  for (const value of iterable) {
+    medianCounter.add(value);
+  }
+  return medianCounter.get();
+};
+
+export default streamMedian;

package/src/stream-stats.js

@@ -0,0 +1,67 @@
+// based on https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+
+export class StatCounter {
+  constructor() {
+    this.count = this.mean = this.M2 = this.M3 = this.M4 = 0;
+  }
+
+  add(value) {
+    const n = ++this.count,
+      delta = value - this.mean,
+      term1 = delta / n,
+      term2 = delta * term1 * (n - 1),
+      term3 = term1 * term1;
+
+    this.mean += delta / n;
+    this.M4 += term3 * term2 * ((n - 3) * n + 3) + 6 * term3 * this.M2 - 4 * term1 * this.M3;
+    this.M3 += term1 * term2 * (n - 2) - 3 * term1 * this.M2;
+    this.M2 += term2;
+  }
+
+  get variance() {
+    return this.M2 / this.count;
+  }
+
+  get sampleVariance() {
+    return this.M2 / (this.count - 1);
+  }
+
+  get skewness() {
+    return (Math.sqrt(this.count) * this.M3) / Math.pow(this.M2, 1.5);
+  }
+
+  get kurtosis() {
+    return (this.count * this.M4) / (this.M2 * this.M2) - 3;
+  }
+
+  clone() {
+    const newStatCounter = new StatCounter();
+
+    newStatCounter.count = this.count;
+    newStatCounter.mean = this.mean;
+    newStatCounter.M2 = this.M2;
+    newStatCounter.M3 = this.M3;
+    newStatCounter.M4 = this.M4;
+
+    return newStatCounter;
+  }
+}
+
+export const streamStats = iterable => {
+  const statCounter = new StatCounter();
+
+  for (const value of iterable) {
+    statCounter.add(value);
+  }
+
+  return {
+    count: statCounter.count,
+    mean: statCounter.mean,
+    variance: statCounter.variance,
+    sampleVariance: statCounter.sampleVariance,
+    skewness: statCounter.skewness,
+    kurtosis: statCounter.kurtosis
+  };
+};
+
+export default streamStats;

package/src/utils/bsearch.js

@@ -0,0 +1,9 @@
+const bsearch = (sortedArray, lessFn, l = 0, r = sortedArray.length) => {
+  while (l < r) {
+    const m = (l + r) >> 1;
+    if (lessFn(sortedArray[m])) l = m + 1;
+    else r = m;
+  }
+  return r;
+};
+export default bsearch;

package/src/utils/rk.js

@@ -0,0 +1,36 @@
+const ONE_THIRD = 1 / 3;
+
+export const rk23 = (fn, {a = 0, b = 1, tolerance = 1e-6, initialValue = 0} = {}) => {
+  const ts = [a],
+    us = [initialValue];
+  let t = ts[0],
+    u = us[0],
+    h = Math.min(0.5 * Math.pow(tolerance, ONE_THIRD), b - t),
+    s1 = fn(a, initialValue);
+
+  while (t < b) {
+    if (t + h == t) {
+      // underflow
+      console.warn('Warning: step is too small near:', t);
+      break;
+    }
+
+    let s2 = fn(t + h / 2, u + (h / 2) * s1),
+      s3 = fn(t + 0.75 * h, u + 0.75 * h * s2),
+      uNew = u + (h * (2 * s1 + 3 * s2 + 4 * s3)) / 9, // 2nd order solution
+      s4 = fn(t + h, uNew),
+      error = Math.abs(h * ((-5 / 72) * s1 + s2 / 12 + s3 / 9 - s4 / 8)), // 2nd/3rd diff error estimate
+      maxError = tolerance * (1 + Math.abs(u)); // relative/absolute blend
+
+    if (error < maxError) {
+      ts.push((t += h));
+      us.push(u = uNew);
+      s1 = s4;
+    }
+
+    const q = Math.min(4, 0.8 * Math.pow(maxError / error, ONE_THIRD));
+    h = Math.min(q * h, b - t);
+  }
+
+  return {ts, us, finalValue: us[us.length - 1]};
+};