Un intervalo de crecimiento indica una zona del dominio donde la función aumenta al avanzar la entrada.
Una función puede no ser creciente en todo su dominio, pero sí en ciertos intervalos. Identificar esos intervalos ayuda a describir su comportamiento con precisión.
En programación, detectar intervalos de crecimiento sirve para encontrar tendencias positivas, fases de mejora, subidas en datos y tramos ascendentes de una animación o simulación.
Un intervalo de crecimiento es una parte del dominio donde, al aumentar x, también aumenta el valor de la función.
Si siempre se cumple f(x₁) < f(x₂), se habla de crecimiento estricto.
Los intervalos suelen escribirse usando paréntesis o corchetes.
| Notación | Significado |
|---|---|
| (a, b) | Entre a y b, sin incluir extremos |
| [a, b] | Entre a y b, incluyendo extremos |
| (a, ∞) | Desde a hacia valores mayores |
| (-∞, b) | Desde valores muy negativos hasta b |
La función f(x) = x² decrece antes de x = 0 y crece después de x = 0.
function f(x) {
return x * x;
}
for (let x = 0; x <= 5; x++) {
console.log({ x, y: f(x) });
}La función f(x) = (x - 2)² tiene su mínimo en x = 2. A partir de ese punto crece.
function f(x) {
return (x - 2) * (x - 2);
}
for (let x = 2; x <= 6; x++) {
console.log({ x, y: f(x) });
}Con puntos muestreados, un tramo es creciente si el valor de salida aumenta entre un punto y el siguiente.
function detectarCrecimiento(puntos) {
const tramos = [];
for (let i = 1; i < puntos.length; i++) {
const anterior = puntos[i - 1];
const actual = puntos[i];
if (actual.y > anterior.y) {
tramos.push({ desde: anterior.x, hasta: actual.x });
}
}
return tramos;
}
const puntos = [
{ x: 0, y: 4 },
{ x: 1, y: 1 },
{ x: 2, y: 0 },
{ x: 3, y: 1 },
{ x: 4, y: 4 }
];
console.log(detectarCrecimiento(puntos));Para analizar una función con código, primero podemos generar puntos en un intervalo.
function generarPuntos(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 - 2) * (x - 2);
}
console.log(generarPuntos(f, -1, 5, 1));Si varios tramos crecientes aparecen uno detrás de otro, conviene unirlos para obtener un intervalo más claro.
function unirTramos(tramos) {
if (tramos.length === 0) return [];
const unidos = [tramos[0]];
for (let i = 1; i < tramos.length; i++) {
const ultimo = unidos[unidos.length - 1];
const actual = tramos[i];
if (actual.desde === ultimo.hasta) {
ultimo.hasta = actual.hasta;
} else {
unidos.push(actual);
}
}
return unidos;
}
const tramos = [
{ desde: 2, hasta: 3 },
{ desde: 3, hasta: 4 },
{ desde: 4, hasta: 5 }
];
console.log(unirTramos(tramos));Combinando detección y unión, podemos aproximar intervalos crecientes a partir de muestras.
function intervalosCrecientes(puntos) {
const tramos = [];
for (let i = 1; i < puntos.length; i++) {
const anterior = puntos[i - 1];
const actual = puntos[i];
if (actual.y > anterior.y) {
const ultimo = tramos[tramos.length - 1];
if (ultimo && ultimo.hasta === anterior.x) {
ultimo.hasta = actual.x;
} else {
tramos.push({ desde: anterior.x, hasta: actual.x });
}
}
}
return tramos;
}
const puntos = [
{ x: -1, y: 9 },
{ x: 0, y: 4 },
{ x: 1, y: 1 },
{ x: 2, y: 0 },
{ x: 3, y: 1 },
{ x: 4, y: 4 },
{ x: 5, y: 9 }
];
console.log(intervalosCrecientes(puntos));Si se permite que la función se mantenga igual, el crecimiento puede ser no estricto. Si se exige que suba siempre, es estricto.
| Tipo | Condición entre dos puntos |
|---|---|
| Creciente | f(x₂) ≥ f(x₁) |
| Estrictamente creciente | f(x₂) > f(x₁) |
En una serie con valores repetidos, el crecimiento no estricto permite tramos constantes.
function esCrecienteNoEstricto(valores) {
for (let i = 1; i < valores.length; i++) {
if (valores[i] < valores[i - 1]) {
return false;
}
}
return true;
}
console.log(esCrecienteNoEstricto([1, 2, 2, 3]));
console.log(esCrecienteNoEstricto([1, 2, 1, 3]));Muchas funciones cambian de decreciente a creciente en un mínimo. El punto donde ocurre el cambio ayuda a separar intervalos.
El punto x = 2 funciona como frontera entre intervalos.
Si la pendiente promedio entre puntos consecutivos es positiva, el tramo analizado es creciente.
function pendiente(p1, p2) {
return (p2.y - p1.y) / (p2.x - p1.x);
}
const p1 = { x: 2, y: 0 };
const p2 = { x: 4, y: 4 };
const m = pendiente(p1, p2);
console.log(m);
console.log(m > 0 ? "tramo creciente" : "no creciente");Los mismos criterios pueden aplicarse a datos, por ejemplo ventas por semana.
const ventas = [
{ semana: 1, valor: 100 },
{ semana: 2, valor: 120 },
{ semana: 3, valor: 140 },
{ semana: 4, valor: 130 },
{ semana: 5, valor: 160 }
];
for (let i = 1; i < ventas.length; i++) {
if (ventas[i].valor > ventas[i - 1].valor) {
console.log(`Crece de semana ${ventas[i - 1].semana} a ${ventas[i].semana}`);
}
}En datos reales puede haber pequeñas variaciones que no representan una tendencia real. Una tolerancia ayuda a ignorar cambios mínimos.
function clasificarCambio(anterior, actual, tolerancia) {
const cambio = actual - anterior;
if (cambio > tolerancia) return "crece";
if (cambio < -tolerancia) return "decrece";
return "estable";
}
console.log(clasificarCambio(100, 101, 2));
console.log(clasificarCambio(100, 105, 2));Si una métrica debe aumentar, los intervalos de crecimiento indican períodos de mejora.
function periodosDeMejora(metricas) {
const periodos = [];
for (let i = 1; i < metricas.length; i++) {
if (metricas[i] > metricas[i - 1]) {
periodos.push({ desde: i - 1, hasta: i });
}
}
return periodos;
}
console.log(periodosDeMejora([50, 55, 60, 58, 62]));Detectar intervalos por muestras es una aproximación. Si el paso es grande, pueden perderse cambios entre dos puntos.
La elección depende del nivel de precisión que necesita el programa.
Los intervalos de crecimiento permiten describir con precisión dónde una función mejora, sube o avanza en sentido positivo. Esta idea es útil tanto para analizar gráficos matemáticos como para interpretar datos reales en programas.