Nivel 19 · Tutorial

El nivel 17, paso a paso: cada capa de BAC.bars con su razonamiento y sus matemáticas

Idea: el nivel 17 lleva tu gráfica del nivel 1 hasta BAC.bars en siete pasos. Aquí se explica cada función nueva de cada paso con tres bloques: el razonamiento (qué problema resuelve), las matemáticas (por qué la cuenta es esa) y, cuando hay que despejar, la balanza: lo que se hace en un plato se hace en el otro. Los números son los del nivel 17 (lienzo de 600 × 250, Ene … Jun).
  1. La base: la recta y su despeje en la balanza
  2. Paso 1 · tu código, con los números del 17
  3. Paso 2 · escala() y bandas()
  4. Paso 3 · pasoRedondo() y maximoRedondo()
  5. Paso 4 · barra(): esquinas con curvas
  6. Paso 5 · tween(), easeOut() y escalon()
  7. Paso 6 · avisos, tooltip y línea de referencia
  8. Paso 7 · BAC.bars: qué parámetro es cada cosa
0 · LA BASE DE TODO

La recta que pasa por dos puntos, despejada en la balanza

Razonamiento

Una recta tiene la misma inclinación entre dos puntos cualesquiera. Si conozco dos puntos, (x0, y0) y (x1, y1), y quiero la y de un tercero (x, y) de la misma recta, igualo las dos inclinaciones y despejo la y.

Balanza · punto de partida: dos pendientes iguales

(y − y0) (y1 − y0) ───────── = ───────── (x − x0) (x1 − x0)
Pesada 1: en el plato de la izquierda (x − x0) está dividiendo. Multiplico los dos platos por (x − x0) y a la izquierda se anula:
y − y0 = (x − x0) · (y1 − y0) / (x1 − x0)
Pesada 2: a la izquierda sobra − y0. Sumo y0 en los dos platos:
y = y0 + (x − x0) · (y1 − y0) / (x1 − x0) ← exactamente map(x, x0, x1, y0, y1)

Ejemplo con el 17: ¿qué píxel le toca al dato 2400 si 0 → 222 y 4800 → 22?

y − 222 22 − 222 ───────── = ────────── punto de partida 2400 − 0 4800 − 0 y − 222 = 2400 · (−200/4800) pesada 1: × 2400 en los dos platos y − 222 = −100 y = 122 pesada 2: + 222 en los dos platos
PASO 1 · TU CÓDIGO

El nivel 1 con el lienzo de los OG

const x0 = 48, x1 = 588;           // izquierda y derecha
const y0 = 222, y1 = 22;           // base y techo
const hueco = (x1 - x0) / n;       // 90
const ancho = hueco * 0.55;        // 49,5
const x = map(i, 0, n, x0, x1) + (hueco - ancho) / 2;
const y = map(v, 0, max, y0, y1);

Razonamiento

Es el nivel 1 con otros bordes. El lienzo de los OG mide 600 × 250 y deja 48 a la izquierda (para los números del eje que vendrán en el paso 3), 12 a la derecha, 22 arriba y 28 abajo (para los meses). La barra ocupa el 55 % de su carril.

Matemáticas · las dos rectas con estos números

hueco = (588 − 48) / 6 = 90 ancho = 90 · 0,55 = 49,5 sobra = (90 − 49,5)/2 = 20,25 x(i) = 48 + i · 90 + 20,25 → 68,25 · 158,25 · 248,25 · 338,25 · 428,25 · 518,25 y(v) = 222 + v · (22 − 222)/4800 = 222 − v/24 (200/4800 = 1/24) alto = 222 − y(v) = v/24 → junio: 4800/24 = 200, toca justo el techo (22)
PASO 2 · ESCALAS COMO FUNCIONES

escala(): la recta con los extremos ya fijados

function escala([d0, d1], [p0, p1]) {
    return (v) => map(v, d0, d1, p0, p1);
}
const y = escala([0, max], [H - m.b, m.t]);     // [0, 4800] → [222, 22]
y(3200)   // 222 − 3200/24 = 88,67

Razonamiento

En el paso 1 llamábamos a map() con cinco números cada vez, y cuatro eran siempre los mismos (0, max, y0, y1). escala() los fija una vez y devuelve una función nueva que solo pide lo que cambia: el dato. A una función que «recuerda» variables de donde se creó se le llama clausura (closure): la flecha (v) => … sigue viendo d0, d1, p0, p1 cuando escala ya ha terminado.
Los corchetes [d0, d1] en los parámetros son desestructuración: se le pasa un array de dos elementos y los separa en dos variables. Se leen como «dominio» (datos) y «rango» (píxeles), como en D3.

Matemáticas · fijar parámetros = una función de una variable

map es una función de cinco variables. Si se fijan cuatro, queda una recta de una sola variable, de la forma y(v) = a + b·v:
y(v) = 222 + (v − 0) · (22 − 222)/(4800 − 0) = 222 − v/24 a = 222 (corte) b = −1/24 (pendiente) y(0) = 222 (la base) y(4800) = 22 (el techo) y(3200) = 222 − 133,33 = 88,67
Mismo dato, distinta escala: en el paso 3 el máximo pasa de 4800 a 6000 y la pendiente de −1/24 a −1/30. Entonces el mismo 3200 cae en y(3200) = 222 − 3200/30 = 115,33: la barra baja porque el techo de la escala ha subido.

bandas(): el reparto horizontal

function bandas(n, x0, x1, hueco) {
    const paso = (x1 - x0) / n;                 // tu "hueco" del nivel 1
    const ancho = paso * (1 - hueco);           // hueco .45 → la barra ocupa el 55 %
    return {
        ancho,
        x: (i) => x0 + i * paso + (paso - ancho) / 2,
        centro: (i) => x0 + i * paso + paso / 2
    };
}

Razonamiento

Cambia el nombre de una cosa: en el nivel 1 «hueco» era el carril entero (90) y aquí paso. Ahora hueco es la parte vacía del carril (45 %). Por eso ancho = paso · (1 − 0,45) = 0,55 · paso, el mismo resultado que hueco * 0.55 del paso 1. Devuelve un objeto con dos funciones: dónde empieza la barra (x) y dónde está su centro (centro, para los textos).

Balanza · por qué x(i) es lo mismo que el map() del paso 1

Sustituyo en la fórmula de la recta los valores de la escala horizontal (0 → x0, n → x1):
map(i, 0, n, x0, x1) = x0 + (i − 0) · (x1 − x0)/(n − 0) = x0 + i · (x1 − x0)/n = x0 + i · paso
Ahora sumo lo mismo en los dos lados, (paso − ancho)/2:
map(i, 0, n, x0, x1) + (paso − ancho)/2 = x0 + i·paso + (paso − ancho)/2 = x(i) ✓
Y para el centro, sumo ancho/2 a los dos lados de x(i) (el centro de una barra que empieza en x(i) y mide ancho):
x(i) + ancho/2 = x0 + i·paso + (paso − ancho)/2 + ancho/2 = x0 + i·paso + paso/2 − ancho/2 + ancho/2 = x0 + i·paso + paso/2 = centro(i) ✓ (los −ancho/2 y +ancho/2 se anulan)

Con números

x(0) = 48 + 0·90 + 20,25 = 68,25 centro(0) = 48 + 0 + 45 = 93 x(5) = 48 + 5·90 + 20,25 = 518,25 centro(5) = 48 + 450 + 45 = 543
PASO 3 · EJE Y REDONDO

pasoRedondo(): el escalón «bonito» del eje

function pasoRedondo(rango, cuantos = 4) {
    const bruto = rango / cuantos;
    const potencia = Math.pow(10, Math.floor(Math.log10(bruto)));
    const k = bruto / potencia;                                // entre 1 y 10
    return (k < 1.5 ? 1 : k < 3 ? 2 : k < 7 ? 5 : 10) * potencia;
}
function maximoRedondo(max) {
    const paso = pasoRedondo(max);
    return Math.ceil(max / paso) * paso;
}
const max = maximoRedondo(Math.max(...datos) * 1.08);         // 4800 → 5184 → 6000

Razonamiento

Un eje con 0, 1296, 2592, 3888… no se lee. Las personas leen bien los múltiplos de 1, 2 y 5 (y sus ×10, ×100…). La función busca, para unas 4 divisiones, el escalón «bonito» más cercano. Antes se multiplica el máximo por 1,08 (8 % de aire), para que la barra más alta no toque el techo ni su texto.

Matemáticas · notación científica con un logaritmo

Todo número positivo se escribe como k × 10e, con k entre 1 y 10: 1296 = 1,296 × 10³. El exponente e es «cuántas cifras tiene menos una», y eso es justo lo que da el logaritmo en base 10 redondeado hacia abajo:
log10(1296) = 3,11… → floor = 3 → potencia = 10³ = 1000 k = 1296 / 1000 = 1,296
Después se redondea k a 1, 2, 5 o 10. Los cortes 1,5 · 3 · 7 están a medio camino en escala logarítmica (√2 ≈ 1,41 · √10 ≈ 3,16 · √50 ≈ 7,07), redondeados: así cada k va al «bonito» que tiene más cerca en proporción.

Balanza · Math.ceil(max / paso) * paso

Quiero el primer múltiplo de paso que sea ≥ max. Divido entre paso («¿cuántos escalones caben?»), redondeo hacia arriba y multiplico otra vez por paso para volver a las unidades:
5184 / 1000 = 5,184 → ceil = 6 → 6 · 1000 = 6000 marcas: pasoRedondo(6000) → bruto 1500, k = 1,5 → no es < 1,5 → 2 → paso 2000 → 0, 2000, 4000, 6000
Con el nuevo máximo cambia la recta vertical: y(v) = 222 − v · 200/6000 = 222 − v/30. Junio: 222 − 160 = 62 (ya no toca el techo, 22).

Prueba con otros máximos:

PASO 4 · ESQUINAS REDONDEADAS

barra(): un <path> que se dibuja como con un lápiz

function barra(x, y, w, h, r) {
    if (h <= 0) return '';
    r = Math.min(r, h, w / 2);                  // el radio no puede ser mayor que la barra
    return `M${x},${y + h} V${y + r} Q${x},${y} ${x + r},${y} H${x + w - r} Q${x + w},${y} ${x + w},${y + r} V${y + h} Z`;
}

Razonamiento · las letras del path son órdenes a un lápiz

M = mueve el lápiz sin pintar · V = línea vertical hasta esa y · H = línea horizontal hasta esa x · Q = curva hasta un punto, «tirada» hacia un punto de control · Z = cierra volviendo al inicio. La barra se recorre: abajo-izquierda → sube → curva → techo → curva → baja → cierra.
Math.min(r, h, w/2): si la barra mide 2 de alto, un radio de 4 se saldría por abajo; si mide 6 de ancho, dos radios de 4 se cruzarían. El radio se limita a lo que cabe.

Matemáticas · la curva Q (Bézier cuadrática)

Una Q une P0 con P2 tirando hacia P1 (el control). Cada punto de la curva es una media ponderada de los tres:
B(t) = (1 − t)² · P0 + 2(1 − t)t · P1 + t² · P2 t de 0 a 1 B(0) = P0 B(1) = P2 los pesos suman 1: (1−t)² + 2(1−t)t + t² = ((1−t) + t)² = 1
Con el control en el vértice de la esquina (x, y), la curva sale en vertical de (x, y+r) y llega en horizontal a (x+r, y): una esquina redondeada, muy parecida a un cuarto de círculo.

Con números · la barra de enero (máximo 6000)

x = 68,25 y = 115,33 w = 49,5 h = 106,67 r = 4 M68.25,222 V119.33 Q68.25,115.33 72.25,115.33 H113.75 Q117.75,115.33 117.75,119.33 V222 Z
PASO 5 · ANIMACIÓN

tween(), easeOut() y escalon()

// tween.js: llama a update(t) en cada fotograma, con t de 0 a 1
var t = Math.min((now - start) / (seconds * 1000), 1);
function easeOut(t) { return 1 - (1 - t) * (1 - t); }

function escalon(t, i, n, solape = .35) {
    const inicio = n > 1 ? i / (n - 1) * solape : 0;
    const local = Math.max(0, Math.min(1, (t - inicio) / (1 - solape)));
    return easeOut(local);
}
const alto = (y(0) - y(datos[i])) * escalon(t, i, datos.length);

Razonamiento

tween: el navegador pinta unos 60 fotogramas por segundo (requestAnimationFrame). En cada uno se calcula qué fracción del tiempo ha pasado: t = 0 al empezar, t = 1 a los 1,2 s. La gráfica no sabe de tiempo, solo de t.
alto × t: si la barra mide 160 y t = 0,5, se dibuja de 80. Se recalcula el d del path en cada fotograma y parece que crece.
easeOut: con t tal cual, la barra crecería a velocidad constante (mecánico). easeOut arranca rápido y frena al final, como algo que se detiene.
escalon: cada barra usa su propio t, retrasado, para que salgan en cascada.

Balanza · ¿cuánto dura cada barra?

La última barra (i = n − 1) empieza en t = solape y tiene que acabar en t = 1. Su duración es lo que queda: 1 − solape. Si todas duran lo mismo, todas duran 1 − 0,35 = 0,65. Para cada barra quiero un «t local» que valga 0 cuando empieza y 1 cuando acaba: es la misma recta de siempre, de [inicio, inicio + 0,65] a [0, 1]:
local = map(t, inicio, inicio + 0,65, 0, 1) = 0 + (t − inicio) · (1 − 0) / 0,65 = (t − inicio) / (1 − solape) ✓
El inicio de cada barra es otra recta, de [0, n − 1] a [0, solape]:
inicio = map(i, 0, n − 1, 0, 0,35) = i / (n − 1) · 0,35 → 0 · 0,07 · 0,14 · 0,21 · 0,28 · 0,35
Antes de su inicio, local saldría negativo y después de acabar, mayor que 1: Math.max(0, Math.min(1, …)) lo «pinza» entre 0 y 1 (clamp).

Matemáticas · por qué easeOut frena

easeOut(t) = 1 − (1 − t)² easeOut(0) = 0 · easeOut(0,5) = 0,75 · easeOut(1) = 1 velocidad = derivada = 2(1 − t) al principio 2 (rápido) · al final 0 (parado)
Es una parábola: a mitad de tiempo ya lleva el 75 % del camino. La velocidad baja en línea recta hasta 0, por eso llega «suave».
PASO 6 · AVISOS, TOOLTIP Y REFERENCIA

Lo que piden las tarjetas de los OG

const cambio = v / datos[i - 1] - 1;
if (cambio < -0.03) avisos[i] = '−' + Math.round(-cambio * 100) + ' %';

tip.style.left = e.clientX + 14 + 'px';  tip.style.top = e.clientY - 50 + 'px';

const yRef = y(datos[0]);                                    // la baseline
crear('text', { x: x.centro(+i), y: y(datos[i]) - 7, class: 'flag' });   // el aviso, encima

Razonamiento

Aviso: se compara cada mes con el anterior. Si cae más de un 3 %, la barra se pinta en rojo y se escribe la caída encima. Es la misma cuenta del render de og1.js (allí el umbral es el 20 %).
Tooltip: un <div> fuera del SVG que sigue al ratón. clientX/clientY es la posición del ratón en la ventana; +14 y −50 lo separan del puntero para no taparlo.
Referencia: una línea horizontal a la altura del primer dato, para ver de un vistazo qué meses superan la baseline.

Balanza · el porcentaje de cambio

«¿Cuánto ha cambiado respecto al anterior?» es (nuevo − anterior) / anterior. Separando la fracción en dos:
(v − ant) / ant = v/ant − ant/ant = v/ant − 1 Abr: 3900/4100 − 1 = 0,9512 − 1 = −0,0488 → −4,88 % Math.round(4,88) = 5 → "−5 %"
Es el único mes con aviso: Feb +9,38 % · Mar +17,14 % · Abr −4,88 % · May +12,82 % · Jun +9,09 %.

Con números (máximo 6000)

línea de referencia: y(3200) = 222 − 3200/30 = 115,33 texto del aviso: y(3900) − 7 = (222 − 130) − 7 = 85 (7 píxeles por encima del techo de abril)
PASO 7 · LA LIBRERÍA

BAC.bars: cada opción es uno de los pasos

BAC.bars(document.getElementById('g7'), {
    labels: meses,                                                   // los textos del eje x (paso 1)
    values: datos,                                                   // las alturas (pasos 1–3)
    refs: [{ value: datos[0], label: `Baseline ene · ${V.fmt(datos[0])}` }],   // paso 6
    flags: avisos,                                                   // paso 6
    tip: (i) => `<b>${V.fmt(datos[i])}</b>${meses[i]}`                // paso 6
});
pasolo que hiciste a manoen las librerías
1map(), x0/x1/y0/y1, hueco, anchodentro de BAC.bars (tu estilo del nivel 10)
2escala(), bandas()V.escala, V.bandas
3pasoRedondo(), maximoRedondo(), corto()V.maximoRedondo, V.marcas, V.corto
4barra()V.barra
5tween(), escalon()tween.js, V.animar, V.escalon
6avisos, tooltip, línea de referenciaopciones flags, tip, refs

Razonamiento

Una librería no añade matemáticas nuevas: empaqueta las de los pasos anteriores detrás de un objeto de opciones. Por eso, cuando una gráfica de los OG falla, se puede bajar «un piso» y buscar la cuenta concreta: la escala (paso 2), el máximo (paso 3), la forma (paso 4)…

Prueba a cambiar

  1. En el paso 3, pon un dato de 23.000 en el deslizador: ¿qué escalón sale y por qué? (Pista: k = 23000·1,08/4/10³ ≈ 6,2.)
  2. En el paso 4, sube el radio hasta el máximo: ¿qué límite de Math.min(r, h, w/2) lo para?
  3. En el paso 5, pon t = 0,35: la última barra justo empieza. Demuéstralo con la balanza: local = (0,35 − 0,35)/0,65 = 0.
  4. Cambia en el nivel 17 el umbral del aviso a −0.05: ¿sigue saliendo abril? (−4,88 % no es menor que −5 %.)