Haskell – Pure Functional Programming

Haskell ist eine rein funktionale, statisch typisierte Programmiersprache mit Lazy Evaluation. Das bedeutet: Funktionen haben keine Seiteneffekte, Variablen sind unveränderlich, und Ausdrücke werden erst ausgewertet, wenn ihr Wert wirklich gebraucht wird. Haskell eignet sich hervorragend, um komplexe Algorithmen kompakt und nachweisbar korrekt zu formulieren.

GHC & GHCi – Compiler und REPL

• ghc --version – Compiler-Version prüfen
• ghc Datei.hs – kompiliert zu einer ausführbaren Datei
• ghc -O2 Datei.hs – mit Optimierung kompilieren
• ghci – interaktive REPL (Read-Eval-Print-Loop) starten
• :load Datei.hs bzw. :l – Modul in GHCi laden
• :t ausdruck – Typ eines Ausdrucks anzeigen
• :info name – Informationen zu einer Funktion
• :quit bzw. :q – GHCi beenden

Basissyntax

-- Kommentar
fac :: Integer -> Integer      -- Typ-Signatur
fac 0 = 1                     -- Basisfall
fac n = n * fac (n - 1)       -- Rekursion

main :: IO ()
main = print (fac 20)

Wichtige Konzepte

• Pure Functions: gleiche Eingabe, gleiche Ausgabe, keine Seiteneffekte
• Immutable Data: Werte sind unveränderlich; „Ändern“ erzeugt neue Werte
• Lazy Evaluation: Ausdrücke werden nur bei Bedarf ausgewertet – erlaubt unendliche Listen wie take 5 [1..]
• Higher-Order Functions: map, filter, foldr/foldl
• Typklassen: Num, Eq, Ord, Show – generische Funktionen
• Monaden: kapseln Seiteneffekte (IO), Fehler (Maybe/Either) und Zustand – z. B. do-Notation

Nützliche Funktionen

map (*2) [1,2,3]        -- [2,4,6]
filter even [1..10]     -- [2,4,6,8,10]
foldr (+) 0 [1..100]    -- 5050
take 5 (repeat 7)       -- [7,7,7,7,7]

Pakete: Cabal und Stack

• cabal update – Paketindex aktualisieren
• cabal install <paket> – Paket installieren
• stack build – Projekt bauen
• stack ghci – REPL im Projektkontext

Weitere Sprachen im Glossar: Scala, Elixir & Erlang und Julia. Grundlagen funktionaler Konzepte: Algorithmus und Compiler.

Prolog – Logikprogrammierung

Prolog (Programming in Logic) ist eine deklarative Programmiersprache: Statt Algorithmen beschreibst du Fakten und Regeln, und die Engine (der Resolution-Mechanismus) beantwortet Anfragen per Backtracking. Prolog wird klassisch in KI, Expertensystemen und Sprachverarbeitung eingesetzt.

SWI-Prolog – Die gängigste Distribution

• swipl – interaktive REPL starten
• swipl -s datei.pl – Datei laden (consult)
• swipl -f datei.pl -g anfrage – Anfrage direkt ausführen
• halt. – Prolog beenden

Basissyntax: Fakten, Regeln, Anfragen

% Fakten
eltern(hans, peter).
eltern(anna, peter).
eltern(peter, lisa).

% Regel
großelter(X, Y) :- eltern(X, Z), eltern(Z, Y).

% Anfrage
?- großelter(anna, lisa).
true.

• Variablen beginnen mit Großbuchstaben: X, Y
• Atome/Konstanten beginnen klein: hans
• :- bedeutet „wenn“ (Implikation), , ist UND, ; ist ODER
• Backtracking: findet automatisch alle Lösungen, z. B. findall(X, eltern(X, peter), L).

Wichtige eingebaute Prädikate

• member(X, Liste) – X ist Element der Liste
• append(L1, L2, L3) – Listen verketten
• length(L, N) – Listenlänge
• sort(L, S) – sortieren
• findall(T, Ziel, Liste) – alle Lösungen sammeln
• assert/retract – Fakten zur Laufzeit hinzufügen/entfernen
• write(X), nl – Ausgabe
• read(X) – Eingabe

Typische Einsatzgebiete

• Expertensysteme: Wenn-Dann-Regeln für Diagnosen
• Constraint-Programming: library(clpfd) für Rätsel und Planung
• Grammatiken: DCG (Definite Clause Grammars) für Parser
• Suchprobleme: Backtracking löst viele Kombinatorik-Probleme von selbst

Verwandte Einträge: Algorithmus, Rekursion und die Referenz Haskell für funktionale Alternativen.

MATLAB – Numerische Berechnung und Plots

MATLAB (MATrix LABoratory) ist eine proprietäre Sprache und Umgebung für numerische Berechnungen, Datenanalyse und Visualisierung. Grundlage ist die Arbeit mit Matrizen – fast jeder Befehl arbeitet vektorisiert, also auf ganzen Arrays gleichzeitig. Alternativen: Julia und Python mit NumPy/SciPy.

Grundbefehle

• help <befehl> – Dokumentation anzeigen
• doc <befehl> – Dokumentationsfenster öffnen
• clc – Kommandozeile leeren
• clear – Variablen löschen
• who / whos – Variablen auflisten
• format long / format short – Zahlenformat
• diary on / off – Session in Datei mitschreiben

Matrizen und Vektoren

v = [1 2 3]            % Zeilenvektor
w = [1; 2; 3]          % Spaltenvektor
A = [1 2; 3 4]         % 2x2-Matrix
A'                     % Transponierte
A * B                  % Matrixmultiplikation
A .* B                 % elementweise Multiplikation
1:5                    % [1 2 3 4 5]
linspace(0, 1, 11)     % 11 Punkte von 0 bis 1
zeros(3), ones(2,4), eye(3), rand(3)

Programmierung

• if ... elseif ... else ... end
• for i = 1:10 ... end
• while bedingung ... end
• function [out] = name(in) ... end – in einer .m-Datei
• disp(x) – Ausgabe
• fprintf('Wert: %f ', x) – formatierte Ausgabe

Plots

plot(x, y)              % Liniendiagramm
plot(x, y, 'r--')       % Farbe/Linienstil
scatter(x, y)           % Punktwolke
bar(x)                  % Balkendiagramm
histogram(x)            % Histogramm
xlabel('x'), ylabel('y'), title('Titel')
legend('a', 'b')
grid on
subplot(2,1,1)          % mehrere Plots in einer Figur
saveas(gcf, 'plot.png') % als Bild speichern

Weitere nützliche Funktionen

• sum, mean, median, std, min, max – Statistik
• find(A > 5) – Indizes von Elementen
• sort, unique, reshape, transpose
• fzero, fsolve, ode45 – Nullstellen und DGL lösen
• fminsearch – Optimierung
• t = readtable('daten.csv'); plot(t) – Daten aus CSV laden

Verwandte Einträge: Julia, R und die Glossar-Einträge Array sowie Algorithmus.

Regex – Reguläre Ausdrücke verständlich erklärt

Ein regulärer Ausdruck (engl. regular expression, kurz Regex) ist ein Suchmuster, mit dem sich Text durchsuchen, prüfen und ersetzen lässt. Regex gibt es in fast jeder Programmiersprache und in vielen Kommandozeilen-Tools: grep, sed, awk, Python (re), JavaScript, PHP (preg_*) – die Grundlagen sind überall gleich.

Die wichtigsten Bausteine

• Literale: Normale Zeichen wie hanse matchen sich selbst.
• Metazeichen: . = beliebiges Zeichen, ^ = Anfang, $ = Ende.
• Zeichenklassen: [abc] = a oder b oder c, [a-z] = Kleinbuchstaben. Kurzformen: d (Ziffer), w (Buchstabe/Ziffer/Unterstrich), s (Leerzeichen).
• Quantifier: * (0 oder mehr), + (1 oder mehr), ? (0 oder 1), {2,4} (2 bis 4).
• Gruppen & Alternativen: (ab|cd) = ab oder cd; Klammern fangen zugleich Text für spätere Referenzen.
• Escape: . matcht einen echten Punkt – Sonderzeichen müssen mit Backslash geschützt werden.

Gierig vs. faul

Quantifier sind standardmäßig gierig: <.*> matcht in <a><b> den ganzen String bis zum letzten >. Ein ? nach dem Quantifier macht ihn faul: <.*?> stoppt am ersten >. Bei HTML/XML-Auswertung ist das oft der gewünschte Modus.

Beispiele

# Alle Zeilen mit 4-stelliger Jahreszahl finden (grep -E)
grep -E '[0-9]{4}' log.txt

# E-Mail-Adressen in Python finden
import re
muster = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}'
re.findall(muster, text)

Praxistipps

• Regex in grep/sed braucht oft -E (extended) – siehe Bash-Befehle.
• Komplexe Muster testen: mit python3 -c oder Online-Testern (z. B. regex101.com) Schritt für Schritt aufbauen.
• Vorsicht Backtracking: verschachtelte .* können bei langen Eingaben sehr langsam werden.
• HTML/JSON nicht „von Hand" mit Regex parsen, wenn es Bibliotheken gibt – Regex ist für Textmuster, nicht für strukturierte Formate.

Weiterführend: Python-Befehle, SQL-Befehle und der Glossar-Eintrag Query.