{"version":3,"sources":["webpack://mlArrayXy/webpack/universalModuleDefinition","webpack://mlArrayXy/webpack/bootstrap","webpack://mlArrayXy/./packages/array-xy-closest-x/node_modules/binary-search/index.js","webpack://mlArrayXy/./packages/array-xy-closest-x/node_modules/num-sort/index.js","webpack://mlArrayXy/./packages/array-xy-max-y/node_modules/binary-search/index.js","webpack://mlArrayXy/./packages/array-xy-max-y/node_modules/num-sort/index.js","webpack://mlArrayXy/./src/index.js","webpack://mlArrayXy/./packages/array-xy-centroids-merge/src/index.js","webpack://mlArrayXy/./packages/array-xy-closest-x/src/index.js","webpack://mlArrayXy/./packages/array-xy-closest-x/node_modules/number-is-nan/index.js","webpack://mlArrayXy/./packages/array-xy-max-merge/src/index.js","webpack://mlArrayXy/./packages/array-xy-max-y/src/index.js","webpack://mlArrayXy/./packages/array-xy-max-y/node_modules/number-is-nan/index.js","webpack://mlArrayXy/./packages/array-xy-sort-x/src/index.js","webpack://mlArrayXy/./packages/array-xy-unique-x/src/index.js","webpack://mlArrayXy/./packages/array-xy-weighted-merge/src/index.js","webpack://mlArrayXy/./packages/array-xy-equally-spaced/node_modules/ml-array-sequential-fill/src/index.js","webpack://mlArrayXy/./packages/array-xy-equally-spaced/src/integral.js","webpack://mlArrayXy/./packages/array-xy-equally-spaced/src/index.js","webpack://mlArrayXy/./packages/array-xy-equally-spaced/src/getZones.js","webpack://mlArrayXy/./packages/array-xy-equally-spaced/src/equallySpacedSlot.js","webpack://mlArrayXy/./packages/array-xy-equally-spaced/src/equallySpacedSmooth.js","webpack://mlArrayXy/./packages/array-xy-filter-x/src/index.js","webpack://mlArrayXy/./packages/array-xy-filter-x/src/getZones.js"],"names":["root","factory","exports","module","define","amd","self","this","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","haystack","needle","comparator","low","high","mid","cmp","undefined","length","RangeError","numberIsNan","require","assertNum","x","TypeError","asc","a","b","desc","default","mergeByCentroids","originalPoints","centroids","_options$window","arguments","window","mergedPoints","slice","y","Array","fill","originalIndex","mergedIndex","diff","Math","abs","__webpack_exports__","closestX","binary_search__WEBPACK_IMPORTED_MODULE_0__","binary_search__WEBPACK_IMPORTED_MODULE_0___default","num_sort__WEBPACK_IMPORTED_MODULE_1__","points","options","_options$target","target","_options$reverse","reverse","index","binarySearch","Number","isNaN","maxMerge","_options$groupWidth","groupWidth","merged","maxAbscissa","size","push","maxY","_options$from","from","_options$to","to","calculateIndex","currentIndex","currentMax","MIN_VALUE","Error","concat","sortX","sortFunc","grouped","map","val","sort","response","uniqueX","current","counter","weightedMerge","weightedAbscissa","sequentialFill","input","isArray","_options","_options$size","step","floor","integral","x0","x1","slope","intercept","equallySpaced","arrayXY","xLength","_options$variant","variant","_options$numberOfPoin","numberOfPoints","_options$exclusions","exclusions","zones","_ref","filter","exclusion","JSON","parse","stringify","forEach","_ref2","toRemove","reduce","previous","unitsPerPoint","currentFrom","totalPoints","currentNbPoints","round","getZones","xResult","yResult","zone","zoneResult","processZone","output","halfStep","lastStep","start","min","max","previousX","MAX_VALUE","previousY","nextX","nextY","frontOutsideSpectra","backOutsideSpectra","currentValue","currentPoints","j","main","equallySpacedSlot","initialOriginalStep","lastOriginalStep","sumAtMin","sumAtMax","add","equallySpacedSmooth","filterX","currentZoneIndex","newX","newY","position"],"mappings":"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","file":"ml-array-xy.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"mlArrayXy\"] = factory();\n\telse\n\t\troot[\"mlArrayXy\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 4);\n","module.exports = function(haystack, needle, comparator, low, high) {\n var mid, cmp;\n\n if(low === undefined)\n low = 0;\n\n else {\n low = low|0;\n if(low < 0 || low >= haystack.length)\n throw new RangeError(\"invalid lower bound\");\n }\n\n if(high === undefined)\n high = haystack.length - 1;\n\n else {\n high = high|0;\n if(high < low || high >= haystack.length)\n throw new RangeError(\"invalid upper bound\");\n }\n\n while(low <= high) {\n /* Note that \"(low + high) >>> 1\" may overflow, and results in a typecast\n * to double (which gives the wrong results). */\n mid = low + (high - low >> 1);\n cmp = +comparator(haystack[mid], needle, mid, haystack);\n\n /* Too low. */\n if(cmp < 0.0)\n low = mid + 1;\n\n /* Too high. */\n else if(cmp > 0.0)\n high = mid - 1;\n\n /* Key found. */\n else\n return mid;\n }\n\n /* Key not found. */\n return ~low;\n}\n","'use strict';\nvar numberIsNan = require('number-is-nan');\n\nfunction assertNum(x) {\n\tif (typeof x !== 'number' || numberIsNan(x)) {\n\t\tthrow new TypeError('Expected a number');\n\t}\n}\n\nexports.asc = function (a, b) {\n\tassertNum(a);\n\tassertNum(b);\n\treturn a - b;\n};\n\nexports.desc = function (a, b) {\n\tassertNum(a);\n\tassertNum(b);\n\treturn b - a;\n};\n","module.exports = function(haystack, needle, comparator, low, high) {\n var mid, cmp;\n\n if(low === undefined)\n low = 0;\n\n else {\n low = low|0;\n if(low < 0 || low >= haystack.length)\n throw new RangeError(\"invalid lower bound\");\n }\n\n if(high === undefined)\n high = haystack.length - 1;\n\n else {\n high = high|0;\n if(high < low || high >= haystack.length)\n throw new RangeError(\"invalid upper bound\");\n }\n\n while(low <= high) {\n /* Note that \"(low + high) >>> 1\" may overflow, and results in a typecast\n * to double (which gives the wrong results). */\n mid = low + (high - low >> 1);\n cmp = +comparator(haystack[mid], needle, mid, haystack);\n\n /* Too low. */\n if(cmp < 0.0)\n low = mid + 1;\n\n /* Too high. */\n else if(cmp > 0.0)\n high = mid - 1;\n\n /* Key found. */\n else\n return mid;\n }\n\n /* Key not found. */\n return ~low;\n}\n","'use strict';\nvar numberIsNan = require('number-is-nan');\n\nfunction assertNum(x) {\n\tif (typeof x !== 'number' || numberIsNan(x)) {\n\t\tthrow new TypeError('Expected a number');\n\t}\n}\n\nexports.asc = function (a, b) {\n\tassertNum(a);\n\tassertNum(b);\n\treturn a - b;\n};\n\nexports.desc = function (a, b) {\n\tassertNum(a);\n\tassertNum(b);\n\treturn b - a;\n};\n","export {\n default as centroidsMerge\n} from '../packages/array-xy-centroids-merge/src';\nexport { default as closestX } from '../packages/array-xy-closest-x/src';\nexport { default as maxMerge } from '../packages/array-xy-max-merge/src';\nexport { default as maxY } from '../packages/array-xy-max-y/src';\nexport { default as sortX } from '../packages/array-xy-sort-x/src';\nexport { default as uniqueX } from '../packages/array-xy-unique-x/src';\nexport { default as filterX } from '../packages/array-xy-filter-x/src';\nexport {\n default as equallySpaced\n} from '../packages/array-xy-equally-spaced/src';\nexport {\n default as weightedMerge\n} from '../packages/array-xy-weighted-merge/src';\n","/**\n * Merge abscissa values if the ordinate value is in a list of centroids\n * @param {object} originalPoints\n * @param {Array} originalPoints.x\n * @param {Array} originalPoints.y\n * @param {Array} centroids\n * @param {object} [options]\n * @param {number} [options.window = 0.01] - has to be a positive number\n * @return {{x: Array, y: Array}}\n */\nexport default function mergeByCentroids(\n originalPoints,\n centroids,\n options = {}\n) {\n const { window = 0.01 } = options;\n\n var mergedPoints = {\n x: centroids.slice(),\n y: new Array(centroids.length).fill(0)\n };\n\n var originalIndex = 0;\n var mergedIndex = 0;\n while (\n originalIndex < originalPoints.x.length &&\n mergedIndex < centroids.length\n ) {\n var diff = originalPoints.x[originalIndex] - centroids[mergedIndex];\n if (Math.abs(diff) < window) {\n mergedPoints.y[mergedIndex] += originalPoints.y[originalIndex++];\n } else if (diff < 0) {\n originalIndex++;\n } else {\n mergedIndex++;\n }\n }\n\n return mergedPoints;\n}\n","import binarySearch from 'binary-search';\nimport { asc, desc } from 'num-sort';\n\n/**\n *\n * @param {object} points\n * @param {Array} originalPoints.x\n * @param {Array} originalPoints.y\n * @param {*} options\n * @return {{x: Array, y: Array}}\n */\nexport default function closestX(points, options) {\n const { x, y } = points;\n const { target = x[0], reverse = false } = options;\n\n let index;\n if (reverse) {\n index = binarySearch(x, target, desc);\n } else {\n index = binarySearch(x, target, asc);\n }\n\n if (index >= 0) {\n return {\n x: x[index],\n y: y[index]\n };\n } else {\n index = ~index;\n if (\n (index !== 0 && Math.abs(x[index] - target) > 0.5) ||\n index === x.length\n ) {\n return {\n x: x[index - 1],\n y: y[index - 1]\n };\n } else {\n return {\n x: x[index],\n y: y[index]\n };\n }\n }\n}\n","'use strict';\nmodule.exports = Number.isNaN || function (x) {\n\treturn x !== x;\n};\n","/**\n * Merge abscissas values on similar ordinates and weight the group of abscissas\n * @param {object} points\n * @param {Array} points.x - sorted abscissas values\n * @param {Array} points.y - ordinates values\n * @param {object} [options]\n * @param {number} [options.groupWidth = 0.001] - window for abscissas to merge\n * @return {{x: Array, y: Array}}\n */\nexport default function maxMerge(points, options = {}) {\n const { x, y } = points;\n const { groupWidth = 0.001 } = options;\n\n var merged = { x: [], y: [] };\n var maxAbscissa = { x: [], y: [] };\n var size = 0;\n var index = 0;\n\n while (index < x.length) {\n if (size === 0 || x[index] - merged.x[size - 1] > groupWidth) {\n maxAbscissa.x.push(x[index]);\n maxAbscissa.y.push(y[index]);\n merged.x.push(x[index]);\n merged.y.push(y[index]);\n index++;\n size++;\n } else {\n if (y[index] > maxAbscissa.y[size - 1]) {\n maxAbscissa.x[size - 1] = x[index];\n maxAbscissa.y[size - 1] = y[index];\n }\n merged.x[size - 1] = x[index];\n merged.y[size - 1] += y[index];\n index++;\n }\n }\n\n merged.x = maxAbscissa.x.slice();\n\n return merged;\n}\n","import binarySearch from 'binary-search';\nimport { asc, desc } from 'num-sort';\n\n/**\n * @param {object} points\n * @param {Array} points.x - sorted abscissas values\n * @param {Array} points.y - ordinates values\n * @param {object} [options]\n * @param {object} [options.from = {index: 0}]\n * @param {object} [options.to = {index: x.length-1}]\n * @param {boolean} [options.reverse = false]\n * @return {{index: number, value: number}}\n */\nexport default function maxY(points, options = {}) {\n const { x, y } = points;\n let {\n from = { index: 0 },\n to = { index: x.length },\n reverse = false\n } = options;\n\n if (from.value !== undefined && from.index === undefined) {\n from.index = calculateIndex(from.value, x, reverse);\n }\n\n if (to.value !== undefined && to.index === undefined) {\n to.index = calculateIndex(to.value, x, reverse);\n }\n\n var currentMax = Number.MIN_VALUE;\n var currentIndex;\n for (var i = from.index; i < to.index; i++) {\n if (currentMax < y[i]) {\n currentMax = y[i];\n currentIndex = i;\n }\n }\n\n return {\n index: currentIndex,\n value: currentMax\n };\n}\n\n/**\n * @param {number} value\n * @param {Array} x\n * @param {boolean} reverse\n * @return {number} index of the value in the array\n */\nfunction calculateIndex(value, x, reverse) {\n let index;\n if (reverse) {\n index = binarySearch(x, value, desc);\n } else {\n index = binarySearch(x, value, asc);\n }\n\n if (index < 0) {\n throw new Error(`the value ${value} doesn't belongs to the abscissa value`);\n }\n\n return index;\n}\n","'use strict';\nmodule.exports = Number.isNaN || function (x) {\n\treturn x !== x;\n};\n","export default function sortX(points, options = {}) {\n const { x, y } = points;\n const { reverse = false } = options;\n\n var sortFunc;\n if (!reverse) {\n sortFunc = (a, b) => a.x - b.x;\n } else {\n sortFunc = (a, b) => b.x - a.x;\n }\n\n var grouped = x\n .map((val, index) => ({\n x: val,\n y: y[index]\n }))\n .sort(sortFunc);\n\n var response = { x: x.slice(), y: y.slice() };\n for (var i = 0; i < x.length; i++) {\n response.x[i] = grouped[i].x;\n response.y[i] = grouped[i].y;\n }\n\n return response;\n}\n","\n/**\n * In place modification of the 2 arrays to make X unique and sum the Y if X has the same value\n * @param {object} [points={}] : Object of points contains property x (an array) and y (an array)\n * @return points\n */\n\nexport default function uniqueX(points = {}) {\n const { x, y } = points;\n if (x.length < 2) return;\n if (x.length !== y.length) {\n throw new Error('The X and Y arrays mush have the same length');\n }\n\n let current = x[0];\n let counter = 0;\n\n for (let i = 1; i < x.length; i++) {\n if (current !== x[i]) {\n counter++;\n current = x[i];\n x[counter] = x[i];\n if (i !== counter) {\n y[counter] = 0;\n }\n }\n if (i !== counter) {\n y[counter] += y[i];\n }\n }\n\n x.length = counter + 1;\n y.length = counter + 1;\n}\n","/**\n * Merge abscissas values on similar ordinates and weight the group of abscissas\n * @param {object} points\n * @param {Array} points.x - sorted abscissas values\n * @param {Array} points.y - ordinates values\n * @param {object} [options]\n * @param {number} [options.groupWidth = 0.001] - window for abscissas to merge\n * @return {{x: Array, y: Array}}\n */\nexport default function weightedMerge(points, options = {}) {\n const { x, y } = points;\n const { groupWidth = 0.001 } = options;\n\n var merged = { x: [], y: [] };\n var weightedAbscissa = { x: [], y: [] };\n var size = 0;\n var index = 0;\n\n while (index < x.length) {\n if (size === 0 || x[index] - merged.x[size - 1] > groupWidth) {\n weightedAbscissa.x.push(x[index] * y[index]);\n weightedAbscissa.y.push(y[index]);\n merged.x.push(x[index]);\n merged.y.push(y[index]);\n index++;\n size++;\n } else {\n weightedAbscissa.x[size - 1] += x[index] * y[index];\n weightedAbscissa.y[size - 1] += y[index];\n merged.x[size - 1] = x[index];\n merged.y[size - 1] += y[index];\n index++;\n }\n }\n\n for (var i = 0; i < merged.x.length; i++) {\n merged.x[i] = weightedAbscissa.x[i] / weightedAbscissa.y[i];\n }\n\n return merged;\n}\n","/**\n * Fill an array with sequential numbers\n * @param {Array} [input] - optional destination array (if not provided a new array will be created)\n * @param {object} [options={}]\n * @param {number} [options.from=0] - first value in the array\n * @param {number} [options.to=10] - last value in the array\n * @param {number} [options.size=input.length] - size of the array (if not provided calculated from step)\n * @param {number} [options.step] - if not provided calculated from size\n * @return {Array}\n */\nexport default function sequentialFill(input = [], options = {}) {\n if (typeof input === 'object' && !Array.isArray(input)) {\n options = input;\n input = [];\n }\n\n if (!Array.isArray(input)) {\n throw new Error('input must be an array');\n }\n\n let {\n from = 0,\n to = 10,\n size = input.length,\n step\n } = options;\n\n if (size && step) {\n size = 0;\n }\n\n if (!size) {\n if (step) {\n size = Math.floor((to - from) / step) + 1;\n } else {\n size = to - from + 1;\n }\n }\n if (!step && size) {\n step = (to - from) / (size - 1);\n }\n\n input.length = 0;\n for (var i = 0; i < size; i++) {\n input.push(from);\n from += step;\n }\n\n return input;\n}\n","/**\n * Function that calculates the integral of the line between two\n * x-coordinates, given the slope and intercept of the line.\n * @param {number} x0\n * @param {number} x1\n * @param {number} slope\n * @param {number} intercept\n * @return {number} integral value.\n */\nexport default function integral(x0, x1, slope, intercept) {\n return (\n 0.5 * slope * x1 * x1 +\n intercept * x1 -\n (0.5 * slope * x0 * x0 + intercept * x0)\n );\n}\n","import sequentialFill from 'ml-array-sequential-fill';\n\nimport equallySpacedSmooth from './equallySpacedSmooth';\nimport equallySpacedSlot from './equallySpacedSlot';\nimport getZones from './getZones';\n\n/**\n * Function that returns a Number array of equally spaced numberOfPoints\n * containing a representation of intensities of the spectra arguments x\n * and y.\n *\n * The options parameter contains an object in the following form:\n * from: starting point\n * to: last point\n * numberOfPoints: number of points between from and to\n * variant: \"slot\" or \"smooth\" - smooth is the default option\n *\n * The slot variant consist that each point in the new array is calculated\n * averaging the existing points between the slot that belongs to the current\n * value. The smooth variant is the same but takes the integral of the range\n * of the slot and divide by the step size between two points in the new array.\n *\n * @param {object} [arrayXY={}] - object containing 2 properties x and y (both an array)\n * @param {object} [options={}]\n * @param {number} [options.from=x[0]]\n * @param {number} [options.to=x[x.length-1]]\n * @param {string} [options.variant='smooth']\n * @param {number} [options.numberOfPoints=100]\n * @param {Array} [options.exclusions=[]] array of from / to that should be skipped for the generation of the points\n * @return {object} new object with x / y array with the equally spaced data.\n */\n\nexport default function equallySpaced(arrayXY = {}, options = {}) {\n let { x, y } = arrayXY;\n let xLength = x.length;\n let reverse = false;\n if (x.length > 1 && x[0] > x[1]) {\n x = x.slice().reverse();\n y = y.slice().reverse();\n reverse = true;\n }\n\n let {\n from = x[0],\n to = x[xLength - 1],\n variant = 'smooth',\n numberOfPoints = 100,\n exclusions = []\n } = options;\n\n if (xLength !== y.length) {\n throw new RangeError(\"the x and y vector doesn't have the same size.\");\n }\n\n if (typeof from !== 'number' || isNaN(from)) {\n throw new RangeError(\"'from' option must be a number\");\n }\n\n if (typeof to !== 'number' || isNaN(to)) {\n throw new RangeError(\"'to' option must be a number\");\n }\n\n if (typeof numberOfPoints !== 'number' || isNaN(numberOfPoints)) {\n throw new RangeError(\"'numberOfPoints' option must be a number\");\n }\n\n let zones = getZones(from, to, numberOfPoints, exclusions);\n\n let xResult = [];\n let yResult = [];\n for (let zone of zones) {\n let zoneResult = processZone(\n x,\n y,\n zone.from,\n zone.to,\n zone.numberOfPoints,\n variant,\n reverse\n );\n xResult.push(...zoneResult.x);\n yResult.push(...zoneResult.y);\n }\n\n if (reverse) {\n if (from < to) {\n return { x: xResult.reverse(), y: yResult.reverse() };\n } else {\n return { x: xResult, y: yResult };\n }\n } else {\n if (from < to) {\n return { x: xResult, y: yResult };\n } else {\n return { x: xResult.reverse(), y: yResult.reverse() };\n }\n }\n}\n\nfunction processZone(x, y, from, to, numberOfPoints, variant) {\n if (numberOfPoints < 1) {\n throw new RangeError('the number of points must be at least 1');\n }\n\n var output =\n variant === 'slot'\n ? equallySpacedSlot(x, y, from, to, numberOfPoints)\n : equallySpacedSmooth(x, y, from, to, numberOfPoints);\n\n return {\n x: sequentialFill({\n from,\n to,\n size: numberOfPoints\n }),\n y: output\n };\n}\n","export default function getZones(from, to, numberOfPoints, exclusions = []) {\n if (from > to) {\n [from, to] = [to, from];\n }\n\n // in exclusions from and to have to be defined\n exclusions = exclusions.filter(\n (exclusion) => exclusion.from !== undefined && exclusion.to !== undefined\n );\n\n exclusions = JSON.parse(JSON.stringify(exclusions));\n // we ensure that from before to\n exclusions.forEach((exclusion) => {\n if (exclusion.from > exclusion.to) {\n [exclusion.to, exclusion.from] = [exclusion.from, exclusion.to];\n }\n });\n\n exclusions.sort((a, b) => a.from - b.from);\n\n // we will rework the exclusions in order to remove overlap and outside range (from / to)\n exclusions.forEach((exclusion) => {\n if (exclusion.from < from) exclusion.from = from;\n if (exclusion.to > to) exclusion.to = to;\n });\n for (let i = 0; i < exclusions.length - 1; i++) {\n if (exclusions[i].to > exclusions[i + 1].from) {\n exclusions[i].to = exclusions[i + 1].from;\n }\n }\n exclusions = exclusions.filter((exclusion) => exclusion.from < exclusion.to);\n\n if (!exclusions || exclusions.length === 0) {\n return [{ from, to, numberOfPoints }];\n }\n\n // need to deal with overlapping exclusions and out of bound exclusions\n\n let toRemove = exclusions.reduce(\n (previous, exclusion) => (previous += exclusion.to - exclusion.from),\n 0\n );\n let total = to - from;\n let unitsPerPoint = (total - toRemove) / numberOfPoints;\n let zones = [];\n let currentFrom = from;\n let totalPoints = 0;\n for (let exclusion of exclusions) {\n let currentNbPoints = Math.round(\n (exclusion.from - currentFrom) / unitsPerPoint\n );\n totalPoints += currentNbPoints;\n if (currentNbPoints > 0) {\n zones.push({\n from: currentFrom,\n to: exclusion.from,\n numberOfPoints: currentNbPoints\n });\n }\n\n currentFrom = exclusion.to;\n }\n if (numberOfPoints - totalPoints > 0) {\n zones.push({\n from: currentFrom,\n to: to,\n numberOfPoints: numberOfPoints - totalPoints\n });\n }\n\n return zones;\n}\n","/**\n * function that retrieves the getEquallySpacedData with the variant \"slot\"\n *\n * @param {Array} x\n * @param {Array} y\n * @param {number} from - Initial point\n * @param {number} to - Final point\n * @param {number} numberOfPoints\n * @return {Array} - Array of y's equally spaced with the variant \"slot\"\n */\nexport default function equallySpacedSlot(x, y, from, to, numberOfPoints) {\n var xLength = x.length;\n\n var step = (to - from) / (numberOfPoints - 1);\n var halfStep = step / 2;\n var lastStep = x[x.length - 1] - x[x.length - 2];\n\n var start = from - halfStep;\n var output = new Array(numberOfPoints);\n\n // Init main variables\n var min = start;\n var max = start + step;\n\n var previousX = -Number.MAX_VALUE;\n var previousY = 0;\n var nextX = x[0];\n var nextY = y[0];\n var frontOutsideSpectra = 0;\n var backOutsideSpectra = true;\n\n var currentValue = 0;\n\n // for slot algorithm\n var currentPoints = 0;\n\n var i = 1; // index of input\n var j = 0; // index of output\n\n main: while (true) {\n if (previousX >= nextX) throw new Error('x must be an increasing serie');\n while (previousX - max > 0) {\n // no overlap with original point, just consume current value\n if (backOutsideSpectra) {\n currentPoints++;\n backOutsideSpectra = false;\n }\n\n output[j] = currentPoints <= 0 ? 0 : currentValue / currentPoints;\n j++;\n\n if (j === numberOfPoints) {\n break main;\n }\n\n min = max;\n max += step;\n currentValue = 0;\n currentPoints = 0;\n }\n\n if (previousX > min) {\n currentValue += previousY;\n currentPoints++;\n }\n\n if (previousX === -Number.MAX_VALUE || frontOutsideSpectra > 1) {\n currentPoints--;\n }\n\n previousX = nextX;\n previousY = nextY;\n\n if (i < xLength) {\n nextX = x[i];\n nextY = y[i];\n i++;\n } else {\n nextX += lastStep;\n nextY = 0;\n frontOutsideSpectra++;\n }\n }\n\n return output;\n}\n","import integral from './integral';\n\n/**\n * function that retrieves the getEquallySpacedData with the variant \"smooth\"\n *\n * @param {Array} x\n * @param {Array} y\n * @param {number} from - Initial point\n * @param {number} to - Final point\n * @param {number} numberOfPoints\n * @return {Array} - Array of y's equally spaced with the variant \"smooth\"\n */\nexport default function equallySpacedSmooth(x, y, from, to, numberOfPoints) {\n var xLength = x.length;\n\n var step = (to - from) / (numberOfPoints - 1);\n var halfStep = step / 2;\n\n var output = new Array(numberOfPoints);\n\n var initialOriginalStep = x[1] - x[0];\n var lastOriginalStep = x[xLength - 1] - x[xLength - 2];\n\n // Init main variables\n var min = from - halfStep;\n var max = from + halfStep;\n\n var previousX = Number.MIN_VALUE;\n var previousY = 0;\n var nextX = x[0] - initialOriginalStep;\n var nextY = 0;\n\n var currentValue = 0;\n var slope = 0;\n var intercept = 0;\n var sumAtMin = 0;\n var sumAtMax = 0;\n\n var i = 0; // index of input\n var j = 0; // index of output\n\n function getSlope(x0, y0, x1, y1) {\n return (y1 - y0) / (x1 - x0);\n }\n\n main: while (true) {\n if (previousX <= min && min <= nextX) {\n add = integral(0, min - previousX, slope, previousY);\n sumAtMin = currentValue + add;\n }\n\n while (nextX - max >= 0) {\n // no overlap with original point, just consume current value\n var add = integral(0, max - previousX, slope, previousY);\n sumAtMax = currentValue + add;\n\n output[j++] = (sumAtMax - sumAtMin) / step;\n\n if (j === numberOfPoints) {\n break main;\n }\n\n min = max;\n max += step;\n sumAtMin = sumAtMax;\n }\n\n currentValue += integral(previousX, nextX, slope, intercept);\n\n previousX = nextX;\n previousY = nextY;\n\n if (i < xLength) {\n nextX = x[i];\n nextY = y[i];\n i++;\n } else if (i === xLength) {\n nextX += lastOriginalStep;\n nextY = 0;\n }\n\n slope = getSlope(previousX, previousY, nextX, nextY);\n intercept = -slope * previousX + previousY;\n }\n\n return output;\n}\n","import getZones from './getZones';\n\n/**\n * Filter an array x/y based on various criteria\n * x points are expected to be sorted\n *\n * @param {object} points\n * @param {object} [options={}]\n * @param {array} [options.from]\n * @param {array} [options.to]\n * @param {array} [options.exclusions=[]]\n * @return {{x: Array, y: Array}}\n */\n\nexport default function filterX(points, options = {}) {\n const { x, y } = points;\n const { from = x[0], to = x[x.length - 1], exclusions = [] } = options;\n\n let zones = getZones(from, to, exclusions);\n\n\n let currentZoneIndex = 0;\n let newX = [];\n let newY = [];\n let position = 0;\n while (position < x.length) {\n if (\n x[position] <= zones[currentZoneIndex].to &&\n x[position] >= zones[currentZoneIndex].from\n ) {\n newX.push(x[position]);\n newY.push(y[position]);\n } else {\n if (x[position] > zones[currentZoneIndex].to) {\n currentZoneIndex++;\n if (!zones[currentZoneIndex]) break;\n }\n }\n position++;\n }\n\n return {\n x: newX,\n y: newY\n };\n}\n","export default function getZones(from, to, exclusions = []) {\n if (from > to) {\n [from, to] = [to, from];\n }\n\n // in exclusions from and to have to be defined\n exclusions = exclusions.filter(\n (exclusion) => exclusion.from !== undefined && exclusion.to !== undefined\n );\n\n exclusions = JSON.parse(JSON.stringify(exclusions));\n // we ensure that from before to\n exclusions.forEach((exclusion) => {\n if (exclusion.from > exclusion.to) {\n [exclusion.to, exclusion.from] = [exclusion.from, exclusion.to];\n }\n });\n\n exclusions.sort((a, b) => a.from - b.from);\n\n // we will rework the exclusions in order to remove overlap and outside range (from / to)\n exclusions.forEach((exclusion) => {\n if (exclusion.from < from) exclusion.from = from;\n if (exclusion.to > to) exclusion.to = to;\n });\n for (let i = 0; i < exclusions.length - 1; i++) {\n if (exclusions[i].to > exclusions[i + 1].from) {\n exclusions[i].to = exclusions[i + 1].from;\n }\n }\n exclusions = exclusions.filter((exclusion) => exclusion.from < exclusion.to);\n\n if (!exclusions || exclusions.length === 0) {\n return [{ from, to }];\n }\n\n let zones = [];\n let currentFrom = from;\n for (let exclusion of exclusions) {\n if (currentFrom < exclusion.from) {\n zones.push({\n from: currentFrom,\n to: exclusion.from\n });\n }\n\n currentFrom = exclusion.to;\n }\n if (currentFrom < to) {\n zones.push({\n from: currentFrom,\n to: to\n });\n }\n\n return zones;\n}\n"],"sourceRoot":""}