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

# LaTeX is krachtiger dan je denkt - de Fibonacci-getallen berekenen en Turing-volledigheid

**Auteur: Robert Murrish (april 2012 (bewerkt door Overleaf in april 2023))**

LaTeX is een krachtig hulpmiddel. Zo krachtig zelfs dat het voor veel meer dan documentopmaak kan worden gebruikt. LaTeX is [Turing-volledig](https://en.wikipedia.org/wiki/Turing_completeness); dat wil zeggen, het kan worden geprogrammeerd om vrijwel alles te berekenen.

Om de algemene programmeermogelijkheden van LaTeX te demonstreren, bekijken we een voorbeeld dat de eerste Fibonacci-getallen berekent. Hoewel dit geen bewijs is van Turing-volledigheid, is het wel een goed voorbeeld van een volledig algoritme dat in LaTeX is geïmplementeerd.

### De Fibonacci-getallen

Elk getal in de Fibonacci-reeks is de som van de twee voorgaande termen in de reeks, waarbij de eerste twee termen als 1 zijn gedefinieerd om een startpunt te bieden.

We kunnen een nieuw commando schrijven om deze getallen te berekenen. Laten we beginnen met te bepalen hoe een aanroep van ons nog te schrijven commando eruit zou kunnen zien:

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

Wanneer dit commando vanuit ons LaTeX-document wordt aangeroepen, moet het een lijst van `n` Fibonacci-getallen (waarbij `n=10` in de voorbeeldaanroep hier). Hier is de code voor het `\fibonacci` commando (d.w\.z. LaTeX-macro). Laten we eens kijken hoe het werkt.

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

[Open dit voorbeeld in 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)

Eerst zetten we een paar variabelen op die we later zullen gebruiken. Het `\newcount` commando geeft ons een variabele die we kunnen gebruiken om een geheel getal in op te slaan; hier maken we er vier aan: `\fcnt`, `\fone`, `\ftwo` en `\temp`. Het is de moeite waard om te vermelden dat dit geen nieuwe variabelen zijn; het zijn eerder aliassen voor bestaande tellers. [LaTeX-tellers](/latex/nl/opmaak/10-counters.md) kunnen rechtstreeks worden gebruikt, zoals in `\count0`, `\count1`, enzovoort. Maar door er namen aan toe te kennen, voorkomen we dat we naar een teller schrijven die al in gebruik is. Als je nieuwsgierig bent, vervang een van de variabelen in deze code door `\count0`, en de paginanummers zullen voor de rest van het document verkeerd zijn.

Vervolgens hebben we het `\fibonacci` commando. We maken het aan met `\newcommand`, dat we voorzien van de naam, het aantal argumenten en TeX-code om als argumenten te verwerken. Voor dit commando accepteren we één argument: het aantal Fibonacci-getallen dat moet worden afgedrukt. De inhoud van dit commando is eenvoudig: we stellen beginwaarden in voor onze variabelen, drukken de eerste twee Fibonacci-getallen af (omdat die niet berekend hoeven te worden) en roepen vervolgens `\fibloop`, dat het zware rekenwerk voor onze berekeningen zal doen.

Het commando `\fibloop` wordt op dezelfde manier gedeclareerd, maar een belangrijk onderdeel van dit commando is hoe de lus werkt. We gebruiken een commando genaamd `\next`, geïnitialiseerd op `\fibloop` binnen `\fibonacci`, en gebruikt binnen `\fibloop` om de lus te regelen. `\fibloop` zal herhalen totdat `\next` wordt gewijzigd door code binnen het `\fibloop` commando zelf. We willen maar `n` keer herhalen, dus gebruiken we een `\ifnum` instructie die de waarde van onze teller controleert (`\fcnt`) en vervolgens, als die nog niet de drempelwaarde 0 heeft bereikt, `\fcnt` wordt bij elke herhaling van de lus verlaagd. Als aan de voorwaarde is voldaan, stellen we `\next` om `\relax`, wat zal voorkomen dat `\fibloop` zich herhaalt—de uiteindelijke `\next` commando doet niets en de lus eindigt.

De andere commando's in dit blok berekenen het volgende Fibonacci-getal in de reeks en werken de waarden van de variabelen bij zodat ze klaar zijn voor de volgende ronde. Het commando `\the\ftwo` drukt de waarde van het huidige Fibonacci-getal af in het document, en je zult ook een komma en een spatie zien bovenaan het `\fibloop` commando dat wordt gebruikt om elke waarde te scheiden.

#### Het resultaat

De eenvoudigste manier om deze code in actie te zien is om hem op Overleaf uit te voeren met de **Open dit voorbeeld in Overleaf** link onderaan de codeweergave. De Fibonacci-reeks groeit snel, dus elke `n>44` zal in deze specifieke implementatie resulteren in een integer-overloop.

### Waar kun je hierna naartoe?

Als een informeel bewijs dat LaTeX Turing-volledig is, presenteer ik de volgende code, die een snelle en eenvoudige implementatie is van een [NAND-poort](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
}
```

NAND- (en ook NOR-) logische poorten hebben de interessante eigenschap dat elke andere logische poort met dit ene type poort kan worden gevormd. Met de basislogische poorten kun je latches, flip-flops en geheugen bouwen. Dat zijn de bouwstenen voor een computer voor algemeen gebruik. Je kunt deze NAND-poort testen voor elk van de vier mogelijke invoercombinaties met het volgende voorbeeld dat je in Overleaf kunt openen.

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

[Open dit voorbeeld in 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)

Weten dat LaTeX Turing-volledig is, opent een wereld aan mogelijkheden. Code als deze komt veel voor in de back-end van LaTeX voor zaken als het bijhouden van pagina- en figuurnummers en het bepalen waar zwevende objecten moeten worden geplaatst. Het is een hulpmiddel dat je in je voordeel kunt gebruiken om complexe documentindelingen te vereenvoudigen.

Om deze post af te sluiten, laat ik je achter met verder leesvoer over voorbeelden van programmeren in LaTeX en Turingmachines.

#### Voorbeelden van programmeren in LaTeX

* [De Mandelbrotverzameling in LaTeX](http://warp.povusers.org/MandScripts/latex.html) . Speciale dank aan deze; deze code was een nuttig voorbeeld tijdens het schrijven van mijn Fibonacci-commando.
* [Een Turingmachine in LaTeX: het vervolg](http://pbelmans.ncag.info/blog/2010/12/12/a-turing-machine-in-latex-follow-u/) NB: Bij het overzetten van dit artikel naar een ander content-hostingsysteem merkten we op dat de site waarnaar in het oorspronkelijke artikel werd verwezen (<http://en.literateprograms.org/Turing_machine_simulator_(LaTeX))> niet langer toegankelijk was, dus hebben we die link vervangen door een vervolgartikel van een andere auteur.
* [Wikiboek over TeX-commando's](http://en.wikibooks.org/wiki/Category:TeX)
* [LaTeX in een programmeerwedstrijd](http://sdh33b.blogspot.com/2008/07/icfp-contest-2008.html). Een controller voor een Marsrover in LaTeX versloeg inzendingen in verschillende meer gangbare programmeertalen.

### Turingmachines op onverwachte plaatsen

* [Conway's Game of Life is Turing-volledig](http://rendell-attic.org/gol/utm/index.htm). Hier is een implementatie van een Turingmachine.
* [Regel 110](http://en.wikipedia.org/wiki/Rule_110) is een eendimensionale cellulaire automaat die Turing-volledig is.
* Minecraft (de videogame) is Turing-volledig. Er zijn verschillende voorbeelden gebouwd, dus de volgende link verwijst simpelweg naar een [pagina met relevante YouTube-zoekresultaten](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/nl/diepgaande-artikelen/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.
