{"version":3,"file":"ml-direct.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","isAnyArray","value","call","endsWith","xCheck","input","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","det","leftTurn","moveBack","map","item","filter","vector","counter","direct","objectiveFunction","lowerBoundaries","upperBoundaries","iterations","epsilon","tolerance","tolerance2","initialState","Float64Array","Error","n","diffBorders","numberOfRectangles","totalIterations","unitaryCoordinates","middlePoint","bestCurrentValue","fCalls","smallerDistance","edgeSizes","diagonalDistances","pow","functionValues","differentDistances","smallerValuesByDistance","choiceLimit","originalCoordinates","getMinIndex","slice","j","iteration","S1","idx","findIndex","e","f","optimumValuesIndex","S3","a1","b1","a2","b2","slope","constant","S2","Uint32Array","xHull","yHull","push","lowerIndexHull","k","largerSide","largeSidesIndex","delta","bestFunctionValues","r","firstMiddleCenter","secondMiddleCenter","firstMiddleValue","secondMiddleValue","firstMinValue","secondMinValue","min","sort","u","ix1","ix2","Set","minIndex","temp","minFunctionValue","pair","finalState","minimizer","optima"],"mappings":"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"}