Tengo una función f(x). Quiero calcular x donde f(x) = max. ¿Cómo puedo hacer eso en un script?
Dado: x es un número positivo, f(x) puede ser positivo o negativo. Quiero empezar con x = 1. Si f(1) ya es negativo, ya no me interesa. Con x creciente, también f(x) devuelve valores crecientes, hasta que se alcanza un pico, y luego f(x) disminuye. x en el pico es lo que me interesa.
EDITAR: Ok, lo que intenté hasta ahora:
Intenté comenzar con x = 1, luego x *=2. Si f(x) es menor que el último resultado, retrocedo x a x/4.
Ejemplo: f(16) = 9, f(32) = 11, f(64) = 10. El pico puede estar entre x=16 y x=64. Así que mi nuevo punto de partida es f(16). De ahí en adelante, quiero continuar de manera similar, pero no puedo encontrar un algoritmo.
Esto es lo que tengo hasta ahora:
let x = 1 let lasty = 0 let holder = 1 while (iteration++ < 20) { let y = myFunction(x) if(y < lasty ) { x = x / 4 holder = 1 } x += holder * 2 holder += 1 lasty = y }EDIT2: Mi versión mejorada que funciona bastante bien pero seguro que no es perfecta:
let x = 1 let lasty = 0 let iteration = 0 let previousX = 1 let lastX = 1 let step = 2 let maxY = -Infinity let bestX = 0 let randomInput = Math.random while (iteration++ < 20) { let y = myFunction(x, randomInput) //added randomInput to show the function does not rely on x alone if (y < 0 && iteration == 1) break if(y > maxY) { maxY = y bestX = x } if (y < lasty) { x = previousX step *= 0.8 lasty = 0 } else { previousX = lastX lastX = x x = x * step lasty = y } } if(bestX > 0) { console.log(`Got best x: ${bestX}`) }EDIT3: Se agregó un parámetro adicional aleatorio para enfatizar el enfoque necesario
EDIT4: También debo mencionar que la probabilidad de f(x) = max es la más alta cuando 0 < x < 100000
Suponiendo que desea maximizar y, simplemente puede almacenar los valores de x e y donde xy es el más alto:
let highestX = 1; // this is just the corresponding x value for the highest y let highestY = -Infinity; let x = 1 let lasty = 0 let holder = 1 while (iteration++ < 20) { let y = myFunction(x); // code for storing the highest y and corresponding x if (y > highestY) { highestY = y; highestX = x; } if(y < lasty ) { x = x / 4 holder = 1 } x += holder * 2 holder += 1 lasty = y } console.log('f(x) is maximised when x =', highestX);Podría resolverse usando llamadas a funciones recursivas.
// array of arguments const args = [...Array(16).keys()]; // sample function const sampleFunc = (x) => Math.sin(x); // recursive function function getElementWithFuncMaximum(arr, func, index = 0, currValue = 0) { const currFuncValue = func(arr[index]); return currFuncValue >= currValue ? getElementWithFuncMaximum(arr, func, index + 1, currFuncValue) : arr[index - 1]; } console.log(getElementWithFuncMaximum(args, sampleFunc));Si sabe que la función tiene un solo pico en un rango dado, y el valor más cercano dentro de una tolerancia es aceptable, entonces una simple búsqueda binaria debería ser todo lo que necesita. Aquí predeterminamos el rango a todo el rango de enteros seguros, pero puede proporcionar el suyo propio con findPeak (tolerance) (fn, rangeMin, rangeMax) , tal vez algo como findPeak (1e-8) (fn, 0, 100000) .
const findPeak = (ε) => ( fn, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER, mid = min / 2 + max / 2 ) => max - min < ε ? mid : fn (min) < fn (max) ? findPeak (ε) (fn, mid, max) : findPeak (ε) (fn, min, mid) const fn = n => 600 + 50 * n - n ** 2 console .log (findPeak (1e-8) (fn)) //=> 24.99999991050572 Este código es sencillo. Es menos eficiente de lo que podría ser si aprovecháramos el hecho de que reutilizaremos fn (min) o fn (max) en cada llamada subsiguiente, y probablemente sería más rápido con un bucle while en lugar de la recursividad. Te dejaré esa optimización a ti. Pero primero vería si esto ya es lo suficientemente rápido, ya que es mucho más fácil trabajar con un código simple.