time-to-botec

Benchmark sampling in different programming languages
Log | Files | Refs | README

splitContinuousAndDiscrete.js (2472B)

      1 export const splitContinuousAndDiscrete = (sortedArray, minDiscreteWeight) => {
      2     const continuous = [];
      3     const discreteCount = [];
      4     const discreteValue = [];
      5     if (!Number.isInteger(minDiscreteWeight)) {
      6         throw new Error(`Minimum discrete weight must be an integer. Got ${minDiscreteWeight}`);
      7     }
      8     if (minDiscreteWeight < 2) {
      9         throw new Error("Minimum discrete weight must be at least 2");
     10     }
     11     const minDistance = minDiscreteWeight - 1;
     12     const len = sortedArray.length;
     13     let i = 0;
     14     while (i < len - minDistance) {
     15         const value = sortedArray[i];
     16         if (value !== sortedArray[i + minDistance]) {
     17             continuous.push(value);
     18             i++;
     19         }
     20         else {
     21             const iOrig = i;
     22             let base = minDistance;
     23             const isEqualAt = (ind) => ind < len && sortedArray[ind] === value;
     24             while (isEqualAt(iOrig + base * 2)) {
     25                 base *= 2;
     26             }
     27             let lo = iOrig + base;
     28             i = Math.min(lo + base, len);
     29             while (i - lo > 1) {
     30                 const mid = lo + Math.floor((i - lo) / 2);
     31                 if (sortedArray[mid] === value) {
     32                     lo = mid;
     33                 }
     34                 else {
     35                     i = mid;
     36                 }
     37             }
     38             discreteValue.push(value);
     39             discreteCount.push(i - iOrig);
     40         }
     41     }
     42     continuous.push(...sortedArray.slice(i));
     43     return {
     44         continuousSamples: continuous,
     45         discreteShape: { xs: discreteValue, ys: discreteCount },
     46     };
     47 };
     48 export const continuousAreSameFilter = ({ continuousSamples, discreteShape: { xs, ys }, }) => {
     49     const allContinuousAreSame = continuousSamples.length > 0 &&
     50         continuousSamples[0] === continuousSamples[continuousSamples.length - 1];
     51     if (allContinuousAreSame) {
     52         return {
     53             continuousSamples: [],
     54             discreteShape: {
     55                 xs: [...xs, continuousSamples[0]],
     56                 ys: [...ys, continuousSamples.length],
     57             },
     58         };
     59     }
     60     return { continuousSamples, discreteShape: { xs, ys } };
     61 };
     62 export const minContinuousSamplesFilter = (minSampleCount, { continuousSamples, discreteShape }) => {
     63     if (continuousSamples.length < minSampleCount) {
     64         return { continuousSamples: [], discreteShape };
     65     }
     66     return { continuousSamples, discreteShape };
     67 };
     68 //# sourceMappingURL=splitContinuousAndDiscrete.js.map