> 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/overleaf-learn-latex-pt/artigos-aprofundados/47-tex-tables-how-tex-calculates-spanned-column-widths.md).

# Tabelas TeX: Como o TeX calcula larguras de colunas que abrangem várias colunas

## O objetivo deste artigo

Neste artigo, exploramos como $$\mathrm\TeX$$ calcula as larguras das colunas da tabela quando as tabelas contêm entradas (por exemplo, cabeçalhos de tabela) que abrangem várias colunas (por exemplo, usando o $$\mathrm\TeX$$ primitivos `\omit` e `\span`). Usando uma simples [tabela “de referência”](#reference-table) como ponto de partida, criamos uma série de exemplos — derivados dessa tabela de referência — alterando várias entradas para criar colunas abrangidas. Ao examinar o efeito dessas alterações, podemos começar a desenvolver uma compreensão do algoritmo subjacente que $$\mathrm\TeX$$ usa para calcular a largura das colunas abrangidas.

### Usando $$\mathrm\TeX$$ contém $$\mathrm\LaTeX$$

Para examinar e explicar *como* $$\mathrm\TeX$$ decide as larguras das colunas abrangidas, é necessário deixar de lado qualquer um dos maravilhosos $$\mathrm\LaTeX$$ pacotes de tabelas e voltar aos comandos fundamentais, de baixo nível (primitivos), para criação de tabelas: em particular, `\halign{...}`, `\span` e `\omit`. [Os pacotes de tabelas existentes $$\mathrm\TeX$$/$$\mathrm\LaTeX$$ pacotes de tabelas](https://ctan.org/topic/table) são, obviamente, ferramentas essenciais de produtividade e fornecem uma grande variedade de funcionalidades extremamente úteis que permitem aos utilizadores produzir rapidamente uma vasta gama de material tabular usando $$\mathrm\LaTeX$$. Esses pacotes fornecem uma essencial “estrutura macro” construída em torno do comportamento de baixo nível de $$\mathrm\TeX$$e os seus desenvolvedores fornecem abstrações muito bem-vindas e camadas de isolamento que cuidam das complexidades subjacentes. Muitos desses pacotes são verdadeiramente proezas incríveis de programação complexa: todos nós deveríamos ser gratos por eles existirem para nos poupar de ter de usar código bruto $$\mathrm\TeX$$ programação: todos nós deveríamos ser gratos por eles existirem para nos poupar de ter de usar código bruto $$\mathrm\TeX$$!

O algoritmo real que $$\mathrm\TeX$$ usa para calcular as larguras das colunas abrangidas é explicado na página 245 do [$$\mathrm\TeX\text{book}$$](https://www.amazon.co.uk/TeXbook-Donald-E-Knuth/dp/0201134489) e, com mais detalhes, na Secção 801 (página 336) do livro impresso que contém $$\mathrm\TeX$$o código-fonte de [$$\mathrm\TeX\text{: The Program}$$](https://www.amazon.co.uk/Computers-Typesetting-Tex-Program-TEX/dp/0201134373). No entanto, para muitas pessoas (incluindo eu), as explicações de Knuth são, por vezes, bastante compactas e sucintas e, em certos momentos, podem ser difíceis de acompanhar em detalhe: exemplos ilustrados são sempre muito úteis.

### Sim, as tabelas são complexas

Na secção 768 (página 322) do livro [$$\mathrm\TeX\text{: The Program}$$](https://www.amazon.co.uk/Computers-Typesetting-Tex-Program-TEX/dp/0201134373), Knuth faz um comentário interessante:

> “É quase um milagre sempre que `\halign` e `\valign` funcionam, porque atravessam tantas das estruturas de controlo de $$\mathrm\TeX$$.”

Além disso, o Volume IV da série de livros de quatro volumes [$$\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 do que 180 páginas (pp. 199–379) à criação de tabelas em $$\mathrm\TeX$$ através de `\halign` e `\valign`.

Assim, é seguro observar que $$\mathrm\TeX$$ as tabelas são de facto “bastante complicadas”.

### Colunas abrangidas: \omit, \span e \multispan

Como foi observado, para explorar $$\mathrm\TeX$$os cálculos de largura das colunas de $$\mathrm\TeX$$; isto significa uma combinação de comandos primitivos e um $$\text{Plain }\mathrm\TeX$$ macro chamado `\multispan`. Embora não usemos estes comandos para ilustrar diretamente as nossas tabelas de exemplo (isto é, explicando completamente todo o $$\mathrm\TeX$$ código), vale a pena incluir uma breve nota a explicá-los:

* `\halign`: Um dos dois $$\mathrm\TeX$$ primitivos (comandos) para criar tabelas. O outro é `\valign` mas esse não é tão amplamente usado e não será discutido neste artigo.
* `\omit`: Um $$\mathrm\TeX$$ primitivo (comando) que instrui $$\mathrm\TeX$$ a ignorar um modelo de preâmbulo de uma entrada de tabela.
* `\span`: Um $$\mathrm\TeX$$ primitivo (comando) usado para combinar duas entradas adjacentes de tabela.
* `\multispan{n}`: Uma macro $$\mathrm\TeX$$ simples do `n` para abranger

Em essência, para abranger colunas $$\mathrm\TeX$$ ignora o número apropriado de modelos de preâmbulo da tabela e combina o número necessário de entradas de tabela numa única entrada. `\multispan{n}` funciona expandindo-se para a sequência de `\omit` e `\span` tokens necessários para abranger `n` colunas. Por exemplo, `\multispan{3}` expande-se para `\omit\span\omit\span\omit`.

## Apresentando a nossa tabela “de referência”

Aqui está a nossa tabela de referência seguida de uma versão anotada que explica os elementos usados na sua construção:

![{{{alt}}}](/files/2056d22d9e4de160f2c389c7f42b1fcbbb732848)

Ao alterarmos a nossa tabela de referência, observaremos o que acontece à largura da tabela, e à largura das colunas individuais, à medida que adicionamos entradas que abrangem várias colunas. Esta tabela de referência foi produzida em TeX bruto $$\mathrm\TeX$$ usando o `\halign{...}` primitivo juntamente com um número de macros personalizadas necessárias para compor as tabelas — não vamos discutir essas macros porque não são essenciais para compreender os exemplos e explicações.

Aqui está uma versão anotada da nossa tabela de referência para explicar as suas características:

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

O nosso primeiro conjunto de tabelas de exemplo, e a tabela de referência inicial, têm todos definido `\tabskip=0pt` para que $$\mathrm\TeX$$ não adicione qualquer espaço entre as nossas colunas: na prática, elas ficam todas em contacto umas com as outras. A razão para fazer isto é simplificar a discussão inicial e os cálculos subsequentes — mais adiante no artigo reintroduzimos o `\tabskip` glue não nulo para examinar o seu efeito no cálculo das larguras das colunas abrangidas.

Como foi observado nas anotações, adicionámos uma pequena quantidade de espaço em branco (5pt) no início de todas as entradas de tabela não abrangidas (exceto na primeira linha). Esse espaço em branco de 5pt faz parte da largura total de todas as entradas não abrangidas (exceto na primeira linha) e foi adicionado apenas para tornar a tabela um pouco menos carregada.

### Uma breve nota sobre as larguras das tabelas

O `\halign{...}` comando tem três formas:

* `\halign{...}`: define a tabela para qualquer largura que $$\mathrm\TeX$$ calcula, com base no tamanho das entradas (e no `\tabskip` glue);
* `\halign to *width* {...}`: instrui $$\mathrm\TeX$$ a compor a tabela para uma `*largura*`;
* `\halign spread *amount*{...}`: ajusta a largura calculada em `*amount*`.

Quando $$\mathrm\TeX$$ compõe uma tabela usando `\halign{...}` tem de ler toda a tabela para a memória para realizar os vários cálculos necessários para a compor. Consequentemente, a menos que tenha especificado a largura usando `\halign to *width* {...}` não pode saber a largura final até $$\mathrm\TeX$$ ter terminado de a processar (compor). Uma forma de obter a largura de uma tabela produzida por `\halign{...}` é primeiro compor a tabela dentro de uma `\vbox{...}` (por exemplo, `\setbox0=\vbox{\halign{...}}`) e depois, por exemplo, usar `\the\wd0` para obter a largura.

### Sem quebra automática de linhas nas entradas da tabela

É importante notar que, quando $$\mathrm\TeX$$ está a compor uma tabela criada com `\halign{...}` qualquer texto dentro das entradas da tabela não é automaticamente sujeito a quebra de linha: as entradas da tabela são compostas em *modo horizontal restrito*—tal como um `\hbox`. Para ativar a quebra de linha, o texto de uma entrada de tabela precisa de ser encerrado dentro de um `\vbox{...}` juntamente com o uso de um valor apropriado para `\hsize` dentro desse `\vbox{...}`. Note, porém, que o texto dentro `\noalign{...}` comando (um $$\mathrm\TeX$$ primitivo) usado numa `\halign{...}` está sujeito à quebra de linha de $$\mathrm\TeX$$’. Na prática, e como o nome indica, `\noalign{...}` permite a $$\mathrm\TeX$$ escapar da `\halign{...}` e colocar material entre as linhas da tabela — normalmente para produzir linhas horizontais entre as linhas da tabela.

### Não permitido: \halign{...} dentro de \hbox{...}

Não é possível *diretamente* compor um `\halign{...}` dentro de um `\hbox{...}`. Tentar usar `\hbox{\halign{...}}` gerará um erro bastante confuso:

```latex
! Falta } inserida.
<inserted text>
                }
<para ser lido de novo>
                   \halign
l.1 \hbox{\halign
```

#### Uma explicação deste erro

Devido ao `\hbox{...}` $$\mathrm\TeX$$ de contenção, o *modo horizontal restrito*está em `\halign{...}` ; então deteta *modo vertical* comando. Por exemplo, se usar `\halign{...}` dentro de um parágrafo, $$\mathrm\TeX$$ irá terminar o parágrafo, processar o `\halign{...}` e depois continuar com o resto do parágrafo.

Quando usado dentro de um `\hbox{...}`, a `\halign{...}` aciona $$\mathrm\TeX$$ para tentar escapar de volta para o modo vertical, tentando forçar o fecho do grupo atual: $$\mathrm\TeX$$ apresenta um “`! Missing }`” e emite um erro porque pensa que cometeu um erro no uso de agrupamento. Embora uma chaveta direita (`}`) possa não estar em falta no seu $$\mathrm\TeX$$ código, a mensagem de erro é um sintoma de `\hbox{...}` a “interferir” e $$\mathrm\TeX$$ a fazer a sua “melhor suposição” sobre a ação apropriada para resolver o problema.

## Exemplos de tabelas com colunas abrangidas

A sequência seguinte de gráficos de tabelas fornece uma gama de exemplos para demonstrar o efeito de abranger colunas da tabela: indicando que entradas de tabela extensas podem ter resultados inesperados na largura de certas colunas — e, consequentemente, na largura da própria tabela. A questão que vamos abordar é o que faz $$\mathrm\TeX$$ quando uma determinada entrada de tabela abrange várias colunas mas é “demasiado larga para caber”. Como observado acima, $$\mathrm\TeX$$ aplica de facto um algoritmo específico a este problema de cálculo das larguras das colunas: os exemplos seguintes foram concebidos para ajudar a desenvolver uma “intuição” sobre o funcionamento desse algoritmo.

### Tabela de exemplo 1

Neste exemplo usamos `\multispan{2}` para abranger as colunas 1 e 2 com uma entrada cujo texto é **Um cabeçalho de tabela**:

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

#### Observações

* A largura desta tabela é a mesma que a da [tabela de referência](#reference-table): $$327.71722\text{pt}$$.
* A largura da entrada que abrange as colunas 1 e 2 é $$81.04953\text{pt}$$ que é menor do que a largura total das entradas nas colunas que abrange: $$52.56676\text{pt} + 57.06679\text{pt} = 109.63355\text{pt}$$

## Tabela de exemplo 2

Tal como em [Tabela de exemplo 1](#example-table-1), este exemplo também usa `\multispan{2}` para abranger as colunas 1 e 2, mas aqui usamos uma entrada mais longa cujo texto é **Um cabeçalho de tabela ligeiramente mais longo**.

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

#### Observações

Se comparar este exemplo com a nossa [tabela de referência](#reference-table) podemos ver o seguinte:

* A largura desta tabela aumentou de $$327.71722\text{pt}$$ para $$374.37032\text{pt}$$: um total de $$46.6531\text{pt}$$.
* A largura da entrada que abrange as colunas 1 e 2 ($$156.28664\text{pt}$$) é maior do que a largura total das entradas nas colunas que abrange: $$52.56676\text{pt} + 57.06679\text{pt} = 109.63355\text{pt}$$. Essa diferença é $$156.28664\text{pt}-109.63355\text{pt} = 46.6531\text{pt}$$ que é a mesma quantia pela qual a largura da tabela aumentou.
* $$\mathrm\TeX$$ ajustou a largura da coluna 2 para fornecer o espaço adicional necessário. Mais adiante veremos como $$\mathrm\TeX$$ calcula a quantidade pela qual a coluna 2 tem de aumentar.
* A coluna 1 não é afetada: a sua largura não foi afetada pela entrada que abrange as colunas 1 e 2.

### Tabela de exemplo 3

Neste exemplo usamos `\multispan{3}` para abranger as colunas 1 a 3 com uma entrada cujo texto é o mesmo que [Tabela de exemplo 2](#example-table-2): **Um cabeçalho de tabela ligeiramente mais longo**.

![{{{alt}}}](/files/2518b45bf995c39bb16e3ebd16242490e9c9d6bf)

#### Observações

* A largura desta tabela é a mesma que a da [tabela de referência](#reference-table): $$327.71722\text{pt}$$.
* A largura da entrada que abrange as colunas 1 a 3 ($$156.28664\text{pt}$$) é menor do que a largura total das entradas nas três colunas que abrange: $$52.56676\text{pt} + 57.06679\text{pt} + 59.03899\text{pt} = 168.67254\text{pt}$$.
* Nenhuma das larguras das colunas foi afetada pela entrada que abrange as colunas 1 a 3.

Já está a começar a ver surgir um padrão?

### Tabela de exemplo 4

Tal como em [Tabela de exemplo 3](#example-table-3), aqui usamos `\multispan{3}` para abranger as colunas 1 a 3, mas desta vez com uma entrada cujo texto é consideravelmente mais longo: **Um cabeçalho de tabela consideravelmente mais longo que se estende bastante**.

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

#### Observações

* Comparado com a [tabela de referência](#reference-table), a largura desta tabela aumentou de $$327.71722\text{pt}$$ para $$465.95685\text{pt}$$: um aumento de $$138.23963\text{pt}$$.
* A largura da entrada que abrange as colunas 1 a 3 é $$306.91216\text{pt}$$.
* A largura total das entradas nas três colunas abrangidas é $$52.56676\text{pt} + 57.06679\text{pt} + 59.03899\text{pt} = 168.67254\text{pt}$$.
* A diferença de largura entre a entrada longa abrangente e as entradas nas colunas 1 a 3 é $$306.91216\text{pt}-168.67254\text{pt}=138.23962\text{pt}$$. A mesma quantia (à quarta casa decimal!) pela qual a largura da tabela aumentou.
* Apenas a coluna 3 teve a sua largura aumentada: nem a coluna 1 nem a coluna 2 são afetadas.

#### Surge um padrão

Se olharmos para [Tabela de exemplo 2](#example-table-2) e [Tabela de exemplo 4](#example-table-4) podemos ver que, em ambos os casos, é a **última coluna na abrangência** que teve a sua largura aumentada para dar espaço à entrada longa que abrangia as colunas:

* Em [Tabela de exemplo 2](#example-table-2): A entrada longa abrangia as colunas 1 e 2. A coluna 2 ficou “esticada”.
* Em [Tabela de exemplo 4](#example-table-4): A entrada longa abrangia as colunas 1 a 3. A coluna 3 ficou “esticada”.

#### A largura da coluna 3: Surge um algoritmo?

Os cálculos seguintes dão uma indicação mais clara do que $$\mathrm\TeX$$ está a fazer. Aqui está o que sabemos:

* A largura da entrada longa que abrange as colunas 1 a 3 é $$306.91216\text{pt}$$.
* A largura total das entradas nas colunas 1 e 2 é $$52.56676\text{pt} + 57.06679\text{pt} = 109.63355\text{pt}$$.

Qual é a diferença entre esses valores? É $$306.91216\text{pt}-109.63355\text{pt} = 197.2786\text{pt}$$ e esta é a largura usada para a coluna 3: ela decorre diretamente do algoritmo usado por $$\mathrm\TeX$$.

### Tabela de exemplo 5

Antes de chegarmos a um exemplo mais complicado, aqui vai mais um exemplo “simples”. Esta tabela contém a mesma entrada longa que [Tabela de exemplo 4](#example-table-4): **Um cabeçalho de tabela consideravelmente mais longo que se estende bastante**; no entanto, desta vez usamos `\multispan{6}` o que permite que essa entrada abranja a tabela inteira. Como pode ver, a tabela resultante ainda tem a mesma largura que a nossa [tabela de referência](#reference-table) ($$327.71722\text{pt}$$) o que significa que nenhuma coluna foi afetada por esta entrada muito longa. Claramente, isto acontece porque a largura da entrada ($$306.91216\text{pt}$$) é menor do que a largura total de todas as entradas que ela abrange: $$327.71722\text{pt}$$; ou seja, a largura da tabela.

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

### Tabela de exemplo 6: Um pouco mais complicada

Aqui, analisamos uma série de três tabelas de exemplo (6(a)–6(c)) para mostrar o efeito de duas entradas diferentes que ambas se estendem até à coluna 5. [Tabela de exemplo 6(a)](#example-table-6a) e [Tabela de exemplo 6(b)](#example-table-6b) cada uma mostra uma tabela contendo uma única entrada que se estende por várias colunas até à coluna 5. [Tabela de exemplo 6(c)](#example-table-6c) combina ambas as entradas abrangentes numa única tabela e coloca a questão: qual entrada determina realmente a largura da coluna 5, e porquê? A resposta leva-nos à essência do algoritmo usado por $$\mathrm\TeX$$.

#### Tabela de exemplo 6(a)

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

**Observações**

* Comparado com a [tabela de referência](#reference-table), a largura desta tabela aumentou de $$327.71722\text{pt}$$ para $$371.11153\text{pt}$$: um aumento de $$43.39431\text{pt}$$.
* A largura da entrada que abrange as colunas 3 a 5 é $$215.06683\text{pt}$$.
* A largura total das entradas nas colunas 3 a 5 é $$59.03899\text{pt} + 52.98344\text{pt} + 59.6501\text{pt} = 171.67253\text{pt}$$.
* A diferença de largura entre as entradas abrangidas nas colunas 3 a 5 e a largura da entrada abrangente é $$215.06683\text{pt}-171.67253\text{pt}=43.3943\text{pt}$$: a quantia exata (à quarta casa decimal!) pela qual a largura da tabela aumentou.

#### Tabela de exemplo 6(b)

![{{{alt}}}](/files/9707ce750066c5f43c7fcb5a22c57e2404a257ea)

**Observações**

* Comparado com a [tabela de referência](#reference-table), a largura desta tabela aumentou de $$327.71722\text{pt}$$ para $$353.3233\text{pt}$$: um aumento de $$25.60608\text{pt}$$.
* A largura da entrada que abrange as colunas 1 a 5 é $$306.91216\text{pt}$$.
* A largura total das entradas nas colunas 1 a 5 é $$52.56676\text{pt} + 57.06679\text{pt} + 59.03899\text{pt} + 52.98344\text{pt} + 59.6501\text{pt} = 281.30608\text{pt}$$.
* A diferença de largura entre as entradas abrangidas nas colunas 1 a 5 e a largura da entrada abrangente é $$306.91216\text{pt}-281.30608\text{pt}=25.60608\text{pt}$$: **note** isto é *menor* do que o valor calculado para [Exemplo 6(a)](#example-table-6a), que era $$43.3943\text{pt}$$.

#### Tabela de exemplo 6(c)

Aqui, combinamos as entradas nas tabelas de exemplo [6(a)](#example-table-6a) e [6(b)](#example-table-6b) numa única tabela: o que acontece?

![{{{alt}}}](/files/1539cbaa1b15970351d3fc5ef1b57da5b3463205)

**Observação**

* Comparado com a [tabela de referência](#reference-table), a largura desta tabela aumentou de $$327.71722\text{pt}$$ para $$371.11153\text{pt}$$: um aumento de $$43.39431\text{pt}$$. Notamos que isto é exatamente o mesmo que [Tabela de exemplo 6(a)](#example-table-6a).

#### O que está $$\mathrm\TeX$$ a fazer?

Para compreender os resultados dos processos de algoritmo e tomada de decisão de $$\mathrm\TeX$$note-se que esta entrada

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

estende-se para além das entradas abrangidas por $$25.60608\text{pt}$$; no entanto, esta entrada

![{{{alt}}}](/files/50ba343a7bc73d8797e27c0b98893a9618b9307a)

estende-se ainda mais para além das entradas abrangidas: em $$43.3943\text{pt}$$. Assim, essa entrada “vence a corrida” e a coluna 5 tem a sua largura aumentada pelo **máximo** destes dois valores ($$43.3943\text{pt}$$). A largura da coluna 5 passa agora a ser $$59.6501\text{pt} + 43.3943\text{pt} = 103.0444\text{pt}$$ para acomodar a entrada que abrange as colunas 3 a 5. A nossa descrição da sequência exata de “eventos” é ligeiramente simplificada, mas o resultado é como descrevemos.

## Reintroduzindo alguma complexidade

Para minimizar a complexidade das nossas discussões (até aqui) usámos exemplos relativamente simples para demonstrar os princípios do $$\mathrm\TeX$$algoritmo de `\tabskip=0pt`. Em prática, tabelas “do mundo real” provavelmente terão muitas entradas que abrangem uma gama de colunas e, naturalmente, terão valores não nulos para o `\tabskip` glue — um tópico ao qual regressaremos agora.

### \tabskip glue e larguras de colunas abrangidas

A conceção de tabelas requer muitas vezes a adição de espaço em branco entre colunas e, naturalmente, $$\mathrm\TeX$$ tem essa facilidade através de um comando primitivo chamado `\tabskip`. Este comando pode ser usado para colocar glue fixo ou flexível (espaçamento):

* antes de uma tabela (isto é, à esquerda da coluna 1);
* entre uma ou mais colunas;
* depois da tabela (isto é, à direita da última coluna).

Aqui está um exemplo para nos lembrarmos:

![{{{alt}}}](/files/42804054da90531ed324a3d1c2cd29704980d828)

### Como é que o glue \tabskip afeta as larguras das colunas abrangidas?

A presença de `\tabskip` glue não nulo entre colunas fornece espaço adicional que as entradas abrangentes podem “absorver” antes de $$\mathrm\TeX$$ precisar de pensar em aumentar a largura da última coluna numa abrangência.

No nosso próximo exemplo vamos usar duas tabelas para comparar os resultados de abranger duas colunas. A única diferença entre as tabelas é o uso de `\tabskip` glue.

* O primeiro exemplo usa a nossa tabela original “de referência” que, se se lembrar, tem definido `\tabskip=0pt`.
* O segundo exemplo usa uma versão modificada da nossa [tabela de referência](#reference-table) (anotada acima) que tem `\tabskip=10pt` antes e depois da tabela mas, mais importante, tem definido `\tabskip=20pt` entre as colunas.

Na *versão modificada* tabela de referência, as duas colunas abrangidas não têm efeito nas larguras das colunas (nem na largura da tabela), mas têm efeito na largura da coluna 2 (e na largura da tabela) na *original* [tabela de referência](#reference-table).

### Tabela de referência original: \tabskip=0pt

Aqui, mostramos a nossa [tabela de referência](#reference-table) original juntamente com uma segunda tabela (derivada da nossa original [tabela de referência](#reference-table)) que tem uma entrada “**Testar um cabeçalho de tabela mais longo**” abrangendo as colunas 1 e 2. Claramente, a coluna 2 (da segunda tabela no diagrama) e, portanto, a tabela inteira, são ambas afetadas pelas colunas abrangidas.

![{{{alt}}}](/files/831c42dc178d82f69794afc02d8996d46f006a30)

### Tabela de referência modificada: \tabskip=20pt

Aqui, mostramos a nossa tabela de referência modificada juntamente com uma segunda tabela (derivada da nossa tabela de referência modificada) que também tem uma entrada “**Testar um cabeçalho de tabela mais longo**” abrangendo as colunas 1 e 2. Claramente, na segunda tabela do diagrama, nem a largura da coluna 2 nem a da tabela são afetadas pelas colunas abrangidas. Neste caso, a presença de `\tabskip` glue (`20pt`) entre as colunas ajudou a “absorver” o espaço necessário pelo texto na entrada que abrange as colunas 1 e 2:

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

## A essência do $$\mathrm\TeX$$algoritmo de

Esperemos que a gama de exemplos apresentada acima tenha ajudado a desenvolver uma “noção” do que $$\mathrm\TeX$$ faz para acomodar entradas abrangentes e como $$\mathrm\TeX$$ irá, se necessário, ajustar a largura da **última** coluna dentro de cada intervalo de colunas abrangidas. Para além da largura das entradas dentro das colunas individuais abrangidas, a presença de `\tabskip` glue não nulo é um fator importante que $$\mathrm\TeX$$ tem em consideração ao decidir se precisa de ajustar alguma largura de coluna. O ponto-chave a lembrar é que $$\mathrm\TeX$$objetivo é calcular uma largura adequada para a **última coluna** dentro de cada intervalo de colunas abrangidas.

### Exemplo final de tabela: últimas colunas num intervalo abrangido

Neste exemplo final voltamos a usar a nossa tabela de referência modificada (com `\tabskip` valores de cola discutidos acima) para derivar outra tabela que contém várias colunas abrangidas por regras — usamos regras para tornar os intervalos mais fáceis de ver.

As duas tabelas foram cuidadosamente alinhadas para mostrar que, na tabela superior, nenhuma coluna anterior à coluna 5 foi afetada pelas colunas abrangidas. A área verde-escura à esquerda do diagrama mostra que as colunas 1 a 4 de обе as tabelas continuam perfeitamente alinhadas. À direita há uma área sombreada em verde-claro que mostra que apenas as colunas 5 e 6 foram afetadas pelas entradas abrangidas.

Na tabela superior, os intervalos são os seguintes:

* colunas 1 a 5: abrangidas por uma $$400\text{pt}$$ regra;
* colunas 3 a 5: abrangidas por uma $$200\text{pt}$$ regra;
* colunas 4 a 6: abrangidas por uma $$250\text{pt}$$ regra.

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

Mais uma vez, a explicação é que, dentro de uma série de colunas abrangidas, apenas a largura da coluna final é ajustada (se necessário): as colunas intermédias não são afetadas e aqui isso significa as colunas 1 a 4 — embora, claro, a largura das colunas 1 a 4 (e das colunas intermédias `\tabskip` de cola) seja tida em consideração ao calcular as larguras ajustadas das colunas 5 e 6.

### Uma análise de $$\mathrm\TeX$$algoritmo de

Concluiremos com uma *simplificada* análise simplificada de “$$\mathrm\TeX$$’s processos de pensamento” à medida que calcula as larguras das colunas nas entradas abrangidas. Descrever $$\mathrm\TeX$$os algoritmos de” não são sempre simples, por isso adotaremos alguma “licença artística simplificadora” para fornecer uma visão geral do que está a acontecer. Os leitores interessados em todos os detalhes confusos são remetidos para a Secção 801 (página 336) do livro impresso que contém $$\mathrm\TeX$$o código-fonte de [$$\mathrm\TeX\text{: The Program}$$](https://www.amazon.co.uk/Computers-Typesetting-Tex-Program-TEX/dp/0201134373).

Tabelas do mundo real são muitas vezes criadas com muitas utilizações da primitiva (por exemplo, dentro de `\span` p. ex., dentro de $$\mathrm\LaTeX$$ pacotes) para construir múltiplas instâncias de colunas abrangidas dentro da tabela. Para gerir isto, as estruturas de dados (no interior profundo de $$\mathrm\TeX$$) mantêm informação (os chamados *nós de span*) que informam $$\mathrm\TeX$$ sobre as ligações (spans) entre entradas/colunas da tabela. Claramente, $$\mathrm\TeX$$ tem de aplicar os seus algoritmos de forma sistemática e terá de processar toda a tabela para fazer os seus cálculos finais — para determinar todas as larguras das colunas, a largura total da tabela e, se necessário, a quantidade pela qual as colas flexíveis usadas na tabela têm de esticar ou encolher. Não é realmente surpreendente que $$\mathrm\TeX$$ não possa dizer-lhe a largura final da tabela até ter processado completamente o `\halign{...}` comando — realmente tem muito trabalho a fazer!

O ponto de partida para os cálculos da largura das colunas é a coluna 1 porque, claro, nada pode abranger a partir da esquerda de (e *atravessando/para dentro de*) coluna 1. $$\mathrm\TeX$$ começa por determinar a largura da coluna 1 ao identificar a entrada com a largura natural máxima *largura natural*. Vamos chamar a essa largura máxima $$w\_1$$e, se houver entradas que se estendam da coluna 1 para a coluna 2, vamos chamar à largura dessa entrada $$w\_{12}$$ (largura de 1 a 2). Além disso, denotaremos a `\tabskip` cola entre as colunas 1 e 2 como $$t\_{1}$$—note que estamos apenas a considerar a *largura natural* largura `\tabskip` dessa cola e, por agora, a ignorar quaisquer componentes de alongamento ou encolhimento que possa possuir. Além disso, seja a largura natural máxima de todas as entradas não abrangidas na coluna 2 $$w\_2$$.

O ponto-chave a notar é que $$\mathrm\TeX$$ está a tentar calcular a largura da coluna 2 considerando apenas aquelas entradas em que a abrangência *começa* na coluna 1 e *termina* na coluna 2. A consideração-chave para $$\mathrm\TeX$$ é o teste $$\max(w\_{2}, w\_{12} - (w\_1+ t\_1))$$— pode haver várias entradas que abrangem as colunas 1 e 2: algumas podem ser estreitas (pequenas $$w\_{12}$$), outras muito largas (grandes $$w\_{12}$$) portanto $$\mathrm\TeX$$ está à procura daquela que tem o maior efeito (daí o $$\max(\text{...})$$). Aqui, o valor de $$w\_{12} -(w\_1+ t\_1)$$ é a quantidade pela qual uma entrada que abrange as colunas 1 e 2 “transborda” da coluna 1 para a coluna 2: note que $$\mathrm\TeX$$ está a usar a largura da coluna 1 **e** o `\tabskip` glue ($$t\_{1}$$) entre as colunas 1 e 2. Depois de $$\mathrm\TeX$$ ter determinado se alguma abrangência da coluna 1 para a 2 afeta de facto a largura da coluna 2, define a largura da coluna 2 para o valor máximo que determinou (usando o teste descrito). $$\mathrm\TeX$$ continua a percorrer todas as outras colunas, realizando testes semelhantes.

E finalmente, só para completar, citamos aqui a essência do $$\mathrm\TeX$$algoritmo de” para calcular as larguras das colunas (retirado da documentação do código-fonte de Knuth de $$\mathrm\TeX$$):

Seja $$w\_{ij}$$ o máximo das larguras naturais de todas as entradas que abrangem as colunas $$i$$ até $$j$$, inclusive. As larguras finais das colunas são definidas pela 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\*}$$

onde $$t\_k$$ é a largura natural da cola tabskip entre as colunas $$k$$ e $$k+1$$.

## Colofão: Usar o Overleaf para produzir tabelas como gráficos SVG

Todas as $$\mathrm\TeX$$ tabelas apresentadas neste artigo são ficheiros Scalable Vector Graphics (SVG) produzidos na plataforma Overleaf. As anotações (setas e caixas verdes) foram adicionadas abrindo o gráfico SVG no Inkscape — note, contudo, que o texto das anotações foi composto em $$\mathrm\TeX$$ como texto adicional para acompanhar a tabela: apenas as setas e os fundos verdes foram adicionados no Inkscape. Se estiver interessado em saber como isto foi conseguido, continue a ler.

Os servidores do Overleaf usam a $$\mathrm\TeX \text{ Live}$$ distribuição que, além de $$\mathrm\TeX$$motores de composição tipográfica baseados em TeX, fornece uma grande quantidade de $$\mathrm\TeX$$ferramentas e utilitários de software muito úteis relacionados com TeX. Entre eles há um chamado [`dvisvgm`](https://dvisvgm.de) que, como o nome sugere, converte $$\mathrm\TeX$$o formato tradicional de ficheiro de saída DVI (**D**e**V**ispositivo **I**ndependente) de saída em SVG. Entre as muitas [opções de linha de comando](https://dvisvgm.de/Manpage/) `dvisvgm` fornece uma opção (`-n` ou `--no-fonts`) que lhe indicará para converter todo o texto em *caminhos* o que significa que o texto nos gráficos SVG é desenhado usando linhas e curvas em vez de tipos e glifos reais. Isto pode aumentar o tamanho do ficheiro do gráfico SVG resultante, mas garante que os gráficos SVG são extremamente portáteis e quase de certeza funcionarão bem em qualquer dispositivo.

### Então... como foi feito?

Num [artigo anterior](https://www.overleaf.com/blog/510-using-luatex-to-run-tools-and-utilities-installed-on-overleafs-servers) discuti como pode usar $$\text{Lua}\mathrm\TeX$$ para executar as várias ferramentas e utilitários de software instalados nos servidores do Overleaf — é uma técnica extremamente fácil e conveniente. Essa técnica foi usada para gerar gráficos SVG de $$\mathrm\TeX$$ tabelas compostas, da seguinte forma. A partir do ficheiro principal $$\mathrm\TeX$$ do documento, o código para compor cada tabela (criada usando `\halign`) foi escrito para um `.tex` ficheiro. Isto foi conseguido ao envolver o código da tabela dentro de um par de comandos a que chamei `\beginscoop` e `\endscoop`. É provável que haja muitas outras maneiras de alcançar os resultados desejados, mas aqui estão as definições de macro que usei:

```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}
```

Usa-as assim:

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

Note que o `\endscoop` token serve apenas para delimitar o parâmetro de `\scoop` macro: $$\mathrm\TeX$$ descarta efetivamente o `\endscoop` token, por isso, na verdade, não precisamos de o definir (por exemplo, com `\def\endscoop{...}`).

O $$\mathrm\TeX$$ o código contido em `\halign{...}` é guardado num `registo` toks chamado `\fulltoks`. Um ponto complicado com que me deparei (com $$\text{Lua}\mathrm\TeX$$) foi a necessidade de impedir que `#` caracteres dentro do `\halign{...}` preâmbulo fossem “duplicados” para `##` quando escritos num `.tex` ficheiro. Para evitar isso, tive de definir temporariamente os `\catcode`de `#` caracteres para 12 antes de guardar o $$\mathrm\TeX$$ código (tokens) no `\fulltoks` registo de tokens.

O próximo passo é escrever os tokens contidos em `\fulltoks` num $$\mathrm\TeX$$ — como eu estava a usar $$\text{Lua}\mathrm\TeX$$ isto revelou-se *extremamente* fácil graças à maravilhosa API Lua de $$\text{Lua}\mathrm\TeX$$Em poucas palavras, escrevi uma macro chamada `\writefile{...}` que recebe como parâmetro o nome de um registo de tokens cujos tokens quer escrever num ficheiro (por exemplo, `\writefile{fulltoks}`). Dentro da `\writefile{...}` macro usei a API Lua para obter uma representação textual do `\fulltoks` registo de tokens:

```latex
\def\writefile#1{%
\directlua{
...
...
 local p=tex.toks[\"#1\"]
...
...
}}
```

Aqui está uma captura de ecrã que mostra um pouco mais do `\writefile{...}` comando:

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

A linguagem Lua e a API Lua fornecida por $$\text{Lua}\mathrm\TeX$$ podem frequentemente simplificar $$\mathrm\TeX$$ tarefas de programação e é por causa destas características úteis e poderosas que tenho usado $$\text{Lua}\mathrm\TeX$$ desde \~2009 — e continuo a ser um grande fã deste verdadeiramente maravilhoso $$\mathrm\TeX$$ motor. OK, o $$\text{Lua}\mathrm\TeX$$ anúncio termina agora.

Tendo obtido tão facilmente o $$\mathrm\TeX$$ código guardado em `\fulltoks` ele é escrito para um ficheiro juntamente com algum código adicional para o transformar num $$\mathrm\LaTeX$$ ficheiro corretamente formado. Os passos seguintes são:

1. Processar o `.tex` ficheiro que contém a nossa tabela com $$\text{pdf}\mathrm\LaTeX$$ (em modo DVI) para que componha a tabela e gere um ficheiro `.dvi` para `dvisvgm` processar. Sim, pode usar $$\text{Lua}\mathrm\TeX$$ para executar $$\text{pdf}\mathrm\LaTeX$$— mais uma vez usei o método discutido numa [artigo anterior](/latex/overleaf-learn-latex-pt/artigos-aprofundados/52-using-luatex-to-run-tools-and-utilities-installed-on-overleaf-s-servers.md).
2. E, finalmente, executar `dvisvgm` para processar o `.dvi` ficheiro para gerar um gráfico SVG da tabela $$\mathrm\TeX$$ composta.
3. Para obter os gráficos SVG reais, pode descarregar um ficheiro ZIP do Overleaf — certificando-se de selecionar a **Ficheiros de entrada e saída** opção.


---

# 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/overleaf-learn-latex-pt/artigos-aprofundados/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.