{"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) {\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}\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    array.forEach((element) => {\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","value","call","endsWith","TypeError","length","xFindClosestIndex","array","target","options","sorted","low","high","middle","Math","abs","index","diff","Number","POSITIVE_INFINITY","i","currentDiff","xGetFromToIndex","x","fromIndex","toIndex","from","to","undefined","xMaxValue","maxValue","xMinValue","minValue","xNorm","result","forEach","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","Error","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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"}