Funciones Matemáticas para Programación - 59. Intervalos de decrecimiento

59.1 Introducción

Una función puede crecer en algunos tramos y decrecer en otros. Los intervalos de decrecimiento describen con precisión dónde la función baja.

En programación, detectar estos intervalos ayuda a identificar caídas, pérdidas, disminuciones de rendimiento, descensos en datos y fases descendentes de una animación.

59.2 Qué es un intervalo de decrecimiento

Un intervalo de decrecimiento es una parte del dominio donde, al aumentar x, el valor de la función disminuye.

Si x₁ < x₂ dentro del intervalo, entonces f(x₁) ≥ f(x₂)

Si siempre se cumple f(x₁) > f(x₂), se habla de decrecimiento estricto.

59.3 Comparación con intervalos de crecimiento

Tipo	Al avanzar x	Diferencia
Crecimiento	f(x) sube	Positiva
Decrecimiento	f(x) baja	Negativa
Constante	f(x) no cambia	Cero

59.4 Ejemplo con función cuadrática

La función f(x) = x² decrece cuando x avanza desde valores negativos hacia 0.

f(x) = x² decrece en (-∞, 0)

function f(x) {
  return x * x;
}

for (let x = -5; x <= 0; x++) {
  console.log({ x, y: f(x) });
}

59.5 Ejemplo con cuadrática desplazada

La función f(x) = (x - 2)² decrece antes de llegar a su mínimo en x = 2.

f(x) = (x - 2)² decrece en (-∞, 2)

function f(x) {
  return (x - 2) * (x - 2);
}

for (let x = -2; x <= 2; x++) {
  console.log({ x, y: f(x) });
}

59.6 Detectar decrecimiento por diferencias

Con puntos muestreados, un tramo es decreciente si el valor de salida baja entre un punto y el siguiente.

function detectarDecrecimiento(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: -1, y: 9 },
  { x: 0, y: 4 },
  { x: 1, y: 1 },
  { x: 2, y: 0 },
  { x: 3, y: 1 }
];

console.log(detectarDecrecimiento(puntos));

59.7 Generar puntos para analizar

Primero se puede generar una lista de puntos y luego detectar los intervalos descendentes.

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, -2, 4, 1));

59.8 Unir tramos decrecientes

Si varios tramos decrecientes son consecutivos, conviene unirlos en un intervalo más largo.

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: -1, hasta: 0 },
  { desde: 0, hasta: 1 },
  { desde: 1, hasta: 2 }
];

console.log(unirTramos(tramos));

59.9 Detectar intervalos decrecientes

Este ejemplo detecta y agrupa tramos decrecientes consecutivos.

function intervalosDecrecientes(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: -2, y: 16 },
  { x: -1, y: 9 },
  { x: 0, y: 4 },
  { x: 1, y: 1 },
  { x: 2, y: 0 },
  { x: 3, y: 1 },
  { x: 4, y: 4 }
];

console.log(intervalosDecrecientes(puntos));

59.10 Decrecimiento estricto y no estricto

Si se permite que la función se mantenga igual, el decrecimiento puede ser no estricto. Si debe bajar siempre, es estricto.

Tipo	Condición entre dos puntos
Decreciente	f(x₂) ≤ f(x₁)
Estrictamente decreciente	f(x₂) < f(x₁)

59.11 Detectar decrecimiento no estricto

Una secuencia no estrictamente decreciente puede tener valores repetidos.

function esDecrecienteNoEstricto(valores) {
  for (let i = 1; i < valores.length; i++) {
    if (valores[i] > valores[i - 1]) {
      return false;
    }
  }

  return true;
}

console.log(esDecrecienteNoEstricto([5, 4, 4, 2]));
console.log(esDecrecienteNoEstricto([5, 4, 6, 2]));

59.12 Intervalos y máximos

Muchas funciones pasan de creciente a decreciente en un máximo. Ese punto suele separar intervalos de comportamiento distinto.

Para f(x) = -(x - 2)²: crece antes de 2 decrece después de 2

El punto x = 2 es la frontera donde comienza el intervalo de decrecimiento.

59.13 Relación con la pendiente

Si la pendiente promedio entre puntos consecutivos es negativa, el tramo analizado es decreciente.

function pendiente(p1, p2) {
  return (p2.y - p1.y) / (p2.x - p1.x);
}

const p1 = { x: 2, y: 4 };
const p2 = { x: 5, y: 1 };

const m = pendiente(p1, p2);

console.log(m);
console.log(m < 0 ? "tramo decreciente" : "no decreciente");

59.14 Intervalos en datos

En datos reales, los intervalos de decrecimiento permiten ubicar períodos de caída.

const ventas = [
  { semana: 1, valor: 160 },
  { semana: 2, valor: 150 },
  { semana: 3, valor: 130 },
  { semana: 4, valor: 140 },
  { semana: 5, valor: 120 }
];

for (let i = 1; i < ventas.length; i++) {
  if (ventas[i].valor < ventas[i - 1].valor) {
    console.log(`Decrece de semana ${ventas[i - 1].semana} a ${ventas[i].semana}`);
  }
}

59.15 Decrecimiento y ruido

Una tolerancia permite distinguir una caída importante de una variación pequeña.

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, 99, 2));
console.log(clasificarCambio(100, 94, 2));

59.16 Aplicación: detectar caída

Si una métrica debe mantenerse alta, los intervalos de decrecimiento pueden señalar problemas.

function periodosDeCaida(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(periodosDeCaida([80, 82, 79, 75, 78]));

59.17 Limitaciones del muestreo

Al igual que con los intervalos de crecimiento, detectar decrecimiento por muestras depende del paso elegido.

Un paso grande puede ocultar subidas y bajadas intermedias.

Para análisis visual o exploratorio puede alcanzar, pero para resultados críticos se necesita más precisión.

59.18 Aplicaciones en programación

Detectar caídas en métricas o ventas.
Identificar fases descendentes en una simulación.
Ubicar tramos donde una función pierde valor.
Marcar alertas cuando una tendencia empeora.
Preparar gráficos resaltando zonas decrecientes.

59.19 Errores comunes

Confundir un tramo decreciente con decrecimiento en todo el dominio.
Usar puntos desordenados por x.
No distinguir entre decrecimiento estricto y no estricto.
Interpretar pequeñas variaciones con ruido como caídas importantes.
Usar un paso de muestreo demasiado grande.

59.20 Qué debes recordar de este tema

Un intervalo de decrecimiento es una zona donde la función disminuye al avanzar x.
Los intervalos decrecientes pueden detectarse comparando valores consecutivos.
Los máximos suelen marcar el comienzo de un intervalo decreciente.
El muestreo permite aproximar tramos, pero depende del paso elegido.
En programación, estos intervalos ayudan a detectar caídas y tendencias negativas.

59.21 Conclusión

Los intervalos de decrecimiento describen dónde una función baja. Esta información es clave para interpretar gráficos, detectar problemas en datos y analizar fases descendentes en algoritmos, simulaciones o visualizaciones.

Volver al índice