> For the complete documentation index, see [llms.txt](https://overleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://overleaf-pro.ayaka.space/latex/es/articulos-en-profundidad/47-tex-tables-how-tex-calculates-spanned-column-widths.md).

# Tablas en TeX: cómo TeX calcula los anchos de columnas abarcadas

## El objetivo de este artículo

En este artículo exploramos cómo $$\mathrm\TeX$$ calcula los anchos de las columnas de las tablas cuando las tablas contienen entradas (por ejemplo, encabezados de tabla) que abarcan varias columnas (por ejemplo, usando el $$\mathrm\TeX$$ primitivas `\omit` y `\span`). Usando una básica [tabla “de referencia”](#reference-table) como punto de partida, creamos una serie de ejemplos —derivados de esa tabla de referencia— modificando varias entradas para crear columnas abarcadas. Al examinar el efecto de esas alteraciones podemos empezar a desarrollar una comprensión del algoritmo subyacente que $$\mathrm\TeX$$ usa para calcular el ancho de las columnas abarcadas.

### Usar $$\mathrm\TeX$$ contiene $$\mathrm\LaTeX$$

Para examinar y explicar *cómo* $$\mathrm\TeX$$ decide los anchos de las columnas abarcadas es necesario prescindir de cualquiera de los maravillosos $$\mathrm\LaTeX$$ paquetes de tablas y volver a comandos fundamentales de creación de tablas de bajo nivel (primitivos): en particular, `\\halign{...}`, `\span` y `\omit`. [Los paquetes $$\mathrm\TeX$$/$$\mathrm\LaTeX$$ de tablas](https://ctan.org/topic/table) son, por supuesto, herramientas esenciales de productividad y ofrecen una gran cantidad de funcionalidad extremadamente útil que permite a los usuarios producir rápidamente una vasta gama de material tabular usando $$\mathrm\LaTeX$$. Esos paquetes proporcionan un “andamiaje de macros” construido en torno al comportamiento de bajo nivel de $$\mathrm\TeX$$TeX y sus desarrolladores proporcionan abstracciones y capas de aislamiento muy bienvenidas que se encargan de las complejidades subyacentes. Muchos de esos paquetes son verdaderamente hazañas increíbles de programación compleja: todos deberíamos estar agradecidos de que existan para protegernos de tener que usar TeX en bruto $$\mathrm\TeX$$ programación: todos deberíamos estar agradecidos de que existan para protegernos de tener que usar TeX en bruto $$\mathrm\TeX$$!

El algoritmo real que $$\mathrm\TeX$$ usa para calcular los anchos de las columnas abarcadas se explica en la página 245 del [$$\mathrm\TeX\text{book}$$](https://www.amazon.co.uk/TeXbook-Donald-E-Knuth/dp/0201134489) y, con más detalles, en la Sección 801 (página 336) del libro impreso que contiene $$\mathrm\TeX$$el código fuente de [$$\mathrm\TeX\text{: The Program}$$](https://www.amazon.co.uk/Computers-Typesetting-Tex-Program-TEX/dp/0201134373). Sin embargo, para muchas personas (incluyéndome a mí) las explicaciones de Knuth son, en ocasiones, bastante compactas y concisas y, a veces, pueden ser difíciles de seguir en detalle: los ejemplos ilustrados siempre son muy útiles.

### Sí, las tablas son complejas

En la sección 768 (página 322) del libro [$$\mathrm\TeX\text{: The Program}$$](https://www.amazon.co.uk/Computers-Typesetting-Tex-Program-TEX/dp/0201134373), Knuth hace un comentario interesante:

> “Es algo así como un milagro siempre que `\halign` y `\valign` funcionan, porque atraviesan muchas de las estructuras de control de $$\mathrm\TeX$$.”

Además, el volumen IV de la serie de libros de cuatro volúmenes [$$\mathrm\TeX\text{ in Practice}$$](https://www.amazon.co.uk/Tex-Practice-Set-Stephan-Bechtolsheim/dp/038797296X/ref=sr_1_11?s=books\&ie=UTF8\&qid=1504256043\&sr=1-11\&keywords=TeX+in+Practice) dedica nada menos que 180 páginas (pp. 199–379) a crear tablas en $$\mathrm\TeX$$ a través de `\halign` y `\valign`.

Así que es seguro observar que $$\mathrm\TeX$$ las tablas son efectivamente “más bien delicadas”.

### Columnas abarcadas: \\\omit, \\\span y \\\multispan

Como se señaló, para explorar $$\mathrm\TeX$$los cálculos de ancho de columna de Knuth necesitamos usar “TeX en bruto” $$\mathrm\TeX$$; lo que esto significa es una combinación de comandos primitivos y una $$\text{Plain }\mathrm\TeX$$ macro llamada `\\multispan`. Aunque no vamos a usar estos comandos para ilustrar directamente nuestras tablas de ejemplo (es decir, explicando por completo todo el $$\mathrm\TeX$$ código), merece la pena incluir una breve nota explicándolos:

* `\halign`: Una de las dos $$\mathrm\TeX$$ primitivas (comandos) para crear tablas. La otra es `\valign` pero esa no se usa tanto y no se tratará en este artículo.
* `\omit`: Una $$\mathrm\TeX$$ primitiva (comando) que indica a $$\mathrm\TeX$$ que ignore la plantilla del preámbulo de una entrada de la tabla.
* `\span`: Una $$\mathrm\TeX$$ primitiva (comando) usada para combinar dos entradas adyacentes de la tabla.
* `\\multispan{n}`: Una simple $$\mathrm\TeX$$ macro para abarcar `n` columnas.

En esencia, para abarcar columnas $$\mathrm\TeX$$ ignora el número apropiado de plantillas del preámbulo de la tabla y combina el número requerido de entradas de la tabla en una sola entrada. `\\multispan{n}` funciona expandiéndose a la secuencia de `\omit` y `\span` tokens necesarios para abarcar `n` columnas. Por ejemplo, `\\multispan{3}` se expande a `\\omit\\span\\omit\\span\\omit`.

## Presentamos nuestra tabla “de referencia”

Aquí está nuestra tabla de referencia seguida de una versión anotada que explica los elementos usados en su construcción:

![{{{alt}}}](/files/9f956644037411f68e5655260012e0d9ddaa8bd0)

Modificando nuestra tabla de referencia observaremos qué sucede con el ancho de la tabla, y con el ancho de las columnas individuales, al añadir entradas que abarcan varias columnas. Esta tabla de referencia se produjo en TeX en bruto $$\mathrm\TeX$$ usando la `\\halign{...}` primitiva junto con una serie de macros personalizadas necesarias para componer las tablas —no discutiremos esas macros porque no son esenciales para entender los ejemplos y las explicaciones.

Aquí hay una versión anotada de nuestra tabla de referencia para explicar sus características:

![{{{alt}}}](/files/d468e1adb906fe641e5fb046413a442904e9c3de)

Nuestro primer conjunto de tablas de ejemplo, y la tabla de referencia inicial, tienen todo configurado `\\tabskip=0pt` para que $$\mathrm\TeX$$ no añada ningún espacio entre nuestras columnas: en efecto, todas se tocan entre sí. La razón para hacer esto es simplificar la discusión inicial y los cálculos subsiguientes; más adelante en el artículo reintroducimos `\tabskip` glue para examinar su efecto al calcular los anchos de las columnas abarcadas.

Como se señala en las anotaciones, hemos añadido una pequeña cantidad de espacio en blanco (5pt) al comienzo de todas las entradas de tabla que no abarcan columnas (excepto la primera fila). Ese espacio en blanco de 5pt forma parte del ancho total de todas las entradas que no abarcan columnas (excepto la primera fila) y se añadió solo para que la tabla se viera un poco menos recargada.

### Una breve nota sobre los anchos de las tablas

El `\\halign{...}` comando tiene tres formas:

* `\\halign{...}`: establece la tabla en el ancho que $$\mathrm\TeX$$ calcula, en función del tamaño de las entradas (y `\tabskip` glue);
* `\\halign to *ancho* {...}`: indica a $$\mathrm\TeX$$ que componerá la tabla con un `*ancho*`;
* `\\halign spread *cantidad*{...}`: ajusta el ancho calculado en `*cantidad*`.

Cuando $$\mathrm\TeX$$ compone una tabla usando `\\halign{...}` tiene que leer toda la tabla en memoria para realizar los diversos cálculos necesarios para componerla. En consecuencia, salvo que hayas especificado el ancho usando `\\halign to *ancho* {...}` no puedes conocer el ancho final hasta que $$\mathrm\TeX$$ haya terminado de procesarla (componerla). Una forma de obtener el ancho de una tabla producida por `\\halign{...}` es componer primero la tabla dentro de una `\vbox{...}` (por ejemplo, `\\setbox0=\\vbox{\\halign{...}}`) y luego, por ejemplo, usar `\\the\\wd0` para obtener el ancho.

### No hay salto automático de línea en las entradas de tabla

Es importante señalar que cuando $$\mathrm\TeX$$ está componiendo una tabla creada con `\\halign{...}` cualquier texto dentro de las entradas de tabla no se somete automáticamente a salto de línea: las entradas de tabla se componen en *modo horizontal restringido*—igual que una `\hbox`. Para habilitar el salto de línea, el texto de una entrada de tabla debe encerrarse dentro de una `\vbox{...}` junto con usar un valor apropiado para `\hsize` dentro de esa `\vbox{...}`. Sin embargo, observa que el texto dentro de un `\\noalign{...}` comando (una $$\mathrm\TeX$$ primitiva) usado en un `\\halign{...}` está sujeto al salto de línea de $$\mathrm\TeX$$TeX. En efecto, y como su nombre sugiere, `\\noalign{...}` permite a $$\mathrm\TeX$$ “escapar” del `\\halign{...}` y colocar material entre las filas de la tabla —normalmente para producir reglas horizontales entre las filas de la tabla.

### No permitido: \\\halign{...} dentro de \\\hbox{...}

No puedes *directamente* componer un `\\halign{...}` dentro de un `\hbox{...}`. Intentar usar `\\hbox{\\halign{...}}` generará un error bastante confuso:

```latex
! Missing } inserted.
<inserted text>
                }
<volver a leerse>
                   \halign
l.1 \\hbox{\\halign
```

#### Una explicación de este error

Debido al contenedor envolvente, `\hbox{...}` $$\mathrm\TeX$$ está en *modo horizontal restringido*modo horizontal; `\\halign{...}` detecta entonces *un comando de modo vertical.* Por ejemplo, si usas `\\halign{...}` dentro de un párrafo, $$\mathrm\TeX$$ terminará el párrafo, procesará el `\\halign{...}` y luego continuará con el resto del párrafo.

Cuando se usa dentro de un `\hbox{...}`, la `\\halign{...}` desencadena $$\mathrm\TeX$$ para intentar escapar de nuevo al modo vertical intentando forzar el cierre del grupo actual: $$\mathrm\TeX$$ informa de un “`! Missing }`” y emite un error porque cree que has cometido un error al usar el agrupamiento. Aunque una llave de cierre (`}`) puede no faltar en tu $$\mathrm\TeX$$ código, el mensaje de error es un síntoma de que `\hbox{...}` se está “interponiendo” y $$\mathrm\TeX$$ está haciendo su “mejor suposición” sobre el curso de acción adecuado para resolver el problema.

## Ejemplos de tablas con columnas abarcadas

La siguiente secuencia de gráficos de tablas proporciona una serie de ejemplos para demostrar el efecto de abarcar columnas de tabla: indicando que las entradas largas de tabla pueden tener resultados inesperados sobre el ancho de ciertas columnas y, en consecuencia, sobre el ancho de la tabla misma. La pregunta que vamos a abordar es qué hace $$\mathrm\TeX$$ cuando una determinada entrada de la tabla abarca varias columnas pero es “demasiado ancha para caber”. Como se señaló arriba, $$\mathrm\TeX$$ sí aplica un algoritmo específico a este problema de calcular anchos de columna: los siguientes ejemplos están diseñados para ayudar a desarrollar una “sensación” del funcionamiento de ese algoritmo.

### Tabla de ejemplo 1

En este ejemplo usamos `\\multispan{2}` para abarcar las columnas 1 y 2 con una entrada cuyo texto es **Un encabezado de tabla**:

![{{{alt}}}](/files/21a9b4cae9a9fa516681ccc1db4ca8f2e5953003)

#### Observaciones

* El ancho de esta tabla es el mismo que el de la [tabla de referencia](#reference-table): $$327.71722\text{pt}$$.
* El ancho de la entrada que abarca las columnas 1 y 2 es $$81.04953\text{pt}$$ que es menor que el ancho total de las entradas en las columnas que abarca: $$52.56676\text{pt} + 57.06679\text{pt} = 109.63355\text{pt}$$

## Tabla de ejemplo 2

Como en [Tabla de ejemplo 1](#example-table-1), este ejemplo también usa `\\multispan{2}` para abarcar las columnas 1 y 2, pero aquí usamos una entrada más larga cuyo texto es **Un encabezado de tabla un poco más largo**.

![{{{alt}}}](/files/adad3d68b84497719f67899b1c29b3ca01b8b625)

#### Observaciones

Si comparas este ejemplo con nuestra [tabla de referencia](#reference-table) podemos ver lo siguiente:

* El ancho de esta tabla ha aumentado de $$327.71722\text{pt}$$ a $$374.37032\text{pt}$$: un total de $$46.6531\text{pt}$$.
* El ancho de la entrada que abarca las columnas 1 y 2 ($$156.28664\text{pt}$$) es mayor que el ancho total de las entradas en las columnas que abarca: $$52.56676\text{pt} + 57.06679\text{pt} = 109.63355\text{pt}$$. Esa diferencia es $$156.28664\text{pt}-109.63355\text{pt} = 46.6531\text{pt}$$ que es la misma cantidad en que ha aumentado el ancho de la tabla.
* $$\mathrm\TeX$$ ha ajustado el ancho de la columna 2 para proporcionar el espacio adicional requerido. Más adelante veremos cómo $$\mathrm\TeX$$ calcula la cantidad en que debe aumentar la columna 2.
* La columna 1 no se ve afectada: su ancho no ha sido afectado por la entrada que abarca las columnas 1 y 2.

### Tabla de ejemplo 3

En este ejemplo usamos `\\multispan{3}` para abarcar las columnas 1 a 3 con una entrada cuyo texto es el mismo que el de [Tabla de ejemplo 2](#example-table-2): **Un encabezado de tabla un poco más largo**.

![{{{alt}}}](/files/3d9a2c11dba3e4e2b3c86da3c6b74ec16e668341)

#### Observaciones

* El ancho de esta tabla es el mismo que el de la [tabla de referencia](#reference-table): $$327.71722\text{pt}$$.
* El ancho de la entrada que abarca las columnas 1 a 3 ($$156.28664\text{pt}$$) es menor que el ancho total de las entradas en las tres columnas que abarca: $$52.56676\text{pt} + 57.06679\text{pt} + 59.03899\text{pt} = 168.67254\text{pt}$$.
* Ninguno de los anchos de columna se ha visto afectado por la entrada que abarca las columnas 1 a 3.

¿Empiezas a ver que surge un patrón?

### Tabla de ejemplo 4

Como en [Tabla de ejemplo 3](#example-table-3), aquí usamos `\\multispan{3}` para abarcar las columnas 1 a 3, pero esta vez con una entrada cuyo texto es considerablemente más largo: **Un encabezado de tabla considerablemente más largo que se extiende mucho**.

![{{{alt}}}](/files/3a01d36c6100fb2302ea3a7a4dd2074ffd94aa05)

#### Observaciones

* En comparación con la [tabla de referencia](#reference-table), el ancho de esta tabla ha aumentado de $$327.71722\text{pt}$$ a $$465.95685\text{pt}$$: un aumento de $$138.23963\text{pt}$$.
* El ancho de la entrada que abarca las columnas 1 a 3 es $$306.91216\text{pt}$$.
* El ancho total de las entradas en las tres columnas abarcadas es $$52.56676\text{pt} + 57.06679\text{pt} + 59.03899\text{pt} = 168.67254\text{pt}$$.
* La diferencia de ancho entre la entrada larga que abarca y las entradas en las columnas 1 a 3 es $$306.91216\text{pt}-168.67254\text{pt}=138.23962\text{pt}$$. La misma cantidad (¡con 4 decimales!) en que ha aumentado el ancho de la tabla.
* Solo la columna 3 ha aumentado su ancho: ni la columna 1 ni la columna 2 se ven afectadas.

#### Surge un patrón

Si miramos [Tabla de ejemplo 2](#example-table-2) y [Tabla de ejemplo 4](#example-table-4) podemos ver que en ambos casos es la **última columna del intervalo** la que aumentó su ancho para hacer espacio para la entrada larga que abarcaba las columnas:

* En [Tabla de ejemplo 2](#example-table-2): La entrada larga abarcaba las columnas 1 y 2. La columna 2 se “estiró”.
* En [Tabla de ejemplo 4](#example-table-4): La entrada larga abarcaba las columnas 1 a 3. La columna 3 se “estiró”.

#### El ancho de la columna 3: ¿Surge un algoritmo?

Los siguientes cálculos dan una indicación más clara de lo que $$\mathrm\TeX$$ está haciendo. Esto es lo que sabemos:

* El ancho de la entrada larga que abarca las columnas 1 a 3 es $$306.91216\text{pt}$$.
* El ancho total de las entradas en las columnas 1 y 2 es $$52.56676\text{pt} + 57.06679\text{pt} = 109.63355\text{pt}$$.

¿Cuál es la diferencia entre esos valores? Es $$306.91216\text{pt}-109.63355\text{pt} = 197.2786\text{pt}$$ y este es el ancho usado para la columna 3: surge directamente del algoritmo usado por $$\mathrm\TeX$$.

### Tabla de ejemplo 5

Antes de pasar a un ejemplo más complicado, aquí hay otro ejemplo “simple”. Esta tabla contiene la misma entrada extensa que [Tabla de ejemplo 4](#example-table-4): **Un encabezado de tabla considerablemente más largo que se extiende mucho**; sin embargo, esta vez usamos `\\multispan{6}` lo que permite que esa entrada abarque toda la tabla. Como puedes ver, la tabla resultante sigue teniendo el mismo ancho que nuestra [tabla de referencia](#reference-table) ($$327.71722\text{pt}$$) lo que significa que ninguna columna se ha visto afectada por esta entrada muy larga. Claramente, esto se debe a que el ancho de la entrada ($$306.91216\text{pt}$$) es menor que el ancho total de todas las entradas que está abarcando: $$327.71722\text{pt}$$; es decir, el ancho de la tabla.

![{{{alt}}}](/files/2eee3c32de8c9bd66afb398a0380f7b1c183aab5)

### Tabla de ejemplo 6: Un poco más complicada

Aquí vemos una serie de tres tablas de ejemplo (6(a)–6(c)) para mostrar el efecto de dos entradas diferentes que ambas se extienden hasta la columna 5. [Tabla de ejemplo 6(a)](#example-table-6a) y [Tabla de ejemplo 6(b)](#example-table-6b) cada una muestra una tabla que contiene una sola entrada que abarca varias columnas hasta la columna 5. [Tabla de ejemplo 6(c)](#example-table-6c) combina ambas entradas que abarcan en una sola tabla y plantea la pregunta: ¿qué entrada determina realmente el ancho de la columna 5, y por qué? La respuesta nos lleva a la esencia del algoritmo usado por $$\mathrm\TeX$$.

#### Tabla de ejemplo 6(a)

![{{{alt}}}](/files/4076c34f03f47934a053719f9621843d821aed3b)

**Observaciones**

* En comparación con la [tabla de referencia](#reference-table), el ancho de esta tabla ha aumentado de $$327.71722\text{pt}$$ a $$371.11153\text{pt}$$: un aumento de $$43.39431\text{pt}$$.
* El ancho de la entrada que abarca las columnas 3 a 5 es $$215.06683\text{pt}$$.
* El ancho total de las entradas en las columnas 3 a 5 es $$59.03899\text{pt} + 52.98344\text{pt} + 59.6501\text{pt} = 171.67253\text{pt}$$.
* La diferencia de ancho entre las entradas abarcadas en las columnas 3 a 5 y el ancho de la entrada que abarca es $$215.06683\text{pt}-171.67253\text{pt}=43.3943\text{pt}$$: la cantidad exacta (¡con 4 decimales!) en que ha aumentado el ancho de la tabla.

#### Tabla de ejemplo 6(b)

![{{{alt}}}](/files/c6e600eda6ed0caf1878f3428fef387ca8dab278)

**Observaciones**

* En comparación con la [tabla de referencia](#reference-table), el ancho de esta tabla ha aumentado de $$327.71722\text{pt}$$ a $$353.3233\text{pt}$$: un aumento de $$25.60608\text{pt}$$.
* El ancho de la entrada que abarca las columnas 1 a 5 es $$306.91216\text{pt}$$.
* El ancho total de las entradas en las columnas 1 a 5 es $$52.56676\text{pt} + 57.06679\text{pt} + 59.03899\text{pt} + 52.98344\text{pt} + 59.6501\text{pt} = 281.30608\text{pt}$$.
* La diferencia de ancho entre las entradas abarcadas en las columnas 1 a 5 y el ancho de la entrada que abarca es $$306.91216\text{pt}-281.30608\text{pt}=25.60608\text{pt}$$: **note** esto es *menor* que el valor calculado para [Ejemplo 6(a)](#example-table-6a), que era $$43.3943\text{pt}$$.

#### Tabla de ejemplo 6(c)

Aquí combinamos las entradas de las tablas de ejemplo [6(a)](#example-table-6a) y [6(b)](#example-table-6b) en una sola tabla: ¿qué ocurre?

![{{{alt}}}](/files/84d121989b50dea37e4296c861ebb7bd20bda6dd)

**Observación**

* En comparación con la [tabla de referencia](#reference-table), el ancho de esta tabla ha aumentado de $$327.71722\text{pt}$$ a $$371.11153\text{pt}$$: un aumento de $$43.39431\text{pt}$$. Observamos que esto es exactamente igual a [Tabla de ejemplo 6(a)](#example-table-6a).

#### ¿Qué está $$\mathrm\TeX$$ haciendo?

Para entender los resultados del $$\mathrm\TeX$$algoritmo y los procesos de decisión de TeX observamos que esta entrada

![{{{alt}}}](/files/7aa9e9664bc7a13c6cb29f5615f0b32f5db6a2b1)

se extiende más allá de las entradas abarcadas por $$25.60608\text{pt}$$; sin embargo, esta entrada

![{{{alt}}}](/files/517a4c2158f72840e40ae2765a60981b0c4e0acc)

se extiende aún más allá de las entradas abarcadas: en $$43.3943\text{pt}$$. Por lo tanto, esa entrada “gana la carrera” y la columna 5 ve aumentado su ancho por el **máximo** de estos dos valores ($$43.3943\text{pt}$$). El ancho de la columna 5 ahora pasa a ser $$59.6501\text{pt} + 43.3943\text{pt} = 103.0444\text{pt}$$ para acomodar la entrada que abarca las columnas 3 a 5. Nuestra descripción de la secuencia exacta de “acontecimientos” se simplifica un poco, pero el resultado es el que hemos descrito.

## Recuperando algo de complejidad

Para minimizar la complejidad de nuestras discusiones (hasta ahora) hemos usado ejemplos relativamente sencillos para demostrar los principios del $$\mathrm\TeX$$algoritmo de TeX; en particular, establecemos `\\tabskip=0pt`. En la práctica, es probable que las tablas del “mundo real” tengan muchas entradas que abarquen un rango de columnas y, por supuesto, tendrán valores distintos de cero para el `\tabskip` glue —un tema al que volveremos ahora.

### \\\tabskip glue y anchos de columnas abarcadas

El diseño de tablas a menudo requiere añadir espacio en blanco entre columnas y, por supuesto, $$\mathrm\TeX$$ dispone de esta facilidad mediante un comando primitivo llamado `\tabskip`. Este comando puede usarse para poner glue fijo o flexible (espaciado):

* antes de una tabla (es decir, a la izquierda de la columna 1);
* entre una o más columnas;
* después de la tabla (es decir, a la derecha de la última columna).

Aquí hay un ejemplo para recordarlo:

![{{{alt}}}](/files/b3e12dd809ac9d6cee1a5a85f50b9bde39858a52)

### ¿Cómo afecta el glue de \\\tabskip a los anchos de las columnas abarcadas?

La presencia de glue distinto de cero `\tabskip` entre columnas proporciona espacio adicional que las entradas abarcadas pueden “absorber” antes de que $$\mathrm\TeX$$ tenga que pensar en aumentar el ancho de la última columna de un intervalo.

En nuestro siguiente ejemplo usaremos dos tablas para comparar los resultados de abarcar dos columnas. La única diferencia entre las tablas es el uso de `\tabskip` glue.

* El primer ejemplo usa nuestra tabla original de “referencia” que, si recuerdas, tiene configurado `\\tabskip=0pt`.
* El segundo ejemplo usa una versión modificada de nuestra [tabla de referencia](#reference-table) (anotada arriba) que tiene `\\tabskip=10pt` antes y después de la tabla, pero, lo que es más importante, tiene configurado `\\tabskip=20pt` entre las columnas.

Dentro de la *modificada* tabla de referencia, las dos columnas abarcadas no tienen ningún efecto sobre los anchos de columna (y el ancho de la tabla), pero sí afectan al ancho de la columna 2 (y al ancho de la tabla) en la *original* [tabla de referencia](#reference-table).

### Tabla de referencia original: \\\tabskip=0pt

Aquí mostramos nuestra tabla [tabla de referencia](#reference-table) original junto con una segunda tabla (derivada de nuestra tabla original [tabla de referencia](#reference-table)) que tiene una entrada “**Probar un encabezado de tabla más largo**” abarcando las columnas 1 y 2. Está clarísimo que la columna 2 (de la segunda tabla del diagrama) y, por tanto, toda la tabla, se ven afectadas por las columnas abarcadas.

![{{{alt}}}](/files/de90f600a5092b51473f79c4fc5dd15989808af7)

### Tabla de referencia modificada: \\\tabskip=20pt

Aquí mostramos nuestra tabla de referencia modificada junto con una segunda tabla (derivada de nuestra tabla de referencia modificada) que también tiene una entrada “**Probar un encabezado de tabla más largo**” abarcando las columnas 1 y 2. Está clarísimo que, dentro de la segunda tabla del diagrama, ni el ancho de la columna 2 ni el de la tabla se ven afectados por las columnas abarcadas. En este caso, la presencia de `\tabskip` glue (`20pt`) entre las columnas ha ayudado a “absorber” el espacio requerido por el texto de la entrada que abarca las columnas 1 y 2:

![{{{alt}}}](/files/8139cc4e4cf2c5a495f7cc15acecc3c026456324)

## La esencia del $$\mathrm\TeX$$algoritmo de Knuth

Esperemos que la variedad de ejemplos proporcionados arriba haya ayudado a desarrollar una “sensación” de lo que $$\mathrm\TeX$$ hace para acomodar las entradas abarcadas y cómo $$\mathrm\TeX$$ ajustará, si es necesario, el ancho de la **última** columna dentro de cada rango de columnas abarcadas. Además del ancho de las entradas dentro de las columnas individuales que se abarcan, la presencia de `\tabskip` glue distinto de cero es un factor importante que $$\mathrm\TeX$$ tiene en cuenta al decidir si necesita ajustar algún ancho de columna. El punto clave para recordar es que $$\mathrm\TeX$$tabla **última columna** dentro de cada intervalo de columnas abarcadas.

### Ejemplo final de tabla: últimas columnas en un intervalo abarcado

En este ejemplo final volvemos a usar nuestra tabla de referencia modificada (con `\tabskip` los valores de glue comentados arriba) para derivar otra tabla que contiene varias columnas abarcadas por reglas; hemos usado reglas para hacer que los intervalos sean más fáciles de ver.

Las dos tablas han sido alineadas cuidadosamente para mostrar que, en la tabla superior, ninguna columna anterior a la columna 5 ha sido afectada por las columnas abarcadas. El área verde más oscura a la izquierda del diagrama muestra que las columnas 1 a 4 de ambas tablas siguen alineadas perfectamente. A la derecha hay un área sombreada en verde más claro que muestra que solo las columnas 5 y 6 han sido afectadas por las entradas abarcadas.

En la tabla superior, los intervalos abarcados son los siguientes:

* columnas 1 a 5: abarcadas por una $$400\text{pt}$$ regla;
* columnas 3 a 5: abarcadas por una $$200\text{pt}$$ regla;
* columnas 4 a 6: abarcadas por una $$250\text{pt}$$ regla.

![{{{alt}}}](/files/68412f319709ec8027f57c147f180fead1bae5b7)

Una vez más, la explicación es que, dentro de una serie de columnas abarcadas, solo se ajusta el ancho de la columna final (si es necesario): las columnas intermedias no se ven afectadas y eso aquí significa las columnas 1 a 4 —aunque, por supuesto, el ancho de las columnas 1 a 4 (y el glue intermedio `\tabskip` ) se tiene en cuenta al calcular los anchos ajustados de las columnas 5 y 6.

### Un recorrido de $$\mathrm\TeX$$algoritmo de Knuth

Concluiremos con un *simplificado* recorrido de «$$\mathrm\TeX$$los procesos de pensamiento» de $$\mathrm\TeX$$mientras calcula los anchos de las columnas en entradas abarcadas. Describir los algoritmos de $$\mathrm\TeX$$el código fuente de [$$\mathrm\TeX\text{: The Program}$$](https://www.amazon.co.uk/Computers-Typesetting-Tex-Program-TEX/dp/0201134373).

Las tablas del mundo real a menudo se crean con muchos usos de la `\span` primitiva (p. ej., dentro de $$\mathrm\LaTeX$$ paquetes) para construir múltiples instancias de columnas abarcadas dentro de la tabla. Para gestionar esto, las estructuras de datos (en lo más profundo de $$\mathrm\TeX$$) mantienen información (las llamadas *nodos de span*) que le indican a $$\mathrm\TeX$$ acerca de los vínculos (spans) entre entradas/columnas de la tabla. Claramente, $$\mathrm\TeX$$ tiene que aplicar sus algoritmos de manera sistemática y tendrá que procesar la tabla completa para hacer sus cálculos finales —para determinar todos los anchos de columna, el ancho total de la tabla y, si es necesario, la cantidad por la cual los glue flexibles usados en la tabla tienen que estirarse o encogerse. No es realmente sorprendente que $$\mathrm\TeX$$ no pueda decirte el ancho final de la tabla hasta que haya procesado completamente el `\\halign{...}` comando; ¡realmente tiene mucho trabajo que hacer!

El punto de partida para los cálculos de ancho de columna es la columna 1 porque, por supuesto, nada puede abarcar desde la izquierda de (y *a través de/en*) la columna 1. $$\mathrm\TeX$$ comienza determinando el ancho de la columna 1 al averiguar qué entrada tiene el mayor *ancho natural*. Llamemos a ese ancho máximo $$w\_1$$y si hay entradas que se extienden desde la columna 1 hasta la columna 2 llamemos al ancho de esa entrada $$w\_{12}$$ (ancho de 1 a 2). Además, denotaremos el `\tabskip` glue entre las columnas 1 y 2 como $$t\_{1}$$—obsérvese que solo estamos considerando el *ancho natural* ancho natural `\tabskip` de ese $$w\_2$$.

El punto clave a observar es que $$\mathrm\TeX$$ está tratando de calcular el ancho de la columna 2 considerando solo aquellas entradas cuyo span *empieza* con la columna 1 y *termina* en la columna 2. La consideración clave para $$\mathrm\TeX$$ es la prueba $$\max(w\_{2}, w\_{12} - (w\_1+ t\_1))$$—podría haber múltiples entradas que abarcan las columnas 1 y 2: algunas pueden ser estrechas (pequeñas $$w\_{12}$$pequeñas $$w\_{12}$$grandes $$\mathrm\TeX$$ está buscando la que tenga el mayor efecto (de ahí el $$\max(\text{...})$$máximo). Aquí, el valor de $$w\_{12} -(w\_1+ t\_1)$$ es la cantidad por la cual una entrada que abarca las columnas 1 y 2 «se desborda» de la columna 1 hacia la columna 2: obsérvese que $$\mathrm\TeX$$ está usando el ancho de la columna 1 **y** el `\tabskip` glue ($$t\_{1}$$) entre las columnas 1 y 2. Una vez $$\mathrm\TeX$$ haya determinado si algún intervalo desde la columna 1 hasta la 2 afecta el ancho de la columna 2, establece el ancho de la columna 2 al valor máximo que ha determinado (usando la prueba descrita). $$\mathrm\TeX$$ continúa avanzando por todas las demás columnas, realizando pruebas similares.

Y por último, solo para completar, aquí citamos la esencia del $$\mathrm\TeX$$algoritmo de $$\mathrm\TeX$$):

Sea $$w\_{ij}$$ el máximo de los anchos naturales de todas las entradas que abarcan las columnas $$i$$ a través de $$j$$, inclusive. Los anchos finales de las columnas se definen mediante la fórmula

$$\begin{equation\*} w\_j=\max\_{1\leq i\leq j}\biggl(w\_{ij}-\sum\_{i\leq k< j}(t\_k+w\_k)\biggr) \end{equation\*}$$

donde $$t\_k$$ es el ancho natural del glue tabskip entre las columnas $$k$$ y $$k+1$$.

## Colofón: uso de Overleaf para producir tablas como gráficos SVG

Todas $$\mathrm\TeX$$ las tablas presentadas en este artículo son archivos de Gráficos Vectoriales Escalables (SVG) producidos en la plataforma Overleaf. Las anotaciones (flechas y cajas verdes) se añadieron abriendo el gráfico SVG en Inkscape —sin embargo, obsérvese que el texto de las anotaciones se compuso en $$\mathrm\TeX$$ como texto adicional para acompañar la tabla: solo las flechas y los fondos verdes se añadieron en Inkscape. Si te interesa saber cómo se logró esto, sigue leyendo.

Los servidores de Overleaf usan la $$\mathrm\TeX \text{ Live}$$ distribución que, además de $$\mathrm\TeX$$los motores de composición basados en $$\mathrm\TeX$$, proporciona una gran cantidad de herramientas y utilidades de software muy útiles relacionadas con [`dvisvgm`](https://dvisvgm.de) que, como su nombre indica, convierte $$\mathrm\TeX$$del DVI tradicional (**D**e**V**i **v**I) en SVG. Entre sus muchas [opciones de línea de comandos](https://dvisvgm.de/Manpage/) `dvisvgm` ofrece una opción (`-n` o `--no-fonts`) que le indicará que convierta todo el texto en *trazados* lo que significa que el texto en los gráficos SVG se dibuja usando líneas y curvas en lugar de fuentes y glifos reales. Esto puede aumentar el tamaño del archivo del gráfico SVG resultante, pero garantiza que los gráficos SVG sean extremadamente portables y casi seguros de funcionar bien en cualquier dispositivo.

### Entonces... ¿cómo se hizo?

En un [artículo anterior](https://www.overleaf.com/blog/510-using-luatex-to-run-tools-and-utilities-installed-on-overleafs-servers) hablé de cómo puedes usar $$\text{Lua}\mathrm\TeX$$ para ejecutar las diversas herramientas y utilidades de software instaladas en los servidores de Overleaf: es una técnica extremadamente fácil y cómoda. Esa técnica se usó para generar gráficos SVG de $$\mathrm\TeX$$ tablas, de la siguiente manera. Desde dentro del archivo principal $$\mathrm\TeX$$ del documento, el código para componer cada tabla (creado usando `\halign`) se escribió en un archivo `.tex` archivo `\beginscoop` y `\endscoop`. Hay muchas otras maneras posibles de lograr los resultados deseados, pero aquí están las definiciones de las macros que usé:

```latex
\def\cc{\catcode`\#=12\relax}
\long\def\scoop#1\endscoop{\global\fulltoks={#1}\egroup}
\def\beginscoop{\global\advance\numfigs by1\relax\bgroup\cc\scoop}
```

Las usas así:

```latex
\beginscoop
\\halign{...}
\endscoop
```

Tenga en cuenta que el `\endscoop` token simplemente sirve para delimitar el parámetro de `\scoop` macro: $$\mathrm\TeX$$ descarta efectivamente el `\endscoop` token, así que en realidad no necesitamos definirlo (por ejemplo, mediante `\def\endscoop{...}`).

El $$\mathrm\TeX$$ el código contenido en el `\\halign{...}` se guarda en un `registro` de toks llamado `\fulltoks`. Un punto complicado con el que me encontré (con $$\text{Lua}\mathrm\TeX$$) fue la necesidad de impedir que los caracteres `#` dentro del preámbulo se “duplicaran” a `\\halign{...}` cuando se escribieran en un `##` archivo. Para evitar esto, tuve que establecer temporalmente los caracteres `.tex` a 12 antes de guardar el `\catcode`de `#` código (tokens) en el $$\mathrm\TeX$$ registro de tokens. `\fulltoks` El siguiente paso es escribir los tokens contenidos en

como un `\fulltoks` archivo —como estaba usando $$\mathrm\TeX$$ esto resultó ser $$\text{Lua}\mathrm\TeX$$ fácil gracias a la maravillosa API Lua de *extremadamente* . En resumen, escribí una macro llamada $$\text{Lua}\mathrm\TeX$$\writefile{...} `que toma como parámetro el nombre de un registro de tokens cuyos tokens quieres escribir en un archivo (p. ej.,` \writefile{fulltoks} `). Dentro de la macro`utilicé la API Lua para obtener una representación textual del `que toma como parámetro el nombre de un registro de tokens cuyos tokens quieres escribir en un archivo (p. ej.,` registro de tokens: `\fulltoks` \def\writefile#1{%

```latex
\directlua{
local p=tex.toks["#1"]
...
...
 Aquí hay una captura de pantalla que muestra un poco más de la
...
...
}}
```

El lenguaje Lua y la API Lua proporcionada por `que toma como parámetro el nombre de un registro de tokens cuyos tokens quieres escribir en un archivo (p. ej.,` comando:

[![{{{alt}}}](/files/3f01e37feecc8cab9a7610a7ff0ac179924ba55e)](https://www.filepicker.io/api/file/ngeDmgRStGWvG044RE1A)

a menudo pueden simplificar $$\text{Lua}\mathrm\TeX$$ las tareas de programación y es debido a estas características útiles y potentes que he usado $$\mathrm\TeX$$ desde \~2009 —y sigo siendo un gran fan de este verdaderamente maravilloso $$\text{Lua}\mathrm\TeX$$ motor. Vale, el $$\mathrm\TeX$$ anuncio ahora concluye. $$\text{Lua}\mathrm\TeX$$ Habiendo obtenido tan fácilmente el

código almacenado en $$\mathrm\TeX$$ se escribe en un archivo junto con algo de código adicional para convertirlo en un `\fulltoks` archivo correctamente formado. Los siguientes pasos son: $$\mathrm\LaTeX$$ Procesar el

1. archivo que contiene nuestra tabla con `.tex` (en modo DVI) para que componga la tabla y genere un archivo $$\text{pdf}\mathrm\LaTeX$$ para que `.dvi` lo procese. Sí, puedes usar `dvisvgm` para ejecutar $$\text{Lua}\mathrm\TeX$$ —nuevamente utilicé el método discutido en un $$\text{pdf}\mathrm\LaTeX$$Y por último, ejecutar [artículo anterior](/latex/es/articulos-en-profundidad/52-using-luatex-to-run-tools-and-utilities-installed-on-overleaf-s-servers.md).
2. para procesar el archivo `dvisvgm` para generar un gráfico SVG de la tabla compuesta. `.dvi` Para obtener los gráficos SVG reales puedes descargar un archivo ZIP de Overleaf —asegurándote de seleccionar los $$\mathrm\TeX$$ Archivos de entrada y salida
3. To obtain the actual SVG graphics you can download a ZIP file from Overleaf—making sure to select the **Input and Output Files** opción.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://overleaf-pro.ayaka.space/latex/es/articulos-en-profundidad/47-tex-tables-how-tex-calculates-spanned-column-widths.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.