Julia-Befehle – Schnellreferenz für Scientific Computing

Julia ist eine moderne Sprache für numerische Berechnungen, Datenanalyse und wissenschaftliches Rechnen. Sie verbindet die Einfachheit von Python mit der Geschwindigkeit von C – dank Just-in-Time-Kompilierung (JIT).

Erste Schritte

julia           # REPL starten
julia script.jl # Skript ausführen
julia -e 'println("Hallo")'  # Einzeiler

Variablen und Typen

x = 42                # Int
y = 3.14              # Float
s = "Hanse"           # String
const PI = 3.14159    # Konstante
::Int64               # Typannotation

Multiple Dispatch: Julia-Spezialität

flaeche(r::Float64) = π * r^2
flaeche(r::Int) = flaeche(Float64(r))
# Gleicher Funktionsname, verschiedene Typen

Arrays und Comprehensions

v = [1, 2, 3]              # Vektor
m = [1 2; 3 4]              # 2x2-Matrix
quadrate = [x^2 for x in 1:5]  # [1, 4, 9, 16, 25]
sum(v), mean(v)             # Statistik

Ökosystem (Paketmanager Pkg)

using Pkg
Pkg.add("DataFrames")   # Datenanalyse
Pkg.add("Plots")        # Visualisierung
Pkg.add("CUDA")         # GPU-Computing

Damit lassen sich DataFrames (vergleichbar mit R und pandas) und GPU-Berechnungen direkt nutzen – siehe auch GPU und Compiler.

Kontrollfluss

for i in 1:3
  println(i)
end

if x > 10
  println("groß")
else
  println("klein")
end

Warum Julia?

• Schnell – JIT-Kompilierung, nahe C-Geschwindigkeit.
• Mathematisch lesbar – Unicode-Symbole wie π, √, ∈ sind erlaubt.
• Wissenschaftlich stark – Differentialgleichungen, Optimierung, ML (Flux.jl).
• Interoperabel – ruft Python, R und C-Bibliotheken auf.

Weiterführend: Python-Befehle, R-Befehle, Machine Learning.

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.