Los máximos y mínimos identifican los valores más altos o más bajos que alcanza una función en un punto o intervalo.
Al analizar una función, muchas veces interesa saber dónde alcanza su valor más alto o más bajo. Esos puntos se llaman máximos y mínimos.
En programación, esta idea aparece al optimizar costos, detectar picos en datos, encontrar el mejor resultado posible o localizar valores extremos en una simulación.
Un máximo es un valor de la función que es mayor o igual que otros valores considerados.
El máximo puede analizarse dentro de un intervalo o en todo el dominio.
Un mínimo es un valor de la función que es menor o igual que otros valores considerados.
También puede ser local, global o estar limitado a un intervalo específico.
| Tipo | Descripción | Alcance |
|---|---|---|
| Máximo local | Mayor que los valores cercanos | Vecindad del punto |
| Mínimo local | Menor que los valores cercanos | Vecindad del punto |
| Máximo global | Mayor valor de todo el intervalo o dominio | Todo el conjunto analizado |
| Mínimo global | Menor valor de todo el intervalo o dominio | Todo el conjunto analizado |
La función cuadrática f(x) = x² tiene un mínimo en x = 0.
function f(x) {
return x * x;
}
for (let x = -3; x <= 3; x++) {
console.log({ x, y: f(x) });
}La función f(x) = -x² tiene un máximo en x = 0.
function f(x) {
return -x * x;
}
for (let x = -3; x <= 3; x++) {
console.log({ x, y: f(x) });
}Si tenemos una lista de puntos, podemos recorrerla y conservar el menor valor encontrado.
function buscarMinimo(puntos) {
let minimo = puntos[0];
for (const punto of puntos) {
if (punto.y < minimo.y) {
minimo = punto;
}
}
return minimo;
}
const puntos = [
{ x: -2, y: 4 },
{ x: -1, y: 1 },
{ x: 0, y: 0 },
{ x: 1, y: 1 },
{ x: 2, y: 4 }
];
console.log(buscarMinimo(puntos));El procedimiento para buscar un máximo es equivalente, pero comparando valores mayores.
function buscarMaximo(puntos) {
let maximo = puntos[0];
for (const punto of puntos) {
if (punto.y > maximo.y) {
maximo = punto;
}
}
return maximo;
}
const puntos = [
{ x: -2, y: -4 },
{ x: -1, y: -1 },
{ x: 0, y: 0 },
{ x: 1, y: -1 },
{ x: 2, y: -4 }
];
console.log(buscarMaximo(puntos));Un extremo local se detecta comparando un punto con los valores cercanos. Si está por encima de ambos vecinos, es máximo local. Si está por debajo, es mínimo local.
function extremosLocales(puntos) {
const extremos = [];
for (let i = 1; i < puntos.length - 1; i++) {
const anterior = puntos[i - 1];
const actual = puntos[i];
const siguiente = puntos[i + 1];
if (actual.y > anterior.y && actual.y > siguiente.y) {
extremos.push({ ...actual, tipo: "máximo local" });
}
if (actual.y < anterior.y && actual.y < siguiente.y) {
extremos.push({ ...actual, tipo: "mínimo local" });
}
}
return extremos;
}
const puntos = [
{ x: 0, y: 0 },
{ x: 1, y: 3 },
{ x: 2, y: 1 },
{ x: 3, y: 4 },
{ x: 4, y: 2 }
];
console.log(extremosLocales(puntos));Una función puede no tener máximo o mínimo global en todo su dominio, pero sí tenerlos dentro de un intervalo cerrado.
Podemos muestrear una función en un intervalo y buscar el mayor y menor valor entre las muestras.
function muestrear(funcion, desde, hasta, paso) {
const puntos = [];
for (let x = desde; x <= hasta; x += paso) {
puntos.push({ x, y: funcion(x) });
}
return puntos;
}
function f(x) {
return x * x - 4 * x + 3;
}
const puntos = muestrear(f, -1, 5, 1);
console.log(puntos);Este enfoque aproxima el mínimo dentro del intervalo elegido.
function f(x) {
return x * x - 4 * x + 3;
}
function buscarMinimoMuestreado(desde, hasta, paso) {
let minimo = { x: desde, y: f(desde) };
for (let x = desde; x <= hasta; x += paso) {
const punto = { x, y: f(x) };
if (punto.y < minimo.y) {
minimo = punto;
}
}
return minimo;
}
console.log(buscarMinimoMuestreado(-1, 5, 0.5));Cuanto menor sea el paso, más precisa puede ser la aproximación, pero se hacen más cálculos.
function cantidadMuestras(desde, hasta, paso) {
return Math.floor((hasta - desde) / paso) + 1;
}
console.log(cantidadMuestras(-10, 10, 1));
console.log(cantidadMuestras(-10, 10, 0.1));
console.log(cantidadMuestras(-10, 10, 0.01));Para una función cuadrática ax² + bx + c, la coordenada x del vértice se calcula con:
Si a es positivo, el vértice es un mínimo. Si a es negativo, es un máximo.
function verticeCuadratica(a, b, c) {
const x = -b / (2 * a);
const y = a * x * x + b * x + c;
const tipo = a > 0 ? "mínimo" : "máximo";
return { x, y, tipo };
}
console.log(verticeCuadratica(1, -4, 3));
console.log(verticeCuadratica(-1, 4, 3));Muchos problemas de programación consisten en maximizar una utilidad o minimizar un costo.
function costo(tamaño) {
return tamaño * tamaño - 10 * tamaño + 40;
}
function buscarMejorTamaño() {
let mejor = { tamaño: 0, costo: costo(0) };
for (let tamaño = 1; tamaño <= 10; tamaño++) {
const actual = { tamaño, costo: costo(tamaño) };
if (actual.costo < mejor.costo) {
mejor = actual;
}
}
return mejor;
}
console.log(buscarMejorTamaño());En datos reales, encontrar máximos permite detectar picos de demanda, tráfico, temperatura o ventas.
function maximoDato(valores) {
let indiceMaximo = 0;
for (let i = 1; i < valores.length; i++) {
if (valores[i] > valores[indiceMaximo]) {
indiceMaximo = i;
}
}
return {
indice: indiceMaximo,
valor: valores[indiceMaximo]
};
}
console.log(maximoDato([10, 14, 13, 20, 18]));Encontrar mínimos sirve para ubicar caídas, puntos de menor costo o valores críticos bajos.
function minimoDato(valores) {
let indiceMinimo = 0;
for (let i = 1; i < valores.length; i++) {
if (valores[i] < valores[indiceMinimo]) {
indiceMinimo = i;
}
}
return {
indice: indiceMinimo,
valor: valores[indiceMinimo]
};
}
console.log(minimoDato([10, 14, 8, 20, 18]));Los máximos y mínimos permiten identificar puntos importantes de una función o conjunto de datos. Son esenciales para optimización, análisis de rendimiento, detección de picos y toma de decisiones basada en valores extremos.