> 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/fr/articles-approfondis/31-latex-is-more-powerful-than-you-think-computing-the-fibonacci-numbers-and-turing-completeness.md).

# LaTeX est plus puissant que vous ne le pensez — calcul des nombres de Fibonacci et complétude de Turing

**Auteur : Robert Murrish (avril 2012 (modifié par Overleaf en avril 2023))**

LaTeX est un outil puissant. Si puissant, en fait, qu’il peut être utilisé pour bien plus que le balisage de documents. LaTeX est [Turing-complet](https://en.wikipedia.org/wiki/Turing_completeness); c’est-à-dire qu’il peut être programmé pour calculer à peu près n’importe quoi.

Pour démontrer les capacités de programmation généralistes de LaTeX, nous allons examiner un exemple qui calcule les premiers nombres de Fibonacci. Bien que ce ne soit pas une preuve de complétude de Turing, c’est un bon exemple d’un algorithme complet implémenté en LaTeX.

### Les nombres de Fibonacci

Chaque nombre de la suite de Fibonacci est la somme des deux termes précédents de la suite, les deux premiers termes étant définis à 1 afin de fournir un point de départ.

Nous pouvons écrire une nouvelle commande pour calculer ces nombres. Commençons par décider à quoi pourrait ressembler un appel à notre commande pas encore écrite :

```latex
\fibonacci{10}
```

Lorsque cette commande est appelée depuis notre document LaTeX, elle doit produire une liste de `n` nombres de Fibonacci (où `n=10` dans l’appel d’exemple ici). Voici le code de la `\fibonacci` commande (c.-à-d. macro LaTeX). Voyons comment elle fonctionne.

```latex
\documentclass{article}
\begin{document}

\newcount\temp
\newcount\fone
\newcount\ftwo
\newcount\fcnt

\newcommand{\fibonacci}[1]{%
	\fcnt=#1
	\fone=1
	\ftwo=1
	\temp=0
	\the\fone, \the\ftwo
	\let\next=\fibloop
	\fibloop
}

\def\fibloop{, %
	\temp=\fone
	\fone=\ftwo
	\advance\ftwo by \temp
	\ifnum\fcnt=0
            \let\next=\relax
        \else
            \advance\fcnt by -1
        \fi
	\the\ftwo
	\next
}

(\fibonacci{10})
\end{document}
```

[Ouvrez cet exemple dans Overleaf](https://www.overleaf.com/docs?engine=pdflatex\&snip_name=Fibonacci+sequence+in+LaTeX\&snip=%5Cdocumentclass%7Barticle%7D%0A%5Cbegin%7Bdocument%7D%0A%0A%5Cnewcount%5Ctemp%0A%5Cnewcount%5Cfone%0A%5Cnewcount%5Cftwo%0A%5Cnewcount%5Cfcnt%0A%0A%5Cnewcommand%7B%5Cfibonacci%7D%5B1%5D%7B%25%0A%09%5Cfcnt%3D%231%0A%09%5Cfone%3D1%0A%09%5Cftwo%3D1%0A%09%5Ctemp%3D0%0A%09%5Cthe%5Cfone%2C+%5Cthe%5Cftwo%0A%09%5Clet%5Cnext%3D%5Cfibloop%0A%09%5Cfibloop%0A%7D%0A%0A%5Cdef%5Cfibloop%7B%2C+%25%0A%09%5Ctemp%3D%5Cfone%0A%09%5Cfone%3D%5Cftwo%0A%09%5Cadvance%5Cftwo+by+%5Ctemp%0A%09%5Cifnum%5Cfcnt%3D0%0A++++++++++++%5Clet%5Cnext%3D%5Crelax%0A++++++++%5Celse%0A++++++++++++%5Cadvance%5Cfcnt+by+-1%0A++++++++%5Cfi%0A%09%5Cthe%5Cftwo%0A%09%5Cnext%0A%7D%0A%0A%28%5Cfibonacci%7B10%7D%29%0A%5Cend%7Bdocument%7D)

Tout d’abord, nous mettons en place quelques variables que nous utiliserons plus tard. La `\newcount` commande nous donne une variable que nous pouvons utiliser pour stocker un entier ; ici, nous en créons quatre : `\fcnt`, `\fone`, `\ftwo` et `\temp`. Il convient de mentionner qu’il ne s’agit pas de nouvelles variables ; ce sont plutôt des alias pour des compteurs existants. [Les compteurs LaTeX](/latex/fr/mise-en-forme/10-counters.md) peuvent être utilisés directement comme dans `\count0`, `\count1`, etc. mais leur donner des noms nous évite d’écrire dans un compteur déjà utilisé. Si cela vous intrigue, remplacez l’une des variables de ce code par `\count0`, et les numéros de page seront faux pour le reste du document.

Nous avons ensuite la `\fibonacci` commande. Nous la créons avec `\newcommand`, que nous lui fournissons avec le nom, le nombre d’arguments et le code TeX à traiter comme arguments. Pour cette commande, nous acceptons un seul argument, le nombre de nombres de Fibonacci à afficher. Le contenu de cette commande est simple : nous définissons les valeurs initiales de nos variables, affichons les deux premiers nombres de Fibonacci (puisqu’ils n’ont pas besoin d’être calculés), puis appelons `\fibloop`, qui se chargera du gros du travail pour nos calculs.

La commande `\fibloop` est déclarée de la même manière, mais un élément clé de cette commande est sa façon de boucler. Nous utilisons une commande appelée `\next`, initialisée à `\fibloop` dans `\fibonacci`, et utilisée dans `\fibloop` pour contrôler la boucle. `\fibloop` se répétera jusqu’à ce que `\next` soit modifié par le code à l’intérieur de la `\fibloop` commande elle-même. Nous voulons uniquement boucler `n` fois, donc nous utilisons une `\ifnum` instruction qui vérifie la valeur de notre compteur (`\fcnt`) puis, s’il n’a pas atteint la valeur seuil de 0, `\fcnt` est décrémenté à chaque répétition de la boucle. Si la condition est remplie, nous définissons `\next` à `\relax`, ce qui empêchera `\fibloop` de se répéter — la dernière `\next` commande ne fait rien, et la boucle se termine.

Les autres commandes de ce bloc calculent le nombre de Fibonacci suivant dans la suite et mettent à jour les valeurs des variables afin qu’elles soient prêtes pour le passage suivant. La commande `\the\ftwo` imprime la valeur du nombre de Fibonacci courant dans le document, et vous remarquerez aussi une virgule et un espace en haut de la `\fibloop` commande utilisée pour séparer chaque valeur.

#### Le résultat

La façon la plus simple de voir ce code à l’œuvre est de l’exécuter sur Overleaf en utilisant le **Ouvrez cet exemple dans Overleaf** lien au bas de l’affichage du code. La suite de Fibonacci croît rapidement, donc tout `n>44` entraînera un dépassement d’entier dans cette implémentation particulière.

### Où aller ensuite ?

Comme preuve informelle que LaTeX est Turing-complet, je présente le code suivant, qui est une implémentation rapide et bricolée d’une [porte NAND](https://en.wikipedia.org/wiki/NAND_gate):

```latex
\newcount\nanone
\newcount\nantwo

\newcommand{\nand}[2]{%
\nanone=#1
\nantwo=#2
  \ifnum\nanone=\nantwo
    \ifnum\nanone=0\relax 1
      \else 0
    \fi
   \else 1
\fi
}
```

Les portes logiques NAND (et aussi NOR) ont la propriété intéressante que toute autre porte logique peut être formée à partir de ce seul type de porte. À partir des portes logiques de base, on peut construire des verrous, des bascules et de la mémoire. Ce sont les ingrédients d’un ordinateur à usage général. Vous pouvez tester cette porte NAND pour chacune de ses quatre entrées possibles avec l’exemple suivant que vous pouvez ouvrir dans Overleaf.

```latex
\documentclass{article}
\begin{document}

\newcount\nanone
\newcount\nantwo

\newcommand{\nand}[2]{%
\nanone=#1
\nantwo=#2
  \ifnum\nanone=\nantwo
    \ifnum\nanone=0\relax 1
      \else 0
    \fi
   \else 1
\fi
}

\nand{0}{0}
\nand{0}{1}
\nand{1}{0}
\nand{1}{1}
\end{document}
```

[Ouvrez cet exemple dans Overleaf](https://www.overleaf.com/docs?engine=pdflatex\&snip_name=NAND+gate+in+LaTeX\&snip=%5Cdocumentclass%7Barticle%7D%0A%5Cbegin%7Bdocument%7D%0A%0A%5Cnewcount%5Cnanone%0A%5Cnewcount%5Cnantwo%0A%0A%5Cnewcommand%7B%5Cnand%7D%5B2%5D%7B%25%0A%5Cnanone%3D%231%0A%5Cnantwo%3D%232%0A++%5Cifnum%5Cnanone%3D%5Cnantwo%0A++++%5Cifnum%5Cnanone%3D0%5Crelax+1%0A++++++%5Celse+0%0A++++%5Cfi%0A+++%5Celse+1%0A%5Cfi%0A%7D%0A%0A%5Cnand%7B0%7D%7B0%7D%0A%5Cnand%7B0%7D%7B1%7D%0A%5Cnand%7B1%7D%7B0%7D%0A%5Cnand%7B1%7D%7B1%7D%0A%5Cend%7Bdocument%7D)

Savoir que LaTeX est Turing-complet ouvre un monde de possibilités. Un code comme celui-ci est courant dans les coulisses de LaTeX pour des choses comme le suivi des numéros de page et de figure et la décision de l’emplacement des flottants. C’est un outil que vous pouvez utiliser à votre avantage pour simplifier des mises en page complexes.

Pour conclure cet article, je vous laisse avec des lectures complémentaires sur des exemples de programmation en LaTeX et sur les machines de Turing.

#### Exemples de programmation en LaTeX

* [L’ensemble de Mandelbrot en LaTeX](http://warp.povusers.org/MandScripts/latex.html) . Remerciements particuliers pour celui-ci ; ce code a été un exemple utile lors de l’écriture de ma commande Fibonacci.
* [Une machine de Turing en LaTeX : suite](http://pbelmans.ncag.info/blog/2010/12/12/a-turing-machine-in-latex-follow-u/) NB : Lors du portage de cet article vers un autre système d’hébergement de contenu, nous avons constaté que le site cité dans l’article original (<http://en.literateprograms.org/Turing_machine_simulator_(LaTeX))> n’était plus accessible, nous avons donc remplacé ce lien par un article de suivi rédigé par un autre auteur.
* [Wikibook sur les commandes TeX](http://en.wikibooks.org/wiki/Category:TeX)
* [LaTeX dans un concours de programmation](http://sdh33b.blogspot.com/2008/07/icfp-contest-2008.html). Un contrôleur de rover martien en LaTeX a surpassé des contributions écrites dans plusieurs langages de programmation plus courants.

### Machines de Turing dans des endroits inattendus

* [Le Jeu de la vie de Conway est Turing-complet](http://rendell-attic.org/gol/utm/index.htm). Voici une implémentation d’une machine de Turing.
* [Règle 110](http://en.wikipedia.org/wiki/Rule_110) est un automate cellulaire 1D Turing-complet.
* Minecraft (le jeu vidéo) est Turing-complet. Plusieurs exemples ont été construits, donc le lien suivant mène simplement vers une [page de résultats de recherche YouTube pertinents](http://www.youtube.com/results?search_query=minecraft+turing+machine)


---

# 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/fr/articles-approfondis/31-latex-is-more-powerful-than-you-think-computing-the-fibonacci-numbers-and-turing-completeness.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.
