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]
:
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:
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