@complat/react-spectra-editor 0.10.13-alpha.5

package/dist/third_party/jAnalyzer.js

@@ -0,0 +1,596 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+// https://github.com/cheminfo-js/spectra/blob/master/packages/spectra-data/src/peakPicking/jAnalyzer.js
+
+/*
+ * This library implements the J analyser described by Cobas et al in the paper:
+ * A two-stage approach to automatic determination of 1H NMR coupling constants
+ */
+var patterns = ['s', 'd', 't', 'q', 'quint', 'h', 'sept', 'o', 'n'];
+var symRatio = 1.5;
+var maxErrorIter1 = 2.5; // Hz
+var maxErrorIter2 = 1; // Hz
+
+exports.default = {
+  /**
+   * The compilation process implements at the first stage a normalization procedure described by Golotvin et al.
+   * embedding in peak-component-counting method described by Hoyes et al.
+   * @param {object} signal
+   * @private
+   */
+  compilePattern: function compilePattern(signal) {
+    signal.multiplicity = 'm';
+    // 1.1 symmetrize
+    // It will add a set of peaks(signal.peaksComp) to the signal that will be used during
+    // the compilation process. The unit of those peaks will be in Hz
+    signal.symRank = symmetrizeChoiseBest(signal, maxErrorIter1, 1);
+    signal.asymmetric = true;
+    // Is the signal symmetric?
+    if (signal.symRank >= 0.95 && signal.peaksComp.length < 32) {
+      signal.asymmetric = false;
+      var i, j, n, P1, n2, maxFlagged;
+      var k = 1;
+      var Jc = [];
+
+      // Loop over the possible number of coupling contributing to the multiplet
+      for (n = 0; n < 9; n++) {
+        // 1.2 Normalize. It makes a deep copy of the peaks before to modify them.
+        var peaks = normalize(signal, n);
+        // signal.peaksCompX = peaks;
+        var validPattern = false; // It will change to true, when we find the good patter
+        // Lets check if the signal could be a singulet.
+        if (peaks.length === 1 && n === 0) {
+          validPattern = true;
+        } else {
+          if (peaks.length <= 1) {
+            continue;
+          }
+        }
+        // 1.3 Establish a range for the Heights Hi [peaks.intensity*0.85,peaks.intensity*1.15];
+        var ranges = getRanges(peaks);
+        n2 = Math.pow(2, n);
+
+        // 1.4 Find a combination of integer heights Hi, one from each Si, that sums to 2^n.
+        var heights = null;
+        var counter = 1;
+        while (!validPattern && (heights = getNextCombination(ranges, n2)) !== null && counter < 400) {
+          // 2.1 Number the components of the multiplet consecutively from 1 to 2n,
+          // starting at peak 1
+          var numbering = new Array(heights.length);
+          k = 1;
+          for (i = 0; i < heights.length; i++) {
+            numbering[i] = new Array(heights[i]);
+            for (j = 0; j < heights[i]; j++) {
+              numbering[i][j] = k++;
+            }
+          }
+
+          Jc = []; // The array to store the detected j-coupling
+          // 2.2 Set j = 1; J1 = P2 - P1. Flag components 1 and 2 as accounted for.
+          j = 1;
+          Jc.push(peaks[1].x - peaks[0].x);
+          P1 = peaks[0].x;
+          numbering[0].splice(0, 1); // Flagged
+          numbering[1].splice(0, 1); // Flagged
+          k = 1;
+          var nFlagged = 2;
+          maxFlagged = Math.pow(2, n) - 1;
+          while (Jc.length < n && nFlagged < maxFlagged && k < peaks.length) {
+            counter += 1;
+            // 4.1. Increment j. Set k to the number of the first unflagged component.
+            j++;
+            while (k < peaks.length && numbering[k].length === 0) {
+              k++;
+            }
+            if (k < peaks.length) {
+              // 4.2 Jj = Pk - P1.
+              Jc.push(peaks[k].x - peaks[0].x);
+              // Flag component k and, for each sum of the...
+              numbering[k].splice(0, 1); // Flageed
+              nFlagged++;
+              // Flag the other components of the multiplet
+              for (var u = 2; u <= j; u++) {
+                // TODO improve those loops
+                var jSum = 0;
+                for (i = 0; i < u; i++) {
+                  jSum += Jc[i];
+                }
+                for (i = 1; i < numbering.length; i++) {
+                  // Maybe 0.25 Hz is too much?
+                  if (Math.abs(peaks[i].x - (P1 + jSum)) < 0.25) {
+                    numbering[i].splice(0, 1); // Flageed
+                    nFlagged++;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+          // Calculate the ideal patter by using the extracted j-couplings
+          var pattern = idealPattern(Jc);
+          // Compare the ideal pattern with the proposed intensities.
+          // All the intensities have to match to accept the multiplet
+          validPattern = true;
+          for (i = 0; i < pattern.length; i++) {
+            if (pattern[i].intensity !== heights[i]) {
+              validPattern = false;
+            }
+          }
+        }
+        // If we found a valid pattern we should inform about the pattern.
+        if (validPattern) {
+          updateSignal(signal, Jc);
+        }
+      }
+    }
+    // Before to return, change the units of peaksComp from Hz to PPM again
+    for (i = 0; i < signal.peaksComp.length; i++) {
+      signal.peaksComp[i].x /= signal.observe;
+    }
+  }
+};
+
+/**
+ * @private
+ * update the signal
+ * @param {*} signal
+ * @param {*} Jc
+ */
+
+function updateSignal(signal, Jc) {
+  // Update the limits of the signal
+  var peaks = signal.peaksComp; // Always in Hz
+  var nbPeaks = peaks.length;
+  signal.startX = peaks[0].x / signal.observe - peaks[0].width;
+  signal.stopX = peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].width;
+
+  // signal.integralData.from = peaks[0].x / signal.observe - peaks[0].width * 3;
+  // signal.integralData.to =
+  //   peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].width * 3;
+
+  // Compile the pattern and format the constant couplings
+  signal.maskPattern = signal.mask2;
+  signal.multiplicity = abstractPattern(signal, Jc);
+  signal.pattern = signal.multiplicity; // Our library depends on this parameter, but it is old
+  // console.log(signal);
+  /* if (DEBUG)        {
+        console.log('Final j-couplings: ' + JSON.stringify(Jc));
+    }*/
+}
+
+/**
+ * Returns the multiplet in the compact format
+ * @param {object} signal
+ * @param {object} Jc
+ * @return {string}
+ * @private
+ */
+function abstractPattern(signal, Jc) {
+  var tol = 0.05;
+  var i = void 0;
+  var pattern = '';
+  var cont = 1;
+  var newNmrJs = [];
+
+  if (Jc && Jc.length > 0) {
+    Jc.sort(function (a, b) {
+      return b - a;
+    });
+
+    for (i = 0; i < Jc.length - 1; i++) {
+      if (Math.abs(Jc[i] - Jc[i + 1]) < tol) {
+        cont++;
+      } else {
+        newNmrJs.push({
+          coupling: Math.abs(Jc[i]),
+          multiplicity: patterns[cont]
+        });
+        pattern += patterns[cont];
+        cont = 1;
+      }
+    }
+    newNmrJs.push({ coupling: Math.abs(Jc[i]), multiplicity: patterns[cont] });
+    pattern += patterns[cont];
+    signal.nmrJs = newNmrJs;
+  } else {
+    pattern = 's';
+    // if (Math.abs(signal.startX - signal.stopX) * signal.observe > 16) {
+    //   pattern = 'br s';
+    // }
+  }
+  return pattern;
+}
+
+/**
+ * This function creates an ideal pattern from the given J-couplings
+ * @private
+ * @param {Array} Jc
+ * @return {*[]}
+ * @private
+ */
+function idealPattern(Jc) {
+  var hsum = Math.pow(2, Jc.length);
+  var i = void 0,
+      j = void 0;
+  var pattern = [{ x: 0, intensity: hsum }];
+  // To split the initial height
+  for (i = 0; i < Jc.length; i++) {
+    for (j = pattern.length - 1; j >= 0; j--) {
+      pattern.push({
+        x: pattern[j].x + Jc[i] / 2,
+        intensity: pattern[j].intensity / 2
+      });
+      pattern[j].x = pattern[j].x - Jc[i] / 2;
+      pattern[j].intensity = pattern[j].intensity / 2;
+    }
+  }
+  // To sum the heights in the same positions
+  pattern.sort(function compare(a, b) {
+    return a.x - b.x;
+  });
+  for (j = pattern.length - 2; j >= 0; j--) {
+    if (Math.abs(pattern[j].x - pattern[j + 1].x) < 0.1) {
+      pattern[j].intensity += pattern[j + 1].intensity;
+      pattern.splice(j + 1, 1);
+    }
+  }
+  return pattern;
+}
+
+/**
+ * Find a combination of integer heights Hi, one from each Si, that sums to 2n.
+ * @param {object} ranges
+ * @param {number} value
+ * @return {*}
+ * @private
+ */
+function getNextCombination(ranges, value) {
+  var half = Math.ceil(ranges.values.length * 0.5);
+  var lng = ranges.values.length;
+  var sum = 0;
+  var i = void 0,
+      ok = void 0;
+  while (sum !== value) {
+    // Update the indexes to point at the next possible combination
+    ok = false;
+    while (!ok) {
+      ok = true;
+      ranges.currentIndex[ranges.active]++;
+      if (ranges.currentIndex[ranges.active] >= ranges.values[ranges.active].length) {
+        // In this case, there is no more possible combinations
+        if (ranges.active + 1 === half) {
+          return null;
+        } else {
+          // If this happens we need to try the next active peak
+          ranges.currentIndex[ranges.active] = 0;
+          ok = false;
+          ranges.active++;
+        }
+      } else {
+        ranges.active = 0;
+      }
+    }
+    // Sum the heights for this combination
+    sum = 0;
+    for (i = 0; i < half; i++) {
+      sum += ranges.values[i][ranges.currentIndex[i]] * 2;
+    }
+    if (ranges.values.length % 2 !== 0) {
+      sum -= ranges.values[half - 1][ranges.currentIndex[half - 1]];
+    }
+  }
+  // If the sum is equal to the expected value, fill the array to return
+  if (sum === value) {
+    var heights = new Array(lng);
+    for (i = 0; i < half; i++) {
+      heights[i] = ranges.values[i][ranges.currentIndex[i]];
+      heights[lng - i - 1] = ranges.values[i][ranges.currentIndex[i]];
+    }
+    return heights;
+  }
+  return null;
+}
+
+/**
+ * This function generates the possible values that each peak can contribute
+ * to the multiplet.
+ * @param {Array} peaks Array of objects with peaks information {intensity}
+ * @return {{values: Array, currentIndex: Array, active: number}}
+ * @private
+ */
+function getRanges(peaks) {
+  var ranges = new Array(peaks.length);
+  var currentIndex = new Array(peaks.length);
+  var min = void 0,
+      max = void 0;
+  ranges[0] = [1];
+  ranges[peaks.length - 1] = [1];
+  currentIndex[0] = -1;
+  currentIndex[peaks.length - 1] = 0;
+  for (var i = 1; i < peaks.length - 1; i++) {
+    min = Math.round(peaks[i].intensity * 0.85);
+    max = Math.round(peaks[i].intensity * 1.15);
+    ranges[i] = [];
+    for (var j = min; j <= max; j++) {
+      ranges[i].push(j);
+    }
+    currentIndex[i] = 0;
+  }
+  return { values: ranges, currentIndex: currentIndex, active: 0 };
+}
+/**
+ * Performs a symmetrization of the signal by using different aproximations to the center.
+ * It will return the result of the symmetrization that removes less peaks from the signal
+ * @param {object} signal
+ * @param {number} maxError
+ * @param {number} iteration
+ * @return {*}
+ * @private
+ */
+function symmetrizeChoiseBest(signal, maxError, iteration) {
+  var symRank1 = symmetrize(signal, maxError, iteration);
+  var tmpPeaks = signal.peaksComp;
+  var tmpMask = signal.mask;
+  var cs = signal.delta1;
+  signal.delta1 = (signal.peaks[0].x + signal.peaks[signal.peaks.length - 1].x) / 2;
+  var symRank2 = symmetrize(signal, maxError, iteration);
+  if (signal.peaksComp.length > tmpPeaks.length) {
+    return symRank2;
+  } else {
+    signal.delta1 = cs;
+    signal.peaksComp = tmpPeaks;
+    signal.mask = tmpMask;
+    return symRank1;
+  }
+}
+
+/**
+ * This function will return a set of symmetric peaks that will
+ * be the enter point for the patter compilation process.
+ * @param {object} signal
+ * @param {number} maxError
+ * @param {number} iteration
+ * @return {number}
+ * @private
+ */
+function symmetrize(signal, maxError, iteration) {
+  // Before to symmetrize we need to keep only the peaks that possibly conforms the multiplete
+  var max = void 0,
+      min = void 0,
+      avg = void 0,
+      ratio = void 0,
+      avgWidth = void 0,
+      i = void 0;
+  var peaks = new Array(signal.peaks.length);
+  // Make a deep copy of the peaks and convert PPM ot HZ
+  for (i = 0; i < peaks.length; i++) {
+    peaks[i] = {
+      x: signal.peaks[i].x * signal.observe,
+      intensity: signal.peaks[i].intensity,
+      width: signal.peaks[i].width
+    };
+  }
+  // Join the peaks that are closer than 0.25 Hz
+  for (i = peaks.length - 2; i >= 0; i--) {
+    if (Math.abs(peaks[i].x - peaks[i + 1].x) < 0.25) {
+      peaks[i].x = peaks[i].x * peaks[i].intensity + peaks[i + 1].x * peaks[i + 1].intensity;
+      peaks[i].intensity = peaks[i].intensity + peaks[i + 1].intensity;
+      peaks[i].x /= peaks[i].intensity;
+      peaks[i].intensity /= 2;
+      peaks[i].width += peaks[i + 1].width;
+      peaks.splice(i + 1, 1);
+    }
+  }
+  signal.peaksComp = peaks;
+  var nbPeaks = peaks.length;
+  var mask = new Array(nbPeaks);
+  signal.mask = mask;
+  var left = 0;
+  var right = peaks.length - 1;
+  var cs = signal.delta1 * signal.observe;
+  var middle = [(peaks[0].x + peaks[nbPeaks - 1].x) / 2, 1];
+  maxError = error(Math.abs(cs - middle[0]));
+  var heightSum = 0;
+  // We try to symmetrize the extreme peaks. We consider as candidates for symmetricing those which have
+  // ratio smaller than 3
+  for (i = 0; i < nbPeaks; i++) {
+    mask[i] = true;
+    heightSum += signal.peaks[i].intensity;
+  }
+
+  while (left <= right) {
+    mask[left] = true;
+    mask[right] = true;
+    if (left === right) {
+      if (nbPeaks > 2 && Math.abs(peaks[left].x - cs) > maxError) {
+        mask[left] = false;
+      }
+    } else {
+      max = Math.max(peaks[left].intensity, peaks[right].intensity);
+      min = Math.min(peaks[left].intensity, peaks[right].intensity);
+      ratio = max / min;
+      if (ratio > symRatio) {
+        if (peaks[left].intensity === min) {
+          mask[left] = false;
+          right++;
+        } else {
+          mask[right] = false;
+          left--;
+        }
+      } else {
+        var diffL = Math.abs(peaks[left].x - cs);
+        var diffR = Math.abs(peaks[right].x - cs);
+
+        if (Math.abs(diffL - diffR) < maxError) {
+          avg = Math.min(peaks[left].intensity, peaks[right].intensity);
+          avgWidth = Math.min(peaks[left].width, peaks[right].width);
+          peaks[left].intensity = peaks[right].intensity = avg;
+          peaks[left].width = peaks[right].width = avgWidth;
+          middle = [middle[0] + (peaks[right].x + peaks[left].x) / 2, middle[1] + 1];
+        } else {
+          if (Math.max(diffL, diffR) === diffR) {
+            mask[right] = false;
+            left--;
+          } else {
+            mask[left] = false;
+            right++;
+          }
+        }
+      }
+    }
+    left++;
+    right--;
+    // Only alter cs if it is the first iteration of the sym process.
+    if (iteration === 1) {
+      cs = chemicalShift(peaks, mask);
+      // There is not more available peaks
+      if (isNaN(cs)) {
+        return 0;
+      }
+    }
+    maxError = error(Math.abs(cs - middle[0] / middle[1]));
+  }
+  // To remove the weak peaks and recalculate the cs
+  for (i = nbPeaks - 1; i >= 0; i--) {
+    if (mask[i] === false) {
+      peaks.splice(i, 1);
+    }
+  }
+  cs = chemicalShift(peaks);
+  if (isNaN(cs)) {
+    return 0;
+  }
+  signal.delta1 = cs / signal.observe;
+  // Now, the peak should be symmetric in heights, but we need to know if it is symmetric in x
+  var symFactor = 0;
+  var weight = 0;
+  if (peaks.length > 1) {
+    for (i = Math.ceil(peaks.length / 2) - 1; i >= 0; i--) {
+      symFactor += (3 + Math.min(Math.abs(peaks[i].x - cs), Math.abs(peaks[peaks.length - 1 - i].x - cs))) / (3 + Math.max(Math.abs(peaks[i].x - cs), Math.abs(peaks[peaks.length - 1 - i].x - cs))) * peaks[i].intensity;
+      weight += peaks[i].intensity;
+    }
+    symFactor /= weight;
+  } else {
+    if (peaks.length === 1) {
+      symFactor = 1;
+    }
+  }
+  var newSumHeights = 0;
+  for (i = 0; i < peaks.length; i++) {
+    newSumHeights += peaks[i].intensity;
+  }
+  symFactor -= (heightSum - newSumHeights) / heightSum * 0.12; // Removed peaks penalty
+  // Sometimes we need a second opinion after the first symmetrization.
+  if (symFactor > 0.8 && symFactor < 0.97 && iteration < 2) {
+    return symmetrize(signal, maxErrorIter2, 2);
+  } else {
+    // Center the given pattern at cs and symmetrize x
+    if (peaks.length > 1) {
+      var dxi = void 0;
+      for (i = Math.ceil(peaks.length / 2) - 1; i >= 0; i--) {
+        dxi = (peaks[i].x - peaks[peaks.length - 1 - i].x) / 2.0;
+        peaks[i].x = cs + dxi;
+        peaks[peaks.length - 1 - i].x = cs - dxi;
+      }
+    }
+  }
+  return symFactor;
+}
+/**
+ * Error validator
+ * @param {number} value
+ * @return {number}
+ * @private
+ */
+function error(value) {
+  var maxError = value * 2.5;
+  if (maxError < 0.75) {
+    maxError = 0.75;
+  }
+  if (maxError > 3) {
+    maxError = 3;
+  }
+  return maxError;
+}
+/**
+ * @private
+ * 2 stages normalizarion of the peaks heights to Math.pow(2,n).
+ * Creates a new mask with the peaks that could contribute to the multiplete
+ * @param {object} signal
+ * @param {number} n
+ * @return {*}
+ */
+function normalize(signal, n) {
+  // Perhaps this is slow
+  var peaks = JSON.parse(JSON.stringify(signal.peaksComp));
+  var norm = 0;
+  var norm2 = 0;
+  for (var i = 0; i < peaks.length; i++) {
+    norm += peaks[i].intensity;
+  }
+  norm = Math.pow(2, n) / norm;
+  signal.mask2 = JSON.parse(JSON.stringify(signal.mask));
+
+  var index = signal.mask2.length - 1;
+  for (i = peaks.length - 1; i >= 0; i--) {
+    peaks[i].intensity *= norm;
+    while (index >= 0 && signal.mask2[index] === false) {
+      index--;
+    }
+    if (peaks[i].intensity < 0.75) {
+      peaks.splice(i, 1);
+      signal.mask2[index] = false;
+    } else {
+      norm2 += peaks[i].intensity;
+    }
+    index--;
+  }
+  norm2 = Math.pow(2, n) / norm2;
+  for (i = peaks.length - 1; i >= 0; i--) {
+    peaks[i].intensity *= norm2;
+  }
+  return peaks;
+}
+
+/**
+ * @private
+ * Calculates the chemical shift as the weighted sum of the peaks
+ * @param {Array} peaks
+ * @param {Array} mask
+ * @return {number}
+ */
+function chemicalShift(peaks, mask) {
+  var sum = 0;
+  var cs = 0;
+  var i = void 0,
+      area = void 0;
+  if (mask) {
+    for (i = 0; i < peaks.length; i++) {
+      if (mask[i] === true) {
+        area = getArea(peaks[i]);
+        sum += area;
+        cs += area * peaks[i].x;
+      }
+    }
+  } else {
+    for (i = 0; i < peaks.length; i++) {
+      area = getArea(peaks[i]);
+      sum += area;
+      cs += area * peaks[i].x;
+    }
+  }
+  return cs / sum;
+}
+
+/**
+ * Return the area of a Lorentzian function
+ * @param {object} peak - object with peak information
+ * @return {number}
+ * @private
+ */
+function getArea(peak) {
+  return Math.abs(peak.intensity * peak.width * 1.57); // 1.772453851);
+}

package/dist/third_party/peakInterval.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPeakIntervals = undefined;
+
+var _mlSavitzkyGolayGeneralized = require('ml-savitzky-golay-generalized');
+
+var _mlSavitzkyGolayGeneralized2 = _interopRequireDefault(_mlSavitzkyGolayGeneralized);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var options = {
+  sgOptions: {
+    windowSize: 9,
+    polynomial: 3
+  },
+  minMaxRatio: 0.00025,
+  broadRatio: 0.0,
+  maxCriteria: true,
+  smoothY: true,
+  realTopDetection: false,
+  heightFactor: 0,
+  boundaries: false,
+  derivativeThreshold: -1
+}; // https://github.com/mljs/global-spectral-deconvolution/blob/master/src/gsd.js
+
+var getPeakIntervals = function getPeakIntervals(entity) {
+  var data = entity.spectra[0].data[0];
+
+  var X = data.x;
+  var dX = X[1] - X[0];
+  var Y = (0, _mlSavitzkyGolayGeneralized2.default)(data.y, data.x, {
+    windowSize: options.sgOptions.windowSize,
+    polynomial: options.sgOptions.polynomial,
+    derivative: 0
+  });
+  var dY = (0, _mlSavitzkyGolayGeneralized2.default)(data.y, data.x, {
+    windowSize: options.sgOptions.windowSize,
+    polynomial: options.sgOptions.polynomial,
+    derivative: 1
+  });
+  var ddY = (0, _mlSavitzkyGolayGeneralized2.default)(data.y, data.x, {
+    windowSize: options.sgOptions.windowSize,
+    polynomial: options.sgOptions.polynomial,
+    derivative: 2
+  });
+  var maxDdy = 0;
+  var maxY = 0;
+  for (var i = 0; i < Y.length; i++) {
+    if (Math.abs(ddY[i]) > maxDdy) {
+      maxDdy = Math.abs(ddY[i]);
+    }
+    if (Math.abs(Y[i]) > maxY) {
+      maxY = Math.abs(Y[i]);
+    }
+  }
+  var lastMax = null;
+  var lastMin = null;
+  var minddY = new Array(Y.length - 2);
+  var intervalL = new Array(Y.length);
+  var intervalR = new Array(Y.length);
+  var broadMask = new Array(Y.length - 2);
+  var minddYLen = 0;
+  var intervalLLen = 0;
+  var intervalRLen = 0;
+  var broadMaskLen = 0;
+
+  for (var _i = 1; _i < Y.length - 1; ++_i) {
+    // filter based on derivativeThreshold
+    if (Math.abs(dY[_i]) > options.derivativeThreshold) {
+      // Minimum in first derivative
+      if (dY[_i] < dY[_i - 1] && dY[_i] <= dY[_i + 1] || dY[_i] <= dY[_i - 1] && dY[_i] < dY[_i + 1]) {
+        lastMin = {
+          x: X[_i],
+          index: _i
+        };
+        if (dX > 0 && lastMax !== null) {
+          intervalL[intervalLLen++] = lastMax;
+          intervalR[intervalRLen++] = lastMin;
+        }
+      }
+
+      // Maximum in first derivative
+      if (dY[_i] >= dY[_i - 1] && dY[_i] > dY[_i + 1] || dY[_i] > dY[_i - 1] && dY[_i] >= dY[_i + 1]) {
+        lastMax = {
+          x: X[_i],
+          index: _i
+        };
+        if (dX < 0 && lastMin !== null) {
+          intervalL[intervalLLen++] = lastMax;
+          intervalR[intervalRLen++] = lastMin;
+        }
+      }
+    }
+    // Minimum in second derivative
+    if (ddY[_i] < ddY[_i - 1] && ddY[_i] < ddY[_i + 1]) {
+      // TODO should we change this to have 3 arrays ? Huge overhead creating arrays
+      minddY[minddYLen++] = _i; // ( [X[i], Y[i], i] );
+      broadMask[broadMaskLen++] = Math.abs(ddY[_i]) <= options.broadRatio * maxDdy;
+    }
+  }
+  return { intervalL: intervalL, intervalR: intervalR };
+};
+
+exports.getPeakIntervals = getPeakIntervals;