56. Funciones crecientes y decrecientes

56.1 Introducción

El crecimiento y el decrecimiento describen la dirección del cambio de una función. Son ideas centrales para interpretar gráficos, datos y modelos.

En programación, detectar si una secuencia sube o baja sirve para analizar tendencias, precios, rendimiento, sensores, animaciones y algoritmos.

56.2 Función creciente

Una función es creciente en un intervalo si, al aumentar la entrada, la salida también aumenta o se mantiene.

Si la salida aumenta estrictamente, se habla de función estrictamente creciente.

56.3 Función decreciente

Una función es decreciente en un intervalo si, al aumentar la entrada, la salida disminuye o se mantiene.

Si la salida disminuye estrictamente, se habla de función estrictamente decreciente.

56.4 Comparación básica

56.5 Ejemplo creciente

La función lineal f(x) = 2x + 1 es creciente porque su pendiente es positiva.

function f(x) {
  return 2 * x + 1;
}

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

56.6 Ejemplo decreciente

La función lineal f(x) = -3x + 10 es decreciente porque su pendiente es negativa.

function f(x) {
  return -3 * x + 10;
}

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

56.7 Detectar crecimiento en una lista

Si tenemos valores discretos, podemos comparar cada valor con el anterior.

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

  return true;
}

console.log(esCreciente([1, 2, 2, 5, 8]));
console.log(esCreciente([1, 3, 2, 5]));

56.8 Detectar decrecimiento en una lista

La lógica es similar, pero ahora se busca que ningún valor sea mayor que el anterior.

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

  return true;
}

console.log(esDecreciente([9, 7, 7, 3, 1]));
console.log(esDecreciente([9, 7, 8, 3]));

56.9 Creciente estricta

Una secuencia estrictamente creciente no permite valores iguales consecutivos.

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

  return true;
}

console.log(esEstrictamenteCreciente([1, 2, 3, 4]));
console.log(esEstrictamenteCreciente([1, 2, 2, 4]));

56.10 Clasificar cambios

Podemos clasificar cada tramo de una lista como creciente, decreciente o constante.

function clasificarCambios(valores) {
  const cambios = [];

  for (let i = 1; i < valores.length; i++) {
    const diferencia = valores[i] - valores[i - 1];
    cambios.push(diferencia > 0 ? "crece" : diferencia < 0 ? "decrece" : "constante");
  }

  return cambios;
}

console.log(clasificarCambios([3, 5, 5, 2, 8]));

56.11 Funciones que crecen y decrecen

Una misma función puede crecer en algunos intervalos y decrecer en otros. La función cuadrática es un ejemplo típico.

Esta función decrece cuando x se acerca a 0 desde la izquierda y crece cuando x se aleja hacia la derecha.

56.12 Analizar una cuadrática por muestras

Al muestrear valores de x², se observa el cambio de decrecimiento a crecimiento.

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

const valores = [];

for (let x = -3; x <= 3; x++) {
  valores.push({ x, y: f(x) });
}

console.log(valores);

56.13 Detectar tramos en puntos

Con una lista de puntos, podemos detectar cómo cambia la función entre pares consecutivos.

function detectarTramos(puntos) {
  const tramos = [];

  for (let i = 1; i < puntos.length; i++) {
    const anterior = puntos[i - 1];
    const actual = puntos[i];
    const cambio = actual.y - anterior.y;

    tramos.push({
      desde: anterior.x,
      hasta: actual.x,
      tipo: cambio > 0 ? "creciente" : cambio < 0 ? "decreciente" : "constante"
    });
  }

  return tramos;
}

const puntos = [
  { x: -2, y: 4 },
  { x: -1, y: 1 },
  { x: 0, y: 0 },
  { x: 1, y: 1 },
  { x: 2, y: 4 }
];

console.log(detectarTramos(puntos));

56.14 Relación con la pendiente

En una recta, el signo de la pendiente indica si la función crece o decrece.

56.15 Calcular pendiente entre dos puntos

La pendiente entre dos puntos indica el cambio promedio de la función en ese tramo.

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

function clasificarPendiente(valor) {
  if (valor > 0) return "creciente";
  if (valor < 0) return "decreciente";
  return "constante";
}

const m = pendiente({ x: 1, y: 2 }, { x: 3, y: 8 });

console.log(m);
console.log(clasificarPendiente(m));

56.16 Crecimiento en datos reales

En una serie de datos, el crecimiento y el decrecimiento permiten detectar tendencias.

const temperaturas = [18, 19, 21, 20, 22, 24];

for (let i = 1; i < temperaturas.length; i++) {
  const cambio = temperaturas[i] - temperaturas[i - 1];
  console.log({
    desde: i - 1,
    hasta: i,
    cambio,
    tipo: cambio > 0 ? "sube" : cambio < 0 ? "baja" : "igual"
  });
}

56.17 Suavizar antes de analizar

Cuando los datos tienen ruido, puede convenir suavizarlos antes de decidir si una tendencia sube o baja.

function promedioMovil(valores, tamaño) {
  const resultado = [];

  for (let i = 0; i <= valores.length - tamaño; i++) {
    const ventana = valores.slice(i, i + tamaño);
    const suma = ventana.reduce(function(total, valor) {
      return total + valor;
    }, 0);
    resultado.push(suma / tamaño);
  }

  return resultado;
}

console.log(promedioMovil([10, 12, 11, 15, 18, 17], 3));

56.18 Crecimiento acumulado

En algunas aplicaciones interesa medir cuánto cambió un valor desde el inicio hasta el final.

function crecimientoTotal(valores) {
  const primero = valores[0];
  const ultimo = valores[valores.length - 1];
  return ultimo - primero;
}

console.log(crecimientoTotal([100, 120, 130, 150]));
console.log(crecimientoTotal([100, 90, 80, 70]));

56.19 Aplicaciones en programación

• Detectar tendencias crecientes o decrecientes en datos.
• Analizar precios, ventas, temperaturas o métricas.
• Reconocer tramos de subida y bajada en una animación.
• Comparar rendimiento entre tamaños de entrada.
• Encontrar zonas donde una función cambia de comportamiento.

56.20 Errores comunes

• Confundir crecimiento en un intervalo con crecimiento en todo el dominio.
• Ignorar valores iguales cuando se necesita crecimiento estricto.
• Analizar datos ruidosos sin considerar pequeñas variaciones accidentales.
• Tomar muestras demasiado separadas y perder cambios intermedios.
• Olvidar ordenar los puntos por x antes de comparar valores.

56.21 Qué debes recordar de este tema

• Una función creciente sube o se mantiene al avanzar x.
• Una función decreciente baja o se mantiene al avanzar x.
• El crecimiento estricto no permite valores repetidos.
• Una función puede crecer en un intervalo y decrecer en otro.
• En programación, se detecta crecimiento comparando valores consecutivos o pendientes.

56.22 Conclusión

Las funciones crecientes y decrecientes permiten describir tendencias de manera precisa. Esta idea conecta el análisis matemático con tareas muy prácticas: leer gráficos, interpretar datos y detectar cambios de comportamiento en programas.