{"version":3,"file":"ml-direct.min.js","sources":["../node_modules/is-any-array/lib-esm/index.js","../node_modules/ml-spectra-processing/lib-esm/x/xCheck.js","../node_modules/ml-spectra-processing/lib-esm/x/xFindClosestIndex.js","../node_modules/ml-spectra-processing/lib-esm/x/xGetFromToIndex.js","../node_modules/ml-spectra-processing/lib-esm/x/xMaxValue.js","../node_modules/ml-spectra-processing/lib-esm/x/xMinValue.js","../node_modules/ml-spectra-processing/lib-esm/x/xNorm.js","../src/util/antiLowerConvexHull.js","../src/index.js"],"sourcesContent":["const toString = Object.prototype.toString;\n/**\n * Checks if an object is an instance of an Array (array or typed array).\n *\n * @param {any} value - Object to check.\n * @returns {boolean} True if the object is an array.\n */\nexport function isAnyArray(value) {\n    return toString.call(value).endsWith('Array]');\n}\n//# sourceMappingURL=index.js.map","import { isAnyArray } from 'is-any-array';\n/**\n * Checks if input is of type array\n *\n * @param input - input\n */\nexport function xCheck(input, options = {}) {\n    const { minLength } = options;\n    if (!isAnyArray(input)) {\n        throw new TypeError('input must be an array');\n    }\n    if (input.length === 0) {\n        throw new TypeError('input must not be empty');\n    }\n    //@ts-expect-error we already checked that input is an array\n    if (minLength && input.length < minLength) {\n        throw new Error(`input must have a length of at least ${minLength}`);\n    }\n}\n//# sourceMappingURL=xCheck.js.map","/**\n * Returns the closest index of a `target`\n *\n * @param array - array of numbers\n * @param target - target\n * @returns - closest index\n */\nexport function xFindClosestIndex(array, target, options = {}) {\n    const { sorted = true } = options;\n    if (sorted) {\n        let low = 0;\n        let high = array.length - 1;\n        let middle = 0;\n        while (high - low > 1) {\n            middle = low + ((high - low) >> 1);\n            if (array[middle] < target) {\n                low = middle;\n            }\n            else if (array[middle] > target) {\n                high = middle;\n            }\n            else {\n                return middle;\n            }\n        }\n        if (low < array.length - 1) {\n            if (Math.abs(target - array[low]) < Math.abs(array[low + 1] - target)) {\n                return low;\n            }\n            else {\n                return low + 1;\n            }\n        }\n        else {\n            return low;\n        }\n    }\n    else {\n        let index = 0;\n        let diff = Number.POSITIVE_INFINITY;\n        for (let i = 0; i < array.length; i++) {\n            const currentDiff = Math.abs(array[i] - target);\n            if (currentDiff < diff) {\n                diff = currentDiff;\n                index = i;\n            }\n        }\n        return index;\n    }\n}\n//# sourceMappingURL=xFindClosestIndex.js.map","import { xFindClosestIndex } from './xFindClosestIndex';\n/**\n * Returns an object with {fromIndex, toIndex} for a specific from / to\n *\n * @param x - array of numbers\n * @param options - Options\n */\nexport function xGetFromToIndex(x, options = {}) {\n    let { fromIndex, toIndex, from, to } = options;\n    if (fromIndex === undefined) {\n        if (from !== undefined) {\n            fromIndex = xFindClosestIndex(x, from);\n        }\n        else {\n            fromIndex = 0;\n        }\n    }\n    if (toIndex === undefined) {\n        if (to !== undefined) {\n            toIndex = xFindClosestIndex(x, to);\n        }\n        else {\n            toIndex = x.length - 1;\n        }\n    }\n    if (fromIndex < 0)\n        fromIndex = 0;\n    if (toIndex < 0)\n        toIndex = 0;\n    if (fromIndex >= x.length)\n        fromIndex = x.length - 1;\n    if (toIndex >= x.length)\n        toIndex = x.length - 1;\n    if (fromIndex > toIndex)\n        [fromIndex, toIndex] = [toIndex, fromIndex];\n    return { fromIndex, toIndex };\n}\n//# sourceMappingURL=xGetFromToIndex.js.map","import { xCheck } from './xCheck';\nimport { xGetFromToIndex } from './xGetFromToIndex';\n/**\n * Computes the maximal value of an array of values\n *\n * @param array - array of numbers\n * @param options - options\n */\nexport function xMaxValue(array, options = {}) {\n    xCheck(array);\n    const { fromIndex, toIndex } = xGetFromToIndex(array, options);\n    let maxValue = array[fromIndex];\n    for (let i = fromIndex + 1; i <= toIndex; i++) {\n        if (array[i] > maxValue) {\n            maxValue = array[i];\n        }\n    }\n    return maxValue;\n}\n//# sourceMappingURL=xMaxValue.js.map","import { xCheck } from './xCheck';\nimport { xGetFromToIndex } from './xGetFromToIndex';\n/**\n * Computes the minimal value of an array of values\n *\n * @param array - array of numbers\n * @param options - options\n */\nexport function xMinValue(array, options = {}) {\n    xCheck(array);\n    const { fromIndex, toIndex } = xGetFromToIndex(array, options);\n    let minValue = array[fromIndex];\n    for (let i = fromIndex + 1; i <= toIndex; i++) {\n        if (array[i] < minValue) {\n            minValue = array[i];\n        }\n    }\n    return minValue;\n}\n//# sourceMappingURL=xMinValue.js.map","/**\n * This function calculate the norm of a vector\n *\n * @example xNorm([3, 4]) -> 5\n * @param array - array\n * @returns - calculated norm\n */\nexport function xNorm(array) {\n    let result = 0;\n    for (const element of array) {\n        result += element ** 2;\n    }\n    return Math.sqrt(result);\n}\n//# sourceMappingURL=xNorm.js.map","/**\n * Preparata, F. P., & Shamos, M. I. (2012). Computational geometry: an introduction. Springer Science & Business Media.\n * @param {Array} x - The array with x coordinates of the points.\n * @param {Array} y - The array with y coordinates of the points.\n * @return {Array} The indices of the points of anticlockwise lower convex hull\n * @private\n */\nexport default function antiLowerConvexHull(x, y) {\n  if (x.length !== y.length) {\n    throw new RangeError('X and Y vectors has different dimensions');\n  }\n\n  const nbPoints = x.length - 1;\n  if (nbPoints === 0) return [0];\n  if (nbPoints === 1) return [0, 1];\n\n  let currentPoint = 0;\n  let result = new Array(x.length).fill(true);\n  while (true) {\n    const a = currentPoint;\n    const b = moveOn(currentPoint, nbPoints, result);\n    const c = moveOn(moveOn(currentPoint, nbPoints, result), nbPoints, result);\n\n    const det =\n      x[c] * (y[a] - y[b]) + x[a] * (y[b] - y[c]) + x[b] * (y[c] - y[a]);\n\n    const leftTurn = det >= 0;\n\n    if (leftTurn) {\n      currentPoint = b;\n    } else {\n      result[b] = false;\n      currentPoint = moveBack(currentPoint, nbPoints, result);\n    }\n    if (c === nbPoints) break;\n  }\n\n  return result\n    .map((item, index) => (item === false ? false : index))\n    .filter((item) => item !== false);\n}\n\n/**\n * @param {number} currentPoint - The index of the current point to make the move\n * @param {number} nbPoints - The total number of points in the array\n * @param {Array} vector - The array with the points\n * @return {number} the index of the point after the move\n * @private\n */\n\nfunction moveBack(currentPoint, nbPoints, vector) {\n  let counter = currentPoint - 1;\n  while (vector[counter] === false) counter--;\n  return currentPoint === 0 ? nbPoints : counter;\n}\n\nfunction moveOn(currentPoint, nbPoints, vector) {\n  let counter = currentPoint + 1;\n  while (vector[counter] === false) counter++;\n  return currentPoint === nbPoints ? 0 : counter;\n}\n","import { xNorm, xMaxValue, xMinValue } from 'ml-spectra-processing';\n\nimport antiLowerConvexHull from './util/antiLowerConvexHull';\n\n/**\n * Performs a global optimization of required parameters\n * It will return an object containing:\n * - `minFunctionValue`: The minimum value found for the objetive function\n * - `optima`: Array of Array of values for all the variables where the function reach its minimum value\n * - `iterations`: Number of iterations performed in the process\n * - `finalState`: Internal state allowing to continue optimization (initialState)\n * @param {function} objectiveFunction Function to evaluate. It should accept an array of variables\n * @param {Array} lowerBoundaries Array containing for each variable the lower boundary\n * @param {Array} upperBoundaries Array containing for each variable the higher boundary\n * @param {Object} [options={}]\n * @param {number} [options.iterations] - Number of iterations.\n * @param {number} [options.epsilon] - Tolerance to choose best current value.\n * @param {number} [options.tolerance] - Minimum tollerance of the function.\n * @param {number} [options.tolerance2] - Minimum tollerance of the function.\n * @param {Object} [options.initialState={}}] - finalState of previous optimization.\n * @return {Object} {finalState, iterations, minFunctionValue}\n * */\n\nexport default function direct(\n  objectiveFunction,\n  lowerBoundaries,\n  upperBoundaries,\n  options = {},\n) {\n  const {\n    iterations = 50,\n    epsilon = 1e-4,\n    tolerance = 1e-16,\n    tolerance2 = 1e-12,\n    initialState = {},\n  } = options;\n\n  if (\n    objectiveFunction === undefined ||\n    lowerBoundaries === undefined ||\n    upperBoundaries === undefined\n  ) {\n    throw new RangeError('There is something undefined');\n  }\n\n  lowerBoundaries = new Float64Array(lowerBoundaries);\n  upperBoundaries = new Float64Array(upperBoundaries);\n\n  if (lowerBoundaries.length !== upperBoundaries.length) {\n    throw new Error(\n      'Lower bounds and Upper bounds for x are not of the same length',\n    );\n  }\n\n  //-------------------------------------------------------------------------\n  //                        STEP 1. Initialization\n  //-------------------------------------------------------------------------\n  let n = lowerBoundaries.length;\n  let diffBorders = upperBoundaries.map((x, i) => x - lowerBoundaries[i]);\n\n  let {\n    numberOfRectangles = 0,\n    totalIterations = 0,\n    unitaryCoordinates = [new Float64Array(n).fill(0.5)],\n    middlePoint = new Float64Array(n).map((value, index) => {\n      return (\n        lowerBoundaries[index] +\n        unitaryCoordinates[0][index] * diffBorders[index]\n      );\n    }),\n    bestCurrentValue = objectiveFunction(middlePoint),\n    fCalls = 1,\n    smallerDistance = 0,\n    edgeSizes = [new Float64Array(n).fill(0.5)],\n    diagonalDistances = [Math.sqrt(n * Math.pow(0.5, 2))],\n    functionValues = [bestCurrentValue],\n    differentDistances = diagonalDistances,\n    smallerValuesByDistance = [bestCurrentValue],\n    choiceLimit = undefined,\n  } = initialState;\n  if (\n    initialState.originalCoordinates &&\n    initialState.originalCoordinates.length > 0\n  ) {\n    bestCurrentValue = xMinValue(functionValues);\n    choiceLimit =\n      epsilon * Math.abs(bestCurrentValue) > 1e-8\n        ? epsilon * Math.abs(bestCurrentValue)\n        : 1e-8;\n\n    smallerDistance = getMinIndex(\n      functionValues,\n      diagonalDistances,\n      choiceLimit,\n      bestCurrentValue,\n    );\n\n    unitaryCoordinates = initialState.originalCoordinates.slice();\n    for (let j = 0; j < unitaryCoordinates.length; j++) {\n      for (let i = 0; i < lowerBoundaries.length; i++) {\n        unitaryCoordinates[j][i] =\n          (unitaryCoordinates[j][i] - lowerBoundaries[i]) / diffBorders[i];\n      }\n    }\n  }\n\n  let iteration = 0;\n  //-------------------------------------------------------------------------\n  //                          Iteration loop\n  //-------------------------------------------------------------------------\n\n  while (iteration < iterations) {\n    //----------------------------------------------------------------------\n    //  STEP 2. Identify the set S of all potentially optimal rectangles\n    //----------------------------------------------------------------------\n\n    let S1 = [];\n    let idx = differentDistances.findIndex(\n      // eslint-disable-next-line no-loop-func\n      (e) => e === diagonalDistances[smallerDistance],\n    );\n    let counter = 0;\n    for (let i = idx; i < differentDistances.length; i++) {\n      for (let f = 0; f < functionValues.length; f++) {\n        if (\n          (functionValues[f] === smallerValuesByDistance[i]) &\n          (diagonalDistances[f] === differentDistances[i])\n        ) {\n          S1[counter++] = f;\n        }\n      }\n    }\n\n    let optimumValuesIndex, S3;\n    if (differentDistances.length - idx > 1) {\n      let a1 = diagonalDistances[smallerDistance];\n      let b1 = functionValues[smallerDistance];\n      let a2 = differentDistances[differentDistances.length - 1];\n      let b2 = smallerValuesByDistance[differentDistances.length - 1];\n      let slope = (b2 - b1) / (a2 - a1);\n      let constant = b1 - slope * a1;\n      let S2 = new Uint32Array(counter);\n      counter = 0;\n      for (let i = 0; i < S2.length; i++) {\n        let j = S1[i];\n        if (\n          functionValues[j] <=\n          slope * diagonalDistances[j] + constant + tolerance2\n        ) {\n          S2[counter++] = j;\n        }\n      }\n\n      let xHull = [];\n      let yHull = [];\n      for (let i = 0; i < counter; i++) {\n        xHull.push(diagonalDistances[S2[i]]);\n        yHull.push(functionValues[S2[i]]);\n      }\n\n      let lowerIndexHull = antiLowerConvexHull(xHull, yHull);\n\n      S3 = [];\n      for (let i = 0; i < lowerIndexHull.length; i++) {\n        S3.push(S2[lowerIndexHull[i]]);\n      }\n    } else {\n      S3 = S1.slice(0, counter);\n    }\n    optimumValuesIndex = S3;\n    //--------------------------------------------------------------\n    // STEPS 3,5: Select any rectangle j in S\n    //--------------------------------------------------------------\n    for (let k = 0; k < optimumValuesIndex.length; k++) {\n      let j = optimumValuesIndex[k];\n      let largerSide = xMaxValue(edgeSizes[j]);\n      let largeSidesIndex = new Uint32Array(edgeSizes[j].length);\n      counter = 0;\n      for (let i = 0; i < edgeSizes[j].length; i++) {\n        if (Math.abs(edgeSizes[j][i] - largerSide) < tolerance) {\n          largeSidesIndex[counter++] = i;\n        }\n      }\n      let delta = (2 * largerSide) / 3;\n      let bestFunctionValues = [];\n      for (let r = 0; r < counter; r++) {\n        let i = largeSidesIndex[r];\n        let firstMiddleCenter = unitaryCoordinates[j].slice();\n        let secondMiddleCenter = unitaryCoordinates[j].slice();\n        firstMiddleCenter[i] += delta;\n        secondMiddleCenter[i] -= delta;\n        let firstMiddleValue = new Float64Array(firstMiddleCenter.length);\n        let secondMiddleValue = new Float64Array(secondMiddleCenter.length);\n        for (let i = 0; i < firstMiddleCenter.length; i++) {\n          firstMiddleValue[i] =\n            lowerBoundaries[i] + firstMiddleCenter[i] * diffBorders[i];\n          secondMiddleValue[i] =\n            lowerBoundaries[i] + secondMiddleCenter[i] * diffBorders[i];\n        }\n        let firstMinValue = objectiveFunction(firstMiddleValue);\n        let secondMinValue = objectiveFunction(secondMiddleValue);\n        fCalls += 2;\n        bestFunctionValues.push({\n          minValue: Math.min(firstMinValue, secondMinValue),\n          index: r,\n        });\n        // [Math.min(firstMinValue, secondMinValue), r];\n        unitaryCoordinates.push(firstMiddleCenter, secondMiddleCenter);\n        functionValues.push(firstMinValue, secondMinValue);\n      }\n\n      let b = bestFunctionValues.sort((a, b) => a.minValue - b.minValue);\n      for (let r = 0; r < counter; r++) {\n        let u = largeSidesIndex[b[r].index];\n        let ix1 = numberOfRectangles + 2 * (b[r].index + 1) - 1;\n        let ix2 = numberOfRectangles + 2 * (b[r].index + 1);\n        edgeSizes[j][u] = delta / 2;\n        edgeSizes[ix1] = edgeSizes[j].slice();\n        edgeSizes[ix2] = edgeSizes[j].slice();\n        diagonalDistances[j] = xNorm(edgeSizes[j]);\n        diagonalDistances[ix1] = diagonalDistances[j];\n        diagonalDistances[ix2] = diagonalDistances[j];\n      }\n      numberOfRectangles += 2 * counter;\n    }\n\n    //--------------------------------------------------------------\n    //                  Update\n    //--------------------------------------------------------------\n\n    bestCurrentValue = xMinValue(functionValues);\n\n    choiceLimit =\n      epsilon * Math.abs(bestCurrentValue) > 1e-8\n        ? epsilon * Math.abs(bestCurrentValue)\n        : 1e-8;\n\n    smallerDistance = getMinIndex(\n      functionValues,\n      diagonalDistances,\n      choiceLimit,\n      bestCurrentValue,\n      iteration,\n    );\n\n    differentDistances = Array.from(new Set(diagonalDistances));\n    differentDistances = differentDistances.sort((a, b) => a - b);\n\n    smallerValuesByDistance = [];\n    for (let i = 0; i < differentDistances.length; i++) {\n      let minIndex;\n      let minValue = Number.POSITIVE_INFINITY;\n      for (let k = 0; k < diagonalDistances.length; k++) {\n        if (diagonalDistances[k] === differentDistances[i]) {\n          if (functionValues[k] < minValue) {\n            minValue = functionValues[k];\n            minIndex = k;\n          }\n        }\n      }\n      smallerValuesByDistance.push(functionValues[minIndex]);\n    }\n\n    let currentMin = [];\n    for (let j = 0; j < functionValues.length; j++) {\n      if (functionValues[j] === bestCurrentValue) {\n        let temp = [];\n        for (let i = 0; i < lowerBoundaries.length; i++) {\n          temp.push(\n            lowerBoundaries[i] + unitaryCoordinates[j][i] * diffBorders[i],\n          );\n        }\n        currentMin.push(temp);\n      }\n    }\n    iteration += 1;\n  }\n  //--------------------------------------------------------------\n  //                  Saving results\n  //--------------------------------------------------------------\n\n  let result = {};\n  result.minFunctionValue = bestCurrentValue;\n  result.iterations = iteration;\n  let originalCoordinates = [];\n  for (let j = 0; j < numberOfRectangles + 1; j++) {\n    let pair = [];\n    for (let i = 0; i < lowerBoundaries.length; i++) {\n      pair.push(lowerBoundaries[i] + unitaryCoordinates[j][i] * diffBorders[i]);\n    }\n    originalCoordinates.push(pair);\n  }\n\n  result.finalState = {\n    numberOfRectangles,\n    totalIterations: (totalIterations += iterations),\n    originalCoordinates,\n    middlePoint,\n    fCalls,\n    smallerDistance,\n    edgeSizes,\n    diagonalDistances,\n    functionValues,\n    differentDistances,\n    smallerValuesByDistance,\n    choiceLimit,\n  };\n\n  let minimizer = [];\n  for (let i = 0; i < functionValues.length; i++) {\n    if (functionValues[i] === bestCurrentValue) {\n      minimizer.push(originalCoordinates[i]);\n    }\n  }\n\n  result.optima = minimizer;\n  return result;\n}\n\nfunction getMinIndex(\n  functionValues,\n  diagonalDistances,\n  choiceLimit,\n  bestCurrentValue,\n) {\n  let item = [];\n  for (let i = 0; i < functionValues.length; i++) {\n    item[i] =\n      Math.abs(functionValues[i] - (bestCurrentValue + choiceLimit)) /\n      diagonalDistances[i];\n  }\n  const min = xMinValue(item);\n  let result = item.findIndex((x) => x === min);\n  return result;\n}\n"],"names":["toString","Object","prototype","xCheck","input","options","arguments","length","undefined","minLength","value","call","endsWith","TypeError","Error","xFindClosestIndex","array","target","sorted","low","high","middle","Math","abs","index","diff","Number","POSITIVE_INFINITY","i","currentDiff","xGetFromToIndex","x","fromIndex","toIndex","from","to","xMaxValue","maxValue","xMinValue","minValue","xNorm","result","element","sqrt","antiLowerConvexHull","y","RangeError","nbPoints","currentPoint","Array","fill","a","b","moveOn","c","moveBack","map","item","filter","vector","counter","getMinIndex","functionValues","diagonalDistances","choiceLimit","bestCurrentValue","min","findIndex","objectiveFunction","lowerBoundaries","upperBoundaries","iterations","epsilon","tolerance","tolerance2","initialState","Float64Array","n","diffBorders","numberOfRectangles","totalIterations","unitaryCoordinates","middlePoint","fCalls","smallerDistance","edgeSizes","pow","differentDistances","smallerValuesByDistance","originalCoordinates","slice","j","iteration","optimumValuesIndex","S3","S1","idx","e","f","a1","b1","a2","slope","constant","S2","Uint32Array","xHull","yHull","push","lowerIndexHull","k","largerSide","largeSidesIndex","delta","bestFunctionValues","r","firstMiddleCenter","secondMiddleCenter","firstMiddleValue","secondMiddleValue","firstMinValue","secondMinValue","sort","u","ix1","ix2","Set","minIndex","temp","minFunctionValue","pair","finalState","minimizer","optima"],"mappings":"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"}