Una función escalonada mantiene un valor constante durante un intervalo y luego salta a otro valor. Es útil para modelar niveles, rangos, tarifas y valores discretos.
Las funciones escalonadas son un caso particular de funciones definidas por tramos. En cada tramo, la salida se mantiene constante.
En programación aparecen cuando convertimos valores continuos en categorías, niveles o cantidades discretas: niveles de experiencia, tarifas por bloques, índices de arreglos, redondeos y cuantización.
Una función escalonada es una función por tramos donde cada tramo devuelve un valor constante.
El gráfico se parece a una escalera: segmentos horizontales separados por saltos.
| x | Tramo | f(x) |
|---|---|---|
| 5 | x < 10 | 0 |
| 10 | 10 ≤ x < 20 | 1 |
| 19 | 10 ≤ x < 20 | 1 |
| 20 | x ≥ 20 | 2 |
Una función escalonada se implementa con condiciones que devuelven valores constantes.
function nivel(x) {
if (x < 10) {
return 0;
}
if (x < 20) {
return 1;
}
return 2;
}
console.log(nivel(5));
console.log(nivel(10));
console.log(nivel(25));
Un ejemplo clásico de función escalonada es la función parte entera o piso, que devuelve el mayor entero menor o igual que el número dado.
En JavaScript se calcula con Math.floor.
console.log(Math.floor(3.8));
console.log(Math.floor(3.1));
console.log(Math.floor(-2.3));
Para números negativos, Math.floor baja al entero menor, no simplemente elimina los decimales.
JavaScript tiene varias funciones relacionadas con redondeo, pero no todas producen el mismo comportamiento.
| Función | Qué hace | Ejemplo con -2.7 |
|---|---|---|
| Math.floor | Entero menor o igual | -3 |
| Math.trunc | Quita la parte decimal | -2 |
| Math.round | Redondea al entero más cercano | -3 |
Cuantizar significa transformar un valor continuo en un nivel discreto. Por ejemplo, convertir una posición en un índice de celda.
function indiceCelda(posicion, tamanoCelda) {
return Math.floor(posicion / tamanoCelda);
}
console.log(indiceCelda(0, 32));
console.log(indiceCelda(31, 32));
console.log(indiceCelda(32, 32));
console.log(indiceCelda(95, 32));
Una función escalonada puede asignar un nivel según el puntaje acumulado.
function nivelPorPuntaje(puntaje) {
if (puntaje < 1000) {
return 1;
}
if (puntaje < 3000) {
return 2;
}
if (puntaje < 6000) {
return 3;
}
return 4;
}
console.log(nivelPorPuntaje(800));
console.log(nivelPorPuntaje(2500));
console.log(nivelPorPuntaje(7000));
Una tarifa puede cambiar de valor según el rango de consumo. Si cada rango devuelve un precio fijo por unidad, estamos usando una función escalonada.
function precioPorUnidad(consumo) {
if (consumo <= 100) {
return 10;
}
if (consumo <= 300) {
return 15;
}
return 20;
}
console.log(precioPorUnidad(80));
console.log(precioPorUnidad(200));
console.log(precioPorUnidad(400));
Podemos convertir un progreso continuo entre 0 y 1 en una cantidad discreta de etapas.
function etapaProgreso(progreso, cantidadEtapas) {
const limitado = Math.min(Math.max(progreso, 0), 1);
return Math.floor(limitado * cantidadEtapas);
}
console.log(etapaProgreso(0.12, 5));
console.log(etapaProgreso(0.5, 5));
console.log(etapaProgreso(1, 5));
El valor se limita entre 0 y 1 antes de calcular la etapa.
En el ejemplo anterior, si progreso = 1 y hay 5 etapas, el resultado puede ser 5, aunque los índices válidos podrían ser 0 a 4.
function indiceEtapa(progreso, cantidadEtapas) {
const limitado = Math.min(Math.max(progreso, 0), 1);
return Math.min(Math.floor(limitado * cantidadEtapas), cantidadEtapas - 1);
}
console.log(indiceEtapa(0, 5));
console.log(indiceEtapa(0.99, 5));
console.log(indiceEtapa(1, 5));
Para visualizar una función escalonada podemos generar una tabla de valores.
function escalon(x) {
return Math.floor(x);
}
for (let x = 0; x <= 4; x += 0.5) {
console.log(x, escalon(x));
}
Las funciones escalonadas suelen tener discontinuidades de salto. En los puntos donde cambia el escalón, la salida cambia bruscamente.
Al graficarlas, no conviene unir verticalmente los escalones si queremos representar correctamente la función.
Las funciones escalonadas son útiles cuando una salida cambia por niveles y no de forma continua. En programación aparecen cada vez que convertimos valores continuos en categorías, bloques o índices.
En el próximo tema comenzaremos con funciones exponenciales, donde el crecimiento depende de multiplicaciones repetidas.