al = {
  const f0 = f0_al, fs = fs_al;
  // Ventana fija de 1 s, como el eje de frecuencias: con las dos escalas quietas se ve
  // cómo se separan o se juntan las muestras al mover fs, que es de lo que va esto.
  const T = 1;
  const continua = d3.range(0, T + 1e-9, T / 4000).map(t => ({t, x: Math.cos(2 * Math.PI * f0 * t), a: Math.cos(2 * Math.PI * fa_al * t)}));
  const muestras = d3.range(0, Math.floor(T * fs + 1e-9) + 1).map(n => ({t: n / fs, x: Math.cos(2 * Math.PI * f0 * n / fs)}));
  // El arco del plegado se traza a mano, como una parábola: con el `bend` de Plot la altura
  // sale de un ángulo y crece con la distancia, y entre 0 y 20 Hz se salía de la diapositiva.
  // Aquí la altura se fija en píxeles (18, más un 2 % de la distancia) y la curva va hacia
  // arriba por construcción. En el caso más separado la desviación baja de 112 px a 41.
  const pxHz = (1216 - 40 - 60) / 20;                  // ancho útil del eje, 20 Hz entre márgenes
  const altoPx = 210 - 30 - 42;                        // alto útil, para 1,75 unidades de y
  const y0 = 0.45;                                     // altura a la que arranca y acaba el arco
  const hy = (18 + 0.02 * Math.abs(f0 - fa_al) * pxHz) / altoPx * 1.75;
  const arco = d3.range(0, 1.0001, 1 / 80).map(u => ({
    f: f0 + (fa_al - f0) * u,
    y: y0 + hy * (1 - (2 * u - 1) ** 2)
  }));
  // La cabeza se dibuja sobre el último tramo, y necesita unos 12 px para verse: se retrocede
  // por el arco hasta juntarlos, en vez de usar los dos últimos puntos (a veces a 2 px).
  let i = arco.length - 1, d = 0;
  while (i > 0 && d < 12) {
    d += Math.hypot((arco[i].f - arco[i - 1].f) * pxHz, (arco[i].y - arco[i - 1].y) / 1.75 * altoPx);
    i--;
  }
  return {T, continua, muestras, arco, hayAlias: f0 > fs / 2 + 1e-9,
          punta: [arco[i], arco[arco.length - 1]]};
}

Plot.plot({
  width: 1216, height: 225, marginTop: 8, marginBottom: 35, marginRight: 60,
  // El rótulo va al final del eje, en el margen derecho, donde no se cruza con nada
  x: {label: "t (s)", domain: [0, 1], labelAnchor: "right", labelArrow: "none"},
  y: {label: null, domain: [-1.15, 1.15], ticks: [-1, 0, 1], grid: true},
  marks: [
    Plot.ruleY([0]),
    // La original va sólida y el alias discontinuo encima: donde no hay aliasing coinciden
    Plot.line(al.continua, {x: "t", y: "x", stroke: "#2c7fb8", strokeWidth: 2}),
    Plot.line(al.continua, {x: "t", y: "a", stroke: "#41ab5d", strokeWidth: 2.5, strokeDasharray: "8 5"}),
    Plot.ruleX(al.muestras, {x: "t", y1: 0, y2: "x", stroke: "#e74c3c", strokeWidth: 1.5}),
    Plot.dot(al.muestras, {x: "t", y: "x", fill: "#e74c3c", r: 4})
  ]
})

Plot.plot({
  width: 1216, height: 210, marginTop: 30, marginBottom: 42, marginRight: 60,
  // Eje fijo: el alias se aprecia mejor si las rayas se mueven sobre una escala que no cambia
  x: {label: "f (Hz)", domain: [0, 20], ticks: d3.range(0, 21, 1),
      labelAnchor: "right", labelArrow: "none"},
  y: {axis: null, domain: [0, 1.75]},
  marks: [
    Plot.rect([{x1: 0, x2: fs_al / 2}], {x1: "x1", x2: "x2", y1: 0, y2: 1.75, fill: "#e0e0e0", fillOpacity: 0.7}),
    Plot.text([{f: 0.1, y: 1.72, t: "Zona sin aliasing"}],
              {x: "f", y: "y", text: "t", textAnchor: "start", lineAnchor: "top", fill: "#555", fontSize: 13}),
    Plot.ruleX([fs_al / 2], {stroke: "#555", strokeWidth: 1.2, strokeDasharray: "5 4"}),
    // El valor de fs/2 va arriba, al lado de su línea: debajo del eje chocaría con «f (Hz)»
    Plot.text([{f: fs_al / 2, y: 1.45, t: `fₛ/2 = ${(fs_al / 2).toFixed(1)}`}],
              {x: "f", y: "y", text: "t", textAnchor: "start", dx: 5, fill: "#555", fontSize: 12}),
    Plot.ruleY([0], {stroke: "#333"}),
    // La raya que hay de verdad: discontinua cuando cae fuera de la banda
    Plot.ruleX([f0_al], {y1: 0, y2: 1, stroke: "#2c7fb8", strokeWidth: 3, strokeDasharray: al.hayAlias ? "6 4" : null}),
    Plot.dot([{f: f0_al, y: 1}], {x: "f", y: "y", fill: al.hayAlias ? "white" : "#2c7fb8", stroke: "#2c7fb8", strokeWidth: 2.5, r: 5}),
    Plot.text([{f: f0_al, y: 1.08, t: `f₀ = ${f0_al.toFixed(1)} Hz${al.hayAlias ? " (la que hay)" : ""}`}],
              {x: "f", y: "y", text: "t", lineAnchor: "bottom", fill: "#2c7fb8", fontSize: 13}),
    // El alias y el arco del plegado, solo cuando los hay
    ...(al.hayAlias ? [
      Plot.ruleX([fa_al], {y1: 0, y2: 1, stroke: "#41ab5d", strokeWidth: 3}),
      Plot.dot([{f: fa_al, y: 1}], {x: "f", y: "y", fill: "#41ab5d", r: 5}),
      Plot.text([{f: fa_al, y: 1.08, t: `f' = ${fa_al.toFixed(1)} Hz (la que se ve)`}],
                {x: "f", y: "y", text: "t", lineAnchor: "bottom", fill: "#41ab5d", fontSize: 13}),
      Plot.line(al.arco, {x: "f", y: "y", stroke: "#41ab5d", strokeWidth: 2}),
      Plot.arrow([{x1: al.punta[0].f, y1: al.punta[0].y, x2: al.punta[1].f, y2: al.punta[1].y}],
                 {x1: "x1", y1: "y1", x2: "x2", y2: "y2", stroke: "#41ab5d", strokeWidth: 2, headLength: 9})
    ] : [])
  ]
})

rc = {
  const x = t => 0.58 * Math.sin(2 * Math.PI * 0.42 * t + 4.23)
               + 0.21 * Math.sin(2 * Math.PI * 1.27 * t + 3.26)
               + 0.10 * Math.sin(2 * Math.PI * 3.08 * t + 5.94);
  const Ts = Math.round(ts_rc * 100) / 100;
  const todas = d3.range(Math.floor(-3 / Ts), Math.ceil(7 / Ts) + 1).map(n => ({t: n * Ts, v: x(n * Ts)}));
  const sinc = u => Math.abs(u) < 1e-12 ? 1 : Math.sin(Math.PI * u) / (Math.PI * u);
  const rec = {
    ZOH: t => x(Math.floor(t / Ts + 1e-9) * Ts),
    Lineal: t => {
      const k = Math.floor(t / Ts + 1e-9), a = t / Ts - k;
      return (1 - a) * x(k * Ts) + a * x((k + 1) * Ts);
    },
    Ideal: t => todas.reduce((s, m) => s + m.v * sinc((t - m.t) / Ts), 0)
  };
  const tt = d3.range(0, 4.0001, 0.005);
  const curvas = Object.fromEntries(tipo_rc.map(k => [k, tt.map(t => ({t, v: rec[k](t)}))]));
  const error = Object.fromEntries(tipo_rc.map(k => [k, Math.sqrt(d3.mean(curvas[k], d => (d.v - x(d.t)) ** 2))]));
  return {
    Ts, curvas, error,
    continua: tt.map(t => ({t, v: x(t)})),
    muestras: todas.filter(m => m.t >= -1e-9 && m.t <= 4 + 1e-9)
  };
}

Plot.plot({
  width: 1216, height: 380,
  x: {label: "t (s)", domain: [-0.1, 4.1]},
  y: {label: null, domain: [-1.05, 1.05], grid: true},
  color: {domain: ["Original", "ZOH", "Lineal", "Ideal"], range: ["#9ecae1", "#9370db", "#41ab5d", "#08519c"], legend: true},
  marks: [
    Plot.ruleY([0]),
    Plot.line(rc.continua, {x: "t", y: "v", stroke: () => "Original", strokeWidth: 6, strokeOpacity: 0.6}),
    rc.curvas.ZOH ? Plot.line(rc.curvas.ZOH, {x: "t", y: "v", stroke: () => "ZOH", strokeWidth: 2}) : null,
    rc.curvas.Lineal ? Plot.line(rc.curvas.Lineal, {x: "t", y: "v", stroke: () => "Lineal", strokeWidth: 2, strokeDasharray: "7 4"}) : null,
    rc.curvas.Ideal ? Plot.line(rc.curvas.Ideal, {x: "t", y: "v", stroke: () => "Ideal", strokeWidth: 2}) : null,
    Plot.ruleX(rc.muestras, {x: "t", y1: 0, y2: "v", stroke: "#e74c3c", strokeWidth: 1.5}),
    Plot.dot(rc.muestras, {x: "t", y: "v", fill: "#e74c3c", r: 3.5})
  ]
})

// Cuantizador bipolar entre −0,5 y 0,5 V (V_FS = 1 V) con Δ = V_FS/(L − 1): código
// k = round((x + 0,5)/Δ) o floor((x + 0,5)/Δ), saturado a L − 1. La entrada es una senoidal que ocupa todo el fondo de escala, la misma
// hipótesis del cálculo de la SQNR, cuantizada sin muestrear para que se vea la escalera entera.
cq = {
  const L = 2 ** b_q, D = 1 / (L - 1);
  const u = v => (v + 0.5) / D;
  const k = v => Math.min(Math.max(modo_q === "Redondeo" ? Math.round(u(v)) : Math.floor(u(v) + 1e-12), 0), L - 1);
  const x = t => 0.5 * Math.sin(2 * Math.PI * t);
  // La rejilla va desplazada medio paso para no caer justo en el pico, x = 0,5 V: ahí el
  // truncamiento da el último código y el error salta un instante de −Δ a 0, un pico aislado.
  const curva = d3.range(0.00025, 2, 0.0005).map(t => {
    const v = x(t), xq = -0.5 + k(v) * D;
    return {t, x: v, xq, e: xq - v};
  });
  const niveles = d3.range(L).map(i => -0.5 + i * D);
  const banda = modo_q === "Redondeo" ? [-D / 2, D / 2] : [-D, 0];
  return {L, D, curva, niveles, banda,
          media: d3.mean(curva, d => d.e), max: d3.max(curva, d => Math.abs(d.e))};
}

Plot.plot({
  width: 1216, height: 225, marginTop: 10, marginBottom: 10, marginLeft: 90, marginRight: 60,
  // Sin eje x: es el mismo tiempo que el panel de abajo, que ya lo rotula
  x: {axis: null, domain: [0, 2]},
  y: {label: "x (V)", domain: [-0.55, 0.55], ticks: [-0.5, 0, 0.5], labelArrow: "none", labelOffset: 90},
  marks: [
    // Los niveles permitidos, punteados como en el recordatorio de cuantización
    Plot.ruleY(cq.niveles, {stroke: "#b0b0b0", strokeWidth: 0.8, strokeDasharray: "2 3"}),
    Plot.line(cq.curva, {x: "t", y: "x", stroke: "#2c7fb8", strokeWidth: 2, strokeOpacity: 0.35}),
    Plot.line(cq.curva, {x: "t", y: "xq", stroke: "#e74c3c", strokeWidth: 2})
  ]
})

Plot.plot({
  width: 1216, height: 210, marginTop: 30, marginBottom: 35, marginLeft: 90, marginRight: 60,
  x: {label: "t (s)", domain: [0, 2], labelAnchor: "right", labelArrow: "none"},
  y: {label: "e (V)", domain: [-0.5, 0.5], ticks: [-0.5, -0.25, 0, 0.25, 0.5], grid: true, labelArrow: "none", labelOffset: 90},
  marks: [
    Plot.rect([{}], {x1: 0, x2: 2, y1: cq.banda[0], y2: cq.banda[1], fill: "#41ab5d", fillOpacity: 0.15}),
    Plot.ruleY([0]),
    Plot.ruleY([cq.media], {stroke: "#555", strokeDasharray: "5 4"}),
    Plot.line(cq.curva, {x: "t", y: "e", stroke: "#e74c3c", strokeWidth: 1.5})
  ]
})