LaTeX Tips & Tricks zur Informatik

Für die hier aufgeführten Pakete gibt es auch ein Beispiel-LaTeX-File:

informatik.tex [4.24 kB]

Erweiterte Backus Nauer Form (EBNF)

Für meine Stoffzusammenfassung zur Informatik (siehe hier) habe ich einige Makros zusammengestellt, mit denen man Grammatiken formaler Sprachen in EBNF notieren kann. Hier zunächst der Quelltext der Makros (und hier als LaTeX-File

jkebnf.tex):

% Umgebung zur Definition von formalen Sprachen \newenvironment{ebnf}{\begin{tabular}{rcll}}{\end{tabular}} \newcommand{\ebnfvar}[1]{{\textit{#1}}\ \ } \newcommand{\ebnfvara}[1]{$\left\langle \text{\textit{#1}}\right\rangle$\ \ } \newcommand{\ebnfor}{\txt{\ $|$\ \ }} \newcommand{\ebnfterm}[1]{\txt{\textbf{\texttt{#1}}}\ \ } \newcommand{\ebnfoption}[1]{\txt{$\left[\;\text{#1}\;\right]$}\ \ } \newcommand{\ebnfmult}[1]{\txt{$\left\{\;\text{#1}\;\right\}$}\ \ } \newcommand{\ebnfattrib}[1]{{$\bigl\{$\ {#1}\ $\bigr\}$}\ \ } \newcommand{\ebnfrule}[2]{{#1}&$\ \ \rightarrow\ \ $&{#2}&\\} \newcommand{\ebnfrulev}[2]{{\ebnfvar{#1}}&$\ \ \rightarrow\ \ $&{#2}&\\} \newcommand{\ebnfhalfrule}[1]{&&{\ebnfor {#1}}&\\} \newcommand{\ebnfrulea}[3]{{#1}&$\ \ \rightarrow\ \ $&{#2}&{$\bigl\{$\ {#3}\ $\bigr\}$}\\} \newcommand{\ebnfruleav}[3]{{\ebnfvar{#1}}&$\ \ \rightarrow\ \ $&{#2}&{$\bigl\{$\ {#3}\ $\bigr\}$}\\} \newcommand{\ebnfhalfrulea}[2]{&&{\ebnfor {#1}}&{$\bigl\{$\ {#2}\ $\bigr\}$}\\} \newcommand{\ebnfsinglerulev}[2]{\txt{{\ebnfvar{#1}}$\ \ \rightarrow\ \ ${#2}\\}} \newcommand{\ebnfsinglerule}[2]{\txt{{#1}$\ \ \rightarrow\ \ ${#2}\\}} \newcommand{\ebnfsingleruleav}[3]{\txt{{\ebnfvar{#1}}$\ \ \rightarrow\ \ ${#2}\ \ \ $\bigl\{$\ {#3}\ $\bigr\}$\\}} \newcommand{\ebnfsinglerulea}[3]{\txt{{#1}$\ \ \rightarrow\ \ ${#2}\ \ \ $\bigl\{$\ {#3}\ $\bigr\}$\\}}

Zunächst werden einige atomare Befehle definiert:

\ebnfvar erzeugt kursiv gesetzte Variable/Nicht-Terminale
\ebnfvara erzeugt kursiv gesetzte Variable/Nicht-Terminale in spitzen Klammern
\ebnfor erzeugt einen aufrechten Strich "|" für Oder-Möglichkeiten
\ebnfterm erzeugt ein Terminal (in Courier gesetzt)
\ebnfoption erzeugt einen optionalen Teil [...]
\ebnfmult erzeugt einen Teil in {...}
\ebnfattrib erzeugt ein Attribut für attributierte Grammatiken, eingeschlossen in {...}

Es gibt zwei Arten die Befehle zu nutzen:

ebnf-Umgebung. Hierin benutzt man für die einzelnen Zeilen die Befehle \ebnfrule, \ebnfrulev (Regeln mit linker und rechter Seite) und \ebnfhalfrule (Regeln ohne rechte Seite, aber mit vorangestellten |. Die Befehle \ebnfrulea, \ebnfruleav und \ebnfhalfrulea erzeugen rechts neben der Regel noch eine in { } gesetzten Teil, in dem Attributberechnungen gesetzt werden können (attributierte Grammatiken im Compilerbau). Die Regeln mit einem \ebnfrulev und \ebnfruleav gehen davon aus, dass auf der linken Seite nur eine Variable steht (dies spart eine \ebnfvar Anweisung). Hier einige Beispiele:

\begin{center} \begin{ebnf} \ebnfrulev{E}{\ebnfvar{E}\ebnfterm{+}\ebnfvar{F}} \ebnfhalfrule{\ebnfvar{E}\ebnfterm{-}\ebnfvar{F}} \ebnfhalfrule{\ebnfvar{E}} \ebnfrulev{F}{\ebnfvar{F}\ebnfterm{*} \ebnfvar{T}\ebnfor\ebnfvar{T}} \ebnfrulev{T}{\ebnfterm{(}\ebnfvar{E}\ebnfterm{)} \ebnfor\ebnfterm{id}} \end{ebnf} \end{center}
Die zwei \ebnfhalfrule erzeugen die halben Zeilen.

\begin{center} \begin{ebnf} \ebnfruleav{Z}{\ebnfvar{$V$} \ebnfvar{$B$}}{ $Z.v=V.v\times B.v$} \ebnfruleav{B}{\ebnfvar{$B_1$} \ebnfterm{ziffer}}{ $B.v=B_1.v\times10+\ebnfterm{ziffer.v};$} \ebnfhalfrulea{\ebnfterm{ziffer}}{ $B.v=\ebnfterm{ziffer.lexval};\ \ \ B.l=1$} \ebnfruleav{V}{\ebnfterm{+}}{ $V.v=+1$} \ebnfhalfrulea{\ebnfterm{-}}{ $V.v=-1$} \end{ebnf} \end{center}
Dies ist eine attributierte Grammatik zur Berechnung des Wertes einer Zahl mit Vorzeichen.

Als einzelne Grammatikdefinitionen in einer Textzeile. Dazu sind die \ebnfsinglerule*-Befehle zuständig. Hier einige Beispiele:

\ebnfsingleruleav{Z}{\ebnfvar{$V$} \ebnfvar{$B$}}{ $Z.v=V.v\times B.v$}

\ebnfsinglerulev{L}{\ebnfvar{$A$} \ebnfterm{operator}\ebnfvar{$B$}}

Pseudocode

Das Paket algorithmicx mit seinen zwei Geschmacksrichtungen algpseudocode und algpascal ermöglicht es Programme in Pseudocode und Pascal in das Dokument einzubinden. Dazu stellt es eine Umgebung und Befehle für die wichtigen syntaktischen Konstrukte bereit. Das Paket algorithmicx selbst ermöglicht es eigen Sprachen zu definieren. Dazu sei aber auf die Dokumentation verwiesen. Als erstes ein Beispiel (Euler-Integration):

  \begin{algorithmic}


    \Function{EulerIntegrate}{$y_0,
a, b, h, f(\cdot)$}


      \State
$N\gets \frac{b-a}{h}$\Comment{Anzahl
der Schritte berechnen}


      \State
$y\gets y_0$


      \For{$i=1,...,N$}\Comment{eigentliche
Integration}


        \State
$y\gets y + h\cdot f(a+i\cdot h)$


      \EndFor


      \State\Return
$y$


    \EndFunction


  \end{algorithmic}

Das Programm erzeug folgende Ausgabe (einmal ohne optionalen Parameter, einmal mit [1]:
example1

Um Programme in Pseudocode zu schreiben muss nur das Paket \usepackage{algpseudocode} eingebunden werden. Es stellt dann neben der algorithmic-Umgebung folgende Befehle zur Verfügung (Auswahl):

\State für einfache Auellcode-Zeilen
\Comment{Kommentar}für Kommentare am Ende der Zeile
\For{Bedingung} ... \EndFor
\ForAll{Bedingung} ... \EndFor
\While{Bedingung} ... \EndWhile
\Repeat... \Until{Bedingung}
\Loop... \EndLoop
\If{Bedingung} ... \ElseIf{Bedingung} ... \Else ... \EndIf
\Procedure{Name}{Parameter}... \EndProcedure
\Function{Name}{Parameter}...\State\Return ... \EndFunction
\Require \Ensure wird benutzt, wie \State
\call{Funktionsname}{Parameter} Funktions-Aufruf

Der Umgebung kann ein optionaler Parameter übergeben werden, der die Zeilen-Nummerierung steuert. o bedeutet keine Nummerierung, bei 1 wird jede Zeile nummeriert, bei 2 jede zweite usw. In der Umgebung kann das \label-Kommando ganz normal benutzt werden. Mit \algref{Marke} kann man dann auf eine Zeile im Algorithmus verweisen.

Mit dem folgenden Befehl kann man sich eine For-Schleife ohne abschließendes, angezeigtes EndFor erzeugen:

\algblockdefx{SmallFor}{EndSmallFor}[1]{\textbf{For} #1}{}

Übergibt man dem Paket die Option [noend], so werden alle EndFor, EndWhile etc. weggelassen!

Benutzt man zusätzlich das algorithm-Paket, so kann man den Algorithmus in eine

\begin{algorithm} ...
\end{algorithm}

-Umgebung stellen, der dann noch ein \label und mit \caption eine "Bildunterschrift" zugewiesen werden kann. In diesem Fall verweist \algref auf eine Zeile und \ref auf einen ganzen Algorithmus! Mit \listofalgorithms kann man (z.B. am Ende eines Dokumentes) eine Liste aller Algorithmen im Dokument erzeugen. Das Paket erzeugt dabei bei mir leider eine fehlermeldung: Der Befehl \theHalgorithm sei unbekannt. Dagegen hilft folgender Hack, der einfach einen soclhen Befehl erzeugt:

\newcommand{\theHalgorithm}{\thealgorithm}

Steht das in der Preambel, dann funktionierts.

Syntaxhervorhebung

Das Paket listings ermöglicht es Quellcode in verschiedenen Sprachen einzubinden, der dann mit Syntax-Hervorhebung angezeigt wird. Einbinden des Paketes:

\usepackage{listings}

Es stellt die Umgebung

\begin{lstlisting} ...
\end{lstlisting}

zur Verfügung. In sie kann einfach der Quellcode geschrieben werden. Das erzeugt eine Ausgabe, wie diese:
lstlisting

Mann kann aber auch eine externe Datei einbinden:

\lstinputlisting[Parameter]{Dateiname.end}

Zusätzlich ist es möglich im Text Code zu formatieren. Dazu verwendet man:

\lstinline!Code!

Der Code zwischen den Anführungszeichen wird angezeigt. Statt der Anführungszeichen kann jedes beliebige andere Zeichen verwendet werden, das nicht im Code auftaucht. Das funktioniert analog zu \verb!...!. Als Parameter für die Umgebung, sowie für \lstinputlisting sind erlaubt (Auswahl):

language=Sparache: gibt an, in welcher Programmiersprache der Code abgefasst ist. Die folgende Liste zählt einiger der verfügbaren Sprachen auf. Zu jeder Sprache kann ein Dialekt angegeben werden. Dies geschieht in der Form [Dialekt]Sprache, also etwa [Visual]C++:

BASIC, [ANSI|Objective|Sharp]C, [ANSI|ISO|GNU|Visual]C++, Algol, bash, Delphi, Java, Mathematica, MuPAD, Octave, Matlab, [77,90,95]Fortran, Gnuplot, HTML, Lisp, make, [Borland6|Standard|XSC]Pascal, PHP, Perl, R, Ruby, SQL, TeX, XML, XSLT ...
frame=single|none|shadowbox|lines|bottomline|topline|leftline: Definiert verschiedene Rahmen um den Code
framerule=1pt: Breite des Rahmens
tabsize=Anzahl an Zeichen: gibt an, wie lang ein Tabulator ist
title={Titel}: gibt einen Titel zur Umgebung an (erscheint über dem Code zentriert)
caption={Titel}: gibt eine Bildunterschrift zur Umgebung an
label=Name: Weist der Code-Umgebung das angegebene Label zu (Verweise mit \ref{})
backgroundcolor=\color{Farbe}: definiert eine Hintergrundfarbe
emph={id1, id2,... }: die Identifier id1, id2 usw. werden hervorgehoben
emphstyle=\underbar: unterstreicht hervorgehobene Identifier
columns=fixed | flexible | fullflexible: gibt an, ob Zeichen fester Breite oder variable Breite verwendet werden sollen.
lineskip=Abstand: definiert den Zeilenabstand
basicstyle=\small: definiert den Basisstiel aller Code-Elemente. Hier kann z.B. eine kleinere Schriftart eingestellt werden.
identifierstyle, commentstyle, stringstyle, keywordstyle, ndkeywordstyle, directivestyle: gibt den Anzeige-Stil des entsprechenden Code-Elementes an
showspaces, showtabs=true|false: gibt an, ob Leerzeichen/Tabulatoren durch eine feine Linie angezeigt werden sollen
numbers=none|left|right: gibt an, ob und wo die Zeilennummern stehen sollen
numberytle: definiert den Anzeigestil von zeilennummern
breaklines=true|false: gibt an, ob zu lange Zeilen automatisch umgebrochen werden sollen.

Die obigen parameter können auch mit \lstset{...} für das ganze Dokument gesetzt werden. Hier ein Beispiel für die Vordefinition:

\lstloadlanguages{C++}
\lstset{%
basicstyle=\footnotesize\ttfamily,
commentstyle=\footnotesize\itshape
}%

Das Kommando \lstloadlanguages lädt am Anfang bereits einige Sprachen. Dann geht das compilieren schneller.
Mit \lstlistoflistings kann man (z.B. am Ende eines Dokumentes) eine Liste aller eingebundener Quellcodes erstellen.

Mit dem folgenden Code kann man ein farbiges Highlighting für C++ erreichen. Dazu muss außerdem das color-Paket eingebunden werden.

`\definecolor{darkblue}{rgb}{0,0,.6}` `\definecolor{darkred}{rgb}{.6,0,0}` `\definecolor{darkgreen}{rgb}{0,.6,0}` `\definecolor{red}{rgb}{.98,0,0}` `\lstloadlanguages{C++}` `\lstset{%` `language=C++,` `basicstyle=\tiny\ttfamily,` `commentstyle=\itshape\color{darkgreen},` `keywordstyle=\bfseries\color{darkblue},` `stringstyle=\color{darkred},` `showspaces=false,` `showtabs=false,` `columns=fixed,` `numbers=left,` `frame=none,` `numberstyle=\tiny,` `breaklines=true,` `showstringspaces=false,` `xleftmargin=1cm` `}%`

`\definecolor{lightblue}{rgb}{0.8,0.85,1} \lstset{% language=C++, basicstyle=\tiny\ttfamily, commentstyle=\it, keywordstyle=\bf, stringstyle=\ttfamily, showspaces=false, showtabs=false, columns=fixed, backgroundcolor=\color{lightblue}, numbers=left, frame=single, numberstyle=\tiny, }%`

zurück zu LaTeX: Tips & tricks