Informatik Rechner
Alle Informatik-Formeln in einer App. Wähle eine Kategorie, suche nach Stichwort, rechne sofort — mit automatischer Variablen-Umstellung.
- Alle Kategorien
- Zahlensysteme & Kodierung
- Boolesche Algebra
- Datendarstellung & Speicher
- IEEE 754 Gleitkomma
- Algorithmen & Komplexität
- Datenstrukturen
- Netzwerk & Protokolle
- Kryptographie & Hashing
- Datenbanken
- Betriebssysteme & Prozesse
- Compilerbau & Formale Sprachen
- Informationstheorie
- Computergrafik
- Performance & Benchmarking
- Dezimal zu Binär (Stellen)
- Dezimal zu Hexadezimal (Stellen)
- Dezimal zu Oktal (Stellen)
- Binär zu Dezimal (Stellenwert)
- Hexadezimal zu Dezimal (Stellenwert)
- Oktal zu Dezimal (Stellenwert)
- Binär zu Hexadezimal (Stellen)
- Hexadezimal zu Binär (Stellen)
- BCD-Kodierung
- Gray-Code aus Binär
- Binär aus Gray-Code
- Zweierkomplement
- Zweierkomplement Wertebereich
- Einerkomplement
- AND (UND)
- OR (ODER)
- NOT (NICHT)
- NAND (NICHT-UND)
- NOR (NICHT-ODER)
- XOR (Exklusiv-ODER)
- XNOR (Äquivalenz)
- De Morgan 1
- De Morgan 2
- Karnaugh-Veitch 2 Variablen
- Karnaugh-Veitch 3 Variablen
- Karnaugh-Veitch 4 Variablen
- Bit zu Byte
- Byte zu Kilobyte (binär)
- Byte zu Megabyte (binär)
- Byte zu Gigabyte (binär)
- Byte zu Terabyte (binär)
- Byte zu Kilobyte (dezimal)
- Speicherbedarf Integer
- Speicherbedarf Float
- Speicherbedarf String (ASCII)
- Speicherbedarf String (UTF-8)
- Speicherbedarf Bild (unkomprimiert)
- Speicherbedarf Audio (unkomprimiert)
- Speicherbedarf Video (unkomprimiert)
- Darstellbare Werte (n Bit)
- Wertebereich unsigned (n Bit)
- Wertebereich signed (n Bit)
- Speicherbedarf Datensätze
- Float 32 Aufbau
- Double 64 Aufbau
- Dezimal zu Float32 Wert
- Bias-Exponent (32 Bit)
- Bias-Exponent (64 Bit)
- Maschinenepsilon (32 Bit)
- Maschinenepsilon (64 Bit)
- Maximaler Gleitkommawert
- Minimaler positiver Gleitkommawert
- O-Notation Vergleich
- Laufzeit linear O(n)
- Laufzeit quadratisch O(n²)
- Master-Theorem (Fall 1)
- Master-Theorem (Fall 2)
- Master-Theorem (Fall 3)
- Binäre Suche Schritte
- Bubble Sort Vergleiche
- Selection Sort Vergleiche
- Merge Sort Vergleiche
- Quick Sort Vergleiche (Average)
- Heap Sort Vergleiche
- Rekursionstiefe Binärraum
- Laufzeit O(n · log n)
- Array Zugriffszeit
- Linked List Zugriffszeit
- Stack Kapazität
- Queue Kapazität
- Hash-Tabelle Lastfaktor
- Hash-Tabelle Kollisionswahrscheinlichkeit
- Binärbaum max. Knoten
- Binärbaum min. Tiefe
- B-Baum max. Schlüssel
- Heap Eltern-Index
- Heap Kind-links Index
- Heap Kind-rechts Index
- CIDR zu Subnetzmaske
- Hosts aus CIDR
- Anzahl Subnetze
- Netzwerkadresse
- Broadcastadresse
- Erste nutzbare IP
- Letzte nutzbare IP
- IPv6 Adressraum
- Bandbreite Bit/s zu Byte/s
- Übertragungsdauer
- Latenz (Round Trip Time)
- Durchsatz (Goodput)
- Paketverlustrate
- Shannon-Kapazität
- Nyquist-Kapazität
- Subnetzmaske zu CIDR
- Bandbreiten-Verzögerungs-Produkt
- Mögliche Schlüssel
- Brute-Force-Zeit
- Passwort-Entropie
- Passwortentropie (Zeichenraum)
- Kollisions-Wahrscheinlichkeit (Geburtstagsparadoxon)
- Hash-Ausgabelänge
- RSA Grundformel
- RSA Verschlüsselung
- RSA Entschlüsselung
- Diffie-Hellman Schlüsselaustausch
- XOR Verschlüsselung
- Caesar-Chiffre
- Vigenère Schlüssellänge
- CRC Prüfbits
- 1NF Prüfung
- 2NF Prüfung
- 3NF Prüfung
- Kardinalität (Kreuzprodukt)
- Index-Größe B-Baum
- Speicherbedarf Tabelle
- Abfragekosten Sequential Scan
- Abfragekosten Index Scan
- Transaktionsrate (TPS)
- DB-Größe Schätzung
- CPU-Auslastung
- Speicher-Auslastung
- FCFS-Wartezeit
- SJF-Wartezeit
- Round-Robin-Wartezeit
- Durchschnittliche Wartezeit
- Durchschnittliche Verweilzeit
- Seitenrahmen-Speicher
- Seitenfehlerrate
- Thrashing-Schwelle
- Semaphor-Ressourcenverwaltung
- Deadlock — Minimale Ressourcen
- Regulärer Ausdruck Zeichenanzahl
- DFA Zustandsübergänge
- Grammatik Ableitungsschritte
- FIRST/FOLLOW-Menge Größe
- LL(1) Parsertabelle Größe
- Token-Länge Lexer
- Syntaxbaumtiefe
- NFA zu DFA Zustandsexplosion
- Shannon-Entropie
- Informationsgehalt
- Redundanz
- Kodierungseffizienz
- Huffman min. Codewortlänge
- Mittlere Codewortlänge
- Kanalkapazität (Shannon)
- Bitfehlerrate (BER)
- Hamming-Distanz
- Hamming-Code Prüfbits
- Parität (gerade)
- Parität (ungerade)
- CRC-Prüfbits
- Pixel zu Weltkoordinate
- Skalierung 2D
- Rotation 2D (X-Komponente)
- Translation 2D
- Perspektivische Projektion
- Seitenverhältnis (Aspect Ratio)
- DPI (Punkte pro Zoll)
- Farbtiefe
- Framerate (FPS)
- Renderzeit pro Frame
- RGB zu Graustufe
- RGB zu HSL (Lightness)
- RGB zu HSL (Saturation)
- Gammakorrektur
- Weltkoordinate zu Pixel
- MIPS (Millionen Instruktionen pro Sekunde)
- FLOPS (Gleitkomma-Operationen pro Sekunde)
- CPI (Zyklen pro Instruktion)
- CPU-Taktzeit
- Ausführungszeit
- Amdahls Gesetz (Speedup)
- Gustafsons Gesetz (skalierter Speedup)
- Cache-Trefferrate
- Effektive Zugriffszeit
- Speicherbandbreite
- Latenz-Bandbreite-Produkt
- Parallelisierungseffizienz
Dezimal zu Binär (Stellen) berechnen
Anzahl der Binärstellen, die zur Darstellung einer nicht-negativen ganzen Dezimalzahl benötigt werden: ⌈log₂(n + 1)⌉.
- Stellen — Binärstellen
- n — Dezimalwert
Dezimal zu Hexadezimal (Stellen) berechnen
Anzahl der Hexadezimalstellen zur Darstellung einer nicht-negativen ganzen Dezimalzahl: ⌈log₁₆(n + 1)⌉.
- Stellen — Hex-Stellen
- n — Dezimalwert
Dezimal zu Oktal (Stellen) berechnen
Anzahl der Oktalstellen zur Darstellung einer nicht-negativen ganzen Dezimalzahl: ⌈log₈(n + 1)⌉.
- Stellen — Oktalstellen
- n — Dezimalwert
Binär zu Dezimal (Stellenwert) berechnen
Dezimalwert einer einzelnen Binärstelle: Wert = bit · 2^pos. Über alle Stellen aufsummiert ergibt das den Gesamtwert.
- Wert — Dezimalwert
- bit — Bitwert
- pos — Position
Hexadezimal zu Dezimal (Stellenwert) berechnen
Dezimalwert einer einzelnen Hexadezimalstelle: Wert = ziffer · 16^pos. Hex-Ziffern sind 0–15.
- Wert — Dezimalwert
- ziffer — Hex-Ziffer
- pos — Position
Oktal zu Dezimal (Stellenwert) berechnen
Dezimalwert einer einzelnen Oktalstelle: Wert = ziffer · 8^pos. Oktalziffern sind 0–7.
- Wert — Dezimalwert
- ziffer — Oktalziffer
- pos — Position
Binär zu Hexadezimal (Stellen) berechnen
Vier Binärstellen entsprechen genau einer Hexadezimalstelle: HexStellen = ⌈BinStellen / 4⌉.
- HexStellen — Hex-Stellen
- BinStellen — Binärstellen
Hexadezimal zu Binär (Stellen) berechnen
Jede Hexadezimalstelle entspricht genau vier Binärstellen: BinStellen = HexStellen · 4.
- BinStellen — Binärstellen
- HexStellen — Hex-Stellen
BCD-Kodierung berechnen
Binary Coded Decimal: pro Dezimalstelle werden vier Bits verwendet. Bits = Dezimalstellen · 4.
- Bits — BCD-Bits
- Dezimalstellen — Dezimalstellen
Gray-Code aus Binär berechnen
Der Gray-Code wird aus dem Binärwert mit G = n XOR (n ≫ 1) gebildet. Zwei aufeinanderfolgende Gray-Code-Werte unterscheiden sich genau in einem Bit.
Binär aus Gray-Code berechnen
Rückwandlung Gray → Binär durch sukzessives XOR mit allen rechts-geschobenen Versionen: n = G XOR (G ≫ 1) XOR (G ≫ 2) …
Zweierkomplement berechnen
Zweierkomplement-Darstellung einer negativen Zahl als vorzeichenlose Bitfolge: neg = 2^n − pos. Bei n Bits wird so −pos als (2^n − pos) abgebildet.
- neg — Zweierkomplement
- pos — Positiver Wert
- n — Bitbreite
Zweierkomplement Wertebereich berechnen
Darstellbarer Wertebereich im Zweierkomplement mit n Bits: Min = −2^(n − 1), Max = 2^(n − 1) − 1. Beispiel n = 8: −128 bis 127.
- Min — Minimum
- Max — Maximum
- n — Bitbreite
Einerkomplement berechnen
Einerkomplement-Darstellung: bitweise Invertierung, äquivalent zu Ergebnis = (2^n − 1) − Wert. Hat zwei Nulldarstellungen (+0 und −0).
- Ergebnis — Einerkomplement
- Wert — Ausgangswert
- n — Bitbreite
AND (UND) berechnen
Logisches UND: Y = A AND B. Der Ausgang ist nur dann 1, wenn beide Eingänge 1 sind — sonst 0.
OR (ODER) berechnen
Logisches ODER: Y = A OR B. Der Ausgang ist 1, sobald mindestens ein Eingang 1 ist.
NOT (NICHT) berechnen
Logische Negation: Y = NOT A. Invertiert den Eingang — aus 0 wird 1, aus 1 wird 0.
NAND (NICHT-UND) berechnen
Logisches NAND: Y = NOT(A AND B). Der Ausgang ist nur dann 0, wenn beide Eingänge 1 sind — universelles Gatter.
NOR (NICHT-ODER) berechnen
Logisches NOR: Y = NOT(A OR B). Der Ausgang ist nur dann 1, wenn beide Eingänge 0 sind — universelles Gatter.
XOR (Exklusiv-ODER) berechnen
Logisches XOR: Y = A XOR B. Der Ausgang ist 1, wenn genau ein Eingang 1 ist — die Eingänge müssen sich unterscheiden.
XNOR (Äquivalenz) berechnen
Logisches XNOR: Y = NOT(A XOR B). Der Ausgang ist 1, wenn beide Eingänge gleich sind — auch Äquivalenz-Gatter genannt.
De Morgan 1 berechnen
De Morgans erstes Gesetz: NOT(A AND B) = NOT(A) OR NOT(B). Beide Seiten liefern denselben Wahrheitswert.
De Morgan 2 berechnen
De Morgans zweites Gesetz: NOT(A OR B) = NOT(A) AND NOT(B). Beide Seiten liefern denselben Wahrheitswert.
Karnaugh-Veitch 2 Variablen berechnen
Anzahl der Zellen einer KV-Tafel: Zellen = 2^n. Für 2 Variablen ergeben sich 4 Zellen (2 × 2-Raster).
- Zellen — KV-Zellen
- n — Variablenanzahl
Karnaugh-Veitch 3 Variablen berechnen
Maximale Gruppenanzahl in einer KV-Tafel: MaxGruppen = 2^n / 2. Für 3 Variablen ergeben sich höchstens 4 Gruppen.
- MaxGruppen — Max. Gruppen
- n — Variablenanzahl
Karnaugh-Veitch 4 Variablen berechnen
Maximale Anzahl Primimplikanten: MaxPrim = 2^(n − 1). Für 4 Variablen ergeben sich höchstens 8 Primimplikanten.
- MaxPrim — Max. Primimplikanten
- n — Variablenanzahl
Bit zu Byte berechnen
Umrechnung zwischen Bit und Byte: Byte = Bit / 8. Ein Byte besteht definitionsgemäß aus acht Bit.
- Byte — Byte
- Bit — Bit
Byte zu Kilobyte (binär) berechnen
Binäre Umrechnung Byte → Kilobyte (KiB): KB = Byte / 1024. Mit Zweierpotenz-Faktor, typisch in Betriebssystemen und Speicheranzeigen.
- KB — Kilobyte
- Byte — Byte
Byte zu Megabyte (binär) berechnen
Binäre Umrechnung Byte → Megabyte (MiB): MB = Byte / 1.048.576 = Byte / 1024². Faktor 2²⁰.
- MB — Megabyte
- Byte — Byte
Byte zu Gigabyte (binär) berechnen
Binäre Umrechnung Byte → Gigabyte (GiB): GB = Byte / 1.073.741.824 = Byte / 1024³. Faktor 2³⁰.
- GB — Gigabyte
- Byte — Byte
Byte zu Terabyte (binär) berechnen
Binäre Umrechnung Byte → Terabyte (TiB): TB = Byte / 2⁴⁰ = Byte / 1024⁴.
- TB — Terabyte
- Byte — Byte
Byte zu Kilobyte (dezimal) berechnen
Dezimale Umrechnung Byte → Kilobyte (SI): kB = Byte / 1000. Typisch für Festplatten- und Netzwerkangaben nach SI-Definition.
- kB — Kilobyte
- Byte — Byte
Speicherbedarf Integer berechnen
Speicherbedarf für eine Folge ganzzahliger Werte: Speicher = Anzahl · ByteProInt. Typische Größen sind 4 Byte für int32 oder 8 Byte für int64.
- Speicher — Speicherbedarf
- Anzahl — Anzahl Werte
- ByteProInt — Byte pro Integer
Speicherbedarf Float berechnen
Speicherbedarf für eine Folge Gleitkommazahlen: Speicher = Anzahl · ByteProFloat. 4 Byte für float32, 8 Byte für float64 (double).
- Speicher — Speicherbedarf
- Anzahl — Anzahl Werte
- ByteProFloat — Byte pro Float
Speicherbedarf String (ASCII) berechnen
Bei reinem ASCII belegt jedes Zeichen genau ein Byte: Speicher = Zeichen · 1. Gilt für 7-Bit-ASCII und einbytige Codepages.
- Speicher — Speicherbedarf
- Zeichen — Zeichenanzahl
Speicherbedarf String (UTF-8) berechnen
UTF-8 kodiert variabel mit 1–4 Byte pro Codepoint: Speicher = Zeichen · ByteProZeichen. Lateinische Buchstaben 1 Byte, Umlaute 2 Byte, CJK 3 Byte, Emoji bis 4 Byte.
- Speicher — Speicherbedarf
- Zeichen — Zeichenanzahl
- ByteProZeichen — Byte pro Zeichen
Speicherbedarf Bild (unkomprimiert) berechnen
Speicherbedarf eines unkomprimierten Rasterbildes: Speicher = Breite · Höhe · Farbtiefe / 8. Farbtiefe in Bit pro Pixel, Ergebnis in Byte.
- Speicher — Speicherbedarf
- Breite — Breite
- Höhe — Höhe
- Farbtiefe — Farbtiefe
Speicherbedarf Audio (unkomprimiert) berechnen
Speicherbedarf einer unkomprimierten PCM-Audiospur: Speicher = Abtastrate · BitTiefe · Kanäle · Dauer / 8. Beispiel CD: 44.100 Hz · 16 Bit · 2 Kanäle.
- Speicher — Speicherbedarf
- Dauer — Dauer
- Abtastrate — Abtastrate
- BitTiefe — Bittiefe
Speicherbedarf Video (unkomprimiert) berechnen
Speicherbedarf von unkomprimiertem Rohvideo: Speicher = Breite · Höhe · Farbtiefe · FPS · Dauer / 8. Faktor pro Frame mal Framerate mal Dauer.
- Speicher — Speicherbedarf
- Dauer — Dauer
Darstellbare Werte (n Bit) berechnen
Mit n Bit lassen sich genau 2^n verschiedene Werte darstellen. Umgekehrt: n = log₂(Werte). Grundgleichung jeder Bitbreiten-Abschätzung.
- Werte — Darstellbare Werte
- n — Bitanzahl
Wertebereich unsigned (n Bit) berechnen
Vorzeichenlose Ganzzahl mit n Bit: Min = 0, Max = 2^n − 1. Beispiel n = 8 (uint8): 0 bis 255, n = 16: 0 bis 65.535.
- Max — Maximalwert
- n — Bitanzahl
Wertebereich signed (n Bit) berechnen
Vorzeichenbehaftete Ganzzahl im Zweierkomplement mit n Bit: Min = −2^(n − 1), Max = 2^(n − 1) − 1. Beispiel int8: −128 bis 127.
- Min — Minimum
- Max — Maximum
- n — Bitanzahl
Speicherbedarf Datensätze berechnen
Speicherbedarf einer Tabelle mit gleich großen Datensätzen: Speicher = Anzahl · ByteProDatensatz. Grundkalkulation für Tabellengrößen und Importvolumen.
- Speicher — Speicherbedarf
- Anzahl — Datensätze
- ByteProDatensatz — Byte pro Datensatz
Float 32 Aufbau berechnen
IEEE 754 Single Precision: 1 Vorzeichenbit + 8 Exponentenbits + 23 Mantissenbits = 32 Bit. Auflösung wahlweise nach Gesamtbreite oder Mantissenbits.
- Gesamt — Gesamtbits
- Mantisse — Mantissenbits
Double 64 Aufbau berechnen
IEEE 754 Double Precision: 1 Vorzeichenbit + 11 Exponentenbits + 52 Mantissenbits = 64 Bit. Bitfelder summieren sich exakt zur Gesamtbreite.
- Gesamt — Gesamtbits
- Mantisse — Mantissenbits
Dezimal zu Float32 Wert berechnen
Berechnet den Float32-Dezimalwert aus den drei Bitfeldern: Wert = (−1)^S · 2^(E − 127) · (1 + M / 2^23).
Bias-Exponent (32 Bit) berechnen
Umrechnung zwischen realem und gespeichertem Exponenten bei Float32: Gespeichert = Exponent + 127. Direkt umstellbar.
- Gespeichert — Gespeicherter Exponent
- Exponent — Realer Exponent
Bias-Exponent (64 Bit) berechnen
Umrechnung zwischen realem und gespeichertem Exponenten bei Float64: Gespeichert = Exponent + 1023. Direkt umstellbar.
- Gespeichert — Gespeicherter Exponent
- Exponent — Realer Exponent
Maschinenepsilon (32 Bit) berechnen
Kleinster Abstand zur nächsten darstellbaren Zahl oberhalb von 1: eps = 2^(−Mantissenbits). Für Float32 ergibt sich 2^(−23) ≈ 1,19·10⁻⁷.
- eps — Maschinenepsilon
- Mantissenbits — Mantissenbits
Maschinenepsilon (64 Bit) berechnen
Maschinenepsilon für Double Precision: eps = 2^(−Mantissenbits). Mit 52 Mantissenbits ergibt sich 2^(−52) ≈ 2,22·10⁻¹⁶.
- eps — Maschinenepsilon
- Mantissenbits — Mantissenbits
Maximaler Gleitkommawert berechnen
Größter darstellbarer Wert: MaxVal = (2 − 2^(−m)) · 2^(2^(e−1) − 1). Für Float32 ≈ 3,4·10³⁸, für Float64 ≈ 1,8·10³⁰⁸.
Minimaler positiver Gleitkommawert berechnen
Kleinster positiver normalisierter Wert: MinVal = 2^(2 − 2^(e−1)). Für Float32 ≈ 1,18·10⁻³⁸, für Float64 ≈ 2,23·10⁻³⁰⁸.
- MinVal — Minimalwert
- e — Exponentenbits
O-Notation Vergleich berechnen
Vergleicht die Operationsanzahl verschiedener Komplexitätsklassen für eine Eingabegröße n. Hier konkret: Wert von O(log n) = log₂(n).
- OLogN — O(log n)
- n — Eingabegröße
Laufzeit linear O(n) berechnen
Operationsanzahl bei linearer Komplexität: Ops = n · k. Jedes Element wird mit konstantem Aufwand k bearbeitet.
- Ops — Operationen
- n — Eingabegröße
- k — Konstante
Laufzeit quadratisch O(n²) berechnen
Operationsanzahl bei quadratischer Komplexität: Ops = n². Typisch für verschachtelte Schleifen über dieselbe Eingabe.
- Ops — Operationen
- n — Eingabegröße
Master-Theorem (Fall 1) berechnen
Rekurrenz T(n) = a·T(n/b) + O(n^c). Im Fall 1 (c < log_b(a)) dominiert die Rekursion: T(n) = O(n^(log_b(a))).
Master-Theorem (Fall 2) berechnen
Rekurrenz T(n) = a·T(n/b) + O(n^c). Im Fall 2 (c = log_b(a)) tragen Rekursion und Kombinieren gleich bei: T(n) = O(n^c · log n).
Master-Theorem (Fall 3) berechnen
Rekurrenz T(n) = a·T(n/b) + O(n^c). Im Fall 3 (c > log_b(a)) dominiert der Kombinieren-Schritt: T(n) = O(n^c).
- T — Laufzeit
- n — Eingabegröße
- c — Exponent
Binäre Suche Schritte berechnen
Maximale Anzahl Schritte (Vergleiche) der binären Suche in einem sortierten Array: Schritte = ⌈log₂(n)⌉.
- Schritte — Max. Schritte
- n — Elementanzahl
Bubble Sort Vergleiche berechnen
Anzahl Vergleiche im Worst Case beim Bubble Sort: Vergleiche = n · (n − 1) / 2. Wächst quadratisch mit n.
- Vergleiche — Vergleiche
- n — Elementanzahl
Selection Sort Vergleiche berechnen
Anzahl Vergleiche beim Selection Sort — unabhängig von der Eingabereihenfolge: Vergleiche = n · (n − 1) / 2.
- Vergleiche — Vergleiche
- n — Elementanzahl
Merge Sort Vergleiche berechnen
Anzahl Vergleiche beim Merge Sort (Divide & Conquer): Vergleiche = n · log₂(n). Garantierte O(n log n)-Laufzeit.
Quick Sort Vergleiche (Average) berechnen
Durchschnittliche Anzahl Vergleiche beim Quick Sort: Vergleiche ≈ 1,39 · n · log₂(n). Im Worst Case (schlechter Pivot) entartet er zu O(n²).
Heap Sort Vergleiche berechnen
Anzahl Vergleiche beim Heap Sort im Worst Case: Vergleiche = 2 · n · log₂(n). Garantierte O(n log n)-Laufzeit ohne zusätzlichen Speicher.
Rekursionstiefe Binärraum berechnen
Maximale Rekursionstiefe bei halbierender Teilung des Problems: Tiefe = ⌊log₂(n)⌋. Begrenzt den benötigten Stack.
- Tiefe — Rekursionstiefe
- n — Problemgröße
Laufzeit O(n · log n) berechnen
Operationsanzahl bei O(n log n)-Komplexität: Ops = n · log₂(n). Typisch für effiziente Sortierverfahren und Divide-&-Conquer-Algorithmen.
Array Zugriffszeit berechnen
Speicheradresse eines Array-Elements aus Basisadresse, Index und Elementgröße: Adresse = Basis + Index · Elementgroesse. Konstante Zeit O(1).
- Adresse — Elementadresse
- Index — Index
- Basis — Basisadresse
Linked List Zugriffszeit berechnen
Anzahl Schritte zum Erreichen eines Elements in einer einfach verketteten Liste: Schritte = Index. Lineare Zeit O(n).
- Schritte — Schritte
- Index — Index
Stack Kapazität berechnen
Speicherbedarf eines Stacks bei fester Kapazität: Speicher = Kapazitaet · Elementgroesse. Pre-allokierter Block, kein Overhead pro Element.
- Speicher — Speicherbedarf
- Kapazitaet — Kapazität
- Elementgroesse — Elementgröße
Queue Kapazität berechnen
Speicherbedarf einer Queue (Ringpuffer) bei fester Kapazität: Speicher = Kapazitaet · Elementgroesse. FIFO-Datenstruktur mit konstantem Pro-Element-Aufwand.
- Speicher — Speicherbedarf
- Kapazitaet — Kapazität
- Elementgroesse — Elementgröße
Hash-Tabelle Lastfaktor berechnen
Füllgrad einer Hash-Tabelle: alpha = Elemente / Tabellengroesse. Werte α ≈ 0,7 gelten als guter Kompromiss zwischen Speicher und Kollisionsrate.
- alpha — Lastfaktor
- Elemente — Elemente
- Tabellengroesse — Tabellengröße
Hash-Tabelle Kollisionswahrscheinlichkeit berechnen
Wahrscheinlichkeit mindestens einer Kollision nach n Einfügungen in m Slots (Geburtstagsparadoxon-Näherung): P = 1 − e^(−n²/(2·m)).
Binärbaum max. Knoten berechnen
Maximale Knotenanzahl eines vollständigen Binärbaums bei Tiefe h (Wurzel auf Ebene 0): MaxKnoten = 2^(h+1) − 1. Geometrische Reihe über alle Ebenen.
- MaxKnoten — Max. Knoten
- h — Tiefe
Binärbaum min. Tiefe berechnen
Minimal benötigte Tiefe eines Binärbaums mit n Knoten (vollständig gefüllte Ebenen): MinTiefe = ⌊log₂(n)⌋. Untere Schranke für Suchoperationen.
- MinTiefe — Min. Tiefe
- n — Knotenanzahl
B-Baum max. Schlüssel berechnen
Maximale Schlüsselanzahl in einem B-Baum der Ordnung m und Tiefe h: MaxKeys = m^(h+1) − 1. Grundlage für Indexdimensionierung in Datenbanken.
- MaxKeys — Max. Schlüssel
- h — Tiefe
Heap Eltern-Index berechnen
Eltern-Index in einem Array-basierten Heap (0-basiert): Eltern = ⌊(i − 1) / 2⌋. Grundlage von Heapify und Priority-Queues.
- Eltern — Eltern-Index
- i — Kind-Index
Heap Kind-links Index berechnen
Index des linken Kindes in einem Array-basierten Heap (0-basiert): Links = 2 · i + 1. Gegenstück zur Eltern-Formel.
- Links — Links-Kind-Index
- i — Eltern-Index
Heap Kind-rechts Index berechnen
Index des rechten Kindes in einem Array-basierten Heap (0-basiert): Rechts = 2 · i + 2. Gegenstück zu linkem Kind und Eltern-Index.
- Rechts — Rechts-Kind-Index
- i — Eltern-Index
CIDR zu Subnetzmaske berechnen
Anzahl der Host-Bits aus der CIDR-Präfixlänge: HostBits = 32 − CIDR. Eine /24-Maske hat 8 Host-Bits.
- HostBits — Host-Bits
- CIDR — CIDR-Präfix
Hosts aus CIDR berechnen
Anzahl nutzbarer Host-Adressen in einem IPv4-Subnetz: Hosts = 2^(32 − CIDR) − 2. Abzug für Netzwerk- und Broadcastadresse.
- Hosts — Nutzbare Hosts
- CIDR — CIDR-Präfix
Anzahl Subnetze berechnen
Anzahl möglicher Subnetze aus den entliehenen Subnetz-Bits: Subnetze = 2^SubnetzBits.
- Subnetze — Subnetze
- SubnetzBits — Subnetz-Bits
Netzwerkadresse berechnen
Netzwerkadresse als bitweises UND aus IP und Subnetzmaske: Netzwerk = IP AND Maske. Eingabe als 32-Bit-Integer-Darstellung.
Broadcastadresse berechnen
Broadcastadresse als ODER aus Netzwerkadresse und invertierter Maske: Broadcast = Netzwerk OR NOT(Maske). Eingabe als 32-Bit-Integer.
Erste nutzbare IP berechnen
Erste Host-Adresse in einem Subnetz, direkt über der Netzwerkadresse: ErsteIP = Netzwerk + 1.
- ErsteIP — Erste nutzbare IP
- Netzwerk — Netzwerkadresse
Letzte nutzbare IP berechnen
Letzte Host-Adresse in einem Subnetz, direkt unter der Broadcastadresse: LetzteIP = Broadcast − 1.
- LetzteIP — Letzte nutzbare IP
- Broadcast — Broadcastadresse
IPv6 Adressraum berechnen
Anzahl Adressen in einem IPv6-Subnetz: Adressen = 2^(128 − Praefixlänge). Ein /64 hat 2^64 Adressen.
- Adressen — Adressen
- Praefixlänge — Präfixlänge
Bandbreite Bit/s zu Byte/s berechnen
Konvertierung der Bandbreite zwischen Bit pro Sekunde und Byte pro Sekunde: ByteProS = BitProS / 8.
- ByteProS — Byte pro Sekunde
- BitProS — Bit pro Sekunde
Übertragungsdauer berechnen
Dauer einer Datenübertragung bei gegebener Bandbreite: Dauer = Datenmenge / Bandbreite.
- Dauer — Übertragungsdauer
- Datenmenge — Datenmenge
- Bandbreite — Bandbreite
Latenz (Round Trip Time) berechnen
Round-Trip-Time aus einfacher (One-Way-)Latenz: RTT = 2 · Latenz. Annahme symmetrischer Laufzeiten.
- RTT — Round Trip Time
- Latenz — Einfache Latenz
Durchsatz (Goodput) berechnen
Effektiver Nutzdatendurchsatz nach Abzug von Headern und Overhead: Goodput = Nutzdaten / Gesamtdaten · Bandbreite.
Paketverlustrate berechnen
Anteil verlorener Pakete: Verlustrate = Verloren / Gesendet. Wert zwischen 0 und 1, üblicherweise als Prozent angegeben.
- Verlustrate — Verlustrate
- Verloren — Verlorene Pakete
- Gesendet — Gesendete Pakete
Shannon-Kapazität berechnen
Maximale Kanalkapazität bei gegebener Bandbreite und Signal-Rausch-Verhältnis: C = B · log₂(1 + SNR). Theoretische Obergrenze.
- C — Kanalkapazität
- B — Bandbreite
- SNR — Signal-Rausch-Verhältnis
Nyquist-Kapazität berechnen
Maximale Datenrate eines rauschfreien Kanals mit M diskreten Signalstufen: C = 2 · B · log₂(M).
- C — Kapazität
- B — Bandbreite
- M — Signalstufen
Subnetzmaske zu CIDR berechnen
CIDR-Präfixlänge aus Anzahl der Host-Bits: CIDR = 32 − HostBits. Umkehrung zu „CIDR zu Subnetzmaske”.
- CIDR — CIDR-Präfix
- HostBits — Host-Bits
Bandbreiten-Verzögerungs-Produkt berechnen
Datenmenge „in der Leitung” als Produkt aus Bandbreite und Round-Trip-Time: BDP = Bandbreite · RTT. Sinnvolle Größe für TCP-Fenster.
- BDP — Bandwidth-Delay Product
- Bandbreite — Bandbreite
- RTT — Round Trip Time
Mögliche Schlüssel berechnen
Anzahl möglicher Schlüssel bei n Bit Schlüssellänge: Schluessel = 2^n. Jedes zusätzliche Bit verdoppelt den Schlüsselraum.
- Schluessel — Mögliche Schlüssel
- n — Schlüssellänge
Brute-Force-Zeit berechnen
Maximale Dauer eines vollständigen Schlüsseldurchlaufs: Zeit = 2^n / VpS. Verdoppelte Versuche pro Sekunde halbieren die Zeit, ein zusätzliches Bit verdoppelt sie.
- Zeit — Maximale Dauer
- n — Schlüssellänge
- VpS — Versuche pro Sekunde
Passwort-Entropie berechnen
Entropie eines Passworts in Bit: H = L · log₂(R). L ist die Länge, R die Größe des Zeichenraums. Mit jedem zusätzlichen Zeichen wächst die Entropie um log₂(R) Bit.
- H — Entropie
- L — Passwortlänge
- R — Zeichenraumgröße
Passwortentropie (Zeichenraum) berechnen
Entropie pro Zeichen für einen Zeichenraum der Größe R: HProZeichen = log₂(R). Reine Ziffern liefern ca. 3,32 Bit, Kleinbuchstaben ca. 4,7 Bit, der ASCII-Druckbereich ca. 6,55 Bit.
- HProZeichen — Entropie pro Zeichen
- R — Zeichenraumgröße
Kollisions-Wahrscheinlichkeit (Geburtstagsparadoxon) berechnen
Näherung für die Anzahl Hashwerte, bei der die Kollisionswahrscheinlichkeit 50 % erreicht: n ≈ √(π/2 · 2^Hashlänge). Daraus folgt die effektive Sicherheit eines b-Bit-Hashes von rund b/2 Bit gegen Kollisionen.
- n — Hashwerte für 50 %
- Hashlänge — Hashlänge
Hash-Ausgabelänge berechnen
Hex-Stellen einer Hash-Ausgabe: HexZeichen = Bit / 4. Beispiele: MD5 = 128 Bit / 32 Hex-Zeichen, SHA-1 = 160 Bit / 40 Hex-Zeichen, SHA-256 = 256 Bit / 64 Hex-Zeichen.
- HexZeichen — Hex-Zeichen
- Bit — Hashlänge
RSA Grundformel berechnen
RSA-Modul aus zwei großen Primzahlen: N = p · q. Daraus folgt φ(N) = (p − 1)(q − 1), Grundlage für die Wahl von öffentlichem Exponenten e und privatem d mit e · d ≡ 1 (mod φ(N)).
- N — RSA-Modul
- p — Primzahl p
- q — Primzahl q
RSA Verschlüsselung berechnen
RSA-Chiffretext durch modulare Potenzierung mit dem öffentlichen Exponenten: C = M^e mod N. Klartext M muss kleiner als der Modul N sein.
RSA Entschlüsselung berechnen
RSA-Klartext durch modulare Potenzierung mit dem privaten Exponenten: M = C^d mod N. Der private Exponent d ist multiplikatives Inverses von e modulo φ(N).
Diffie-Hellman Schlüsselaustausch berechnen
Öffentlicher Schlüsselanteil im Diffie-Hellman-Verfahren: A = g^a mod p. Generator g und Primzahl p sind öffentlich, der private Wert a bleibt geheim.
XOR Verschlüsselung berechnen
Bitweises XOR zwischen Daten und Schlüssel: Ergebnis = Daten XOR Schluessel. Die Operation ist selbst-invers — zweimaliges XOR mit demselben Schlüssel stellt den Klartext wieder her.
- Ergebnis — Ergebnis
- Daten — Datenwert
- Schluessel — Schlüsselwert
Caesar-Chiffre berechnen
Verschobene Position im 26-Buchstaben-Alphabet: Chiffre = (Klartext + Verschiebung) mod 26. Mit A = 0, B = 1, …, Z = 25. Eine Verschiebung von 13 entspricht ROT13.
- Chiffre — Chiffre-Position
- Klartext — Klartext-Position
- Verschiebung — Verschiebung
Vigenère Schlüssellänge berechnen
Anzahl möglicher Vigenère-Schlüssel der Länge L: Möglichkeiten = 26^Länge. Schon eine Schlüssellänge von 8 liefert mehr als 2·10¹¹ Varianten.
- Möglichkeiten — Möglichkeiten
- Länge — Schlüssellänge
CRC Prüfbits berechnen
Gesamtlänge eines Datenrahmens mit CRC-Prüfsumme: Gesamtbits = Datenbits + CRCBits. Übliche Polynome: CRC-8, CRC-16, CRC-32 mit 8, 16 bzw. 32 Prüfbits.
- Gesamtbits — Gesamtlänge
- Datenbits — Datenbits
- CRCBits — CRC-Bits
1NF Prüfung berechnen
Prüft die erste Normalform: alle Attributwerte müssen atomar sein und es muss ein eindeutiger Primärschlüssel existieren. Ausgabe als Indikator 0/1.
2NF Prüfung berechnen
Prüft die zweite Normalform: 1NF muss erfüllt sein und kein Nicht-Schlüssel-Attribut darf nur von einem Teil eines zusammengesetzten Primärschlüssels abhängen.
3NF Prüfung berechnen
Prüft die dritte Normalform: 2NF muss erfüllt sein und es darf keine transitive Abhängigkeit von Nicht-Schlüssel-Attributen geben.
Kardinalität (Kreuzprodukt) berechnen
Zeilenanzahl eines kartesischen Produkts zweier Relationen: Ergebnis = KardA · KardB. Damit lassen sich auch Worst-Case-Zwischenergebnisse von Joins abschätzen.
- Ergebnis — Ergebnis-Kardinalität
- KardA — Kardinalität A
- KardB — Kardinalität B
Index-Größe B-Baum berechnen
Tiefe eines B-Baum-Index bei n indexierten Datensätzen und Ordnung m: Tiefe = ⌈log_m(n)⌉. Bestimmt direkt die Anzahl Random-I/Os pro Indexsuche.
Speicherbedarf Tabelle berechnen
Grobschätzung des Speicherbedarfs einer Tabelle: Speicher = Zeilen · ByteProZeile. Reine Nutzdaten ohne Index-, Overhead- oder Füllgrad-Anteile.
- Speicher — Speicherbedarf
- Zeilen — Zeilenanzahl
- ByteProZeile — Byte pro Zeile
Abfragekosten Sequential Scan berechnen
Geschätzte Kosten eines vollständigen Tabellen-Scans: Kosten = Seiten · SeqSeitenKosten. SeqSeitenKosten typischerweise 1,0 in Kostenmodellen wie PostgreSQL.
- Kosten — Gesamtkosten
- Seiten — Seitenanzahl
- SeqSeitenKosten — Kosten pro Seite
Abfragekosten Index Scan berechnen
Geschätzte Kosten eines Index-Scans entlang eines B-Baum-Pfads: Kosten = Tiefe · RandSeitenKosten. RandSeitenKosten typischerweise 4,0 für Random-I/O.
- Kosten — Gesamtkosten
- Tiefe — Indextiefe
- RandSeitenKosten — Random-I/O-Kosten
Transaktionsrate (TPS) berechnen
Durchsatz einer Datenbank in Transaktionen pro Sekunde: TPS = Transaktionen / Zeit. Klassisches Benchmark-Maß (z. B. TPC-C, pgbench).
- TPS — Transaktionen/s
- Transaktionen — Transaktionen
- Zeit — Zeitraum
DB-Größe Schätzung berechnen
Grobschätzung der gesamten Datenbankgröße aus Anzahl Tabellen, mittlerer Zeilenanzahl pro Tabelle und mittlerer Zeilengröße in Byte.
- Größe — DB-Größe
- Tabellen — Tabellenanzahl
CPU-Auslastung berechnen
Anteil der Zeit, in der die CPU aktiv Prozesse bedient: Auslastung = BusyTime / GesamtTime · 100.
- Auslastung — CPU-Auslastung
- BusyTime — Busy-Time
- GesamtTime — Gesamtzeit
Speicher-Auslastung berechnen
Anteil des belegten Hauptspeichers: Auslastung = Belegt / Gesamt · 100.
- Auslastung — Speicherauslastung
- Belegt — Belegter Speicher
- Gesamt — Gesamtspeicher
FCFS-Wartezeit berechnen
Wartezeit eines Prozesses bei First-Come-First-Served: Summe der Bedienzeiten aller vorher eingeplanten Prozesse.
SJF-Wartezeit berechnen
Wartezeit bei Shortest Job First — nach Sortierung nach Bedienzeit identisch zu FCFS: Summe der Bedienzeiten aller kürzeren Prozesse.
Round-Robin-Wartezeit berechnen
Maximale Wartezeit bei Round-Robin-Scheduling bis zur nächsten Ausführung: MaxWartezeit = (Prozesse − 1) · Zeitscheibe.
- MaxWartezeit — Max. Wartezeit
- Prozesse — Prozessanzahl
- Zeitscheibe — Zeitscheibe
Durchschnittliche Wartezeit berechnen
Mittlere Wartezeit eines Schedulings über alle Prozesse: DurchschnWartezeit = SummeWartezeiten / Prozesse.
- DurchschnWartezeit — Ø Wartezeit
- SummeWartezeiten — Summe Wartezeiten
- Prozesse — Prozessanzahl
Durchschnittliche Verweilzeit berechnen
Mittlere Verweilzeit (Wartezeit + Bedienzeit) im System: DurchschnVerweilzeit = SummeVerweilzeiten / Prozesse.
- DurchschnVerweilzeit — Ø Verweilzeit
- SummeVerweilzeiten — Summe Verweilzeiten
- Prozesse — Prozessanzahl
Seitenrahmen-Speicher berechnen
Physischer Speicher, der für eine bestimmte Anzahl Seitenrahmen reserviert wird (Grundlage für FIFO- und LRU-Seitenersetzung): Speicher = Rahmen · Seitengröße.
- Speicher — Phys. Speicher
- Rahmen — Seitenrahmen
- Seitengröße — Seitengröße
Seitenfehlerrate berechnen
Anteil der Seitenzugriffe, die einen Seitenfehler auslösen: Rate = Seitenfehler / Zugriffe.
- Rate — Seitenfehlerrate
- Seitenfehler — Seitenfehler
- Zugriffe — Zugriffe
Thrashing-Schwelle berechnen
Verhältnis von benötigtem Working Set zu verfügbaren Seitenrahmen; Werte > 1 deuten auf Thrashing hin: Schwelle = WSS / VerfRahmen.
- Schwelle — Thrashing-Schwelle
- WSS — Working-Set-Größe
- VerfRahmen — Verfügbare Rahmen
Semaphor-Ressourcenverwaltung berechnen
Aktuell verfügbare Ressourcen eines zählenden Semaphors: Verfügbar = Kapazität − Belegt.
- Verfügbar — Verfügbare Ressourcen
- Belegt — Belegte Ressourcen
- Kapazitaet — Kapazität
Deadlock — Minimale Ressourcen berechnen
Mindestanzahl an Ressourcen, ab der ein Deadlock prinzipiell vermieden wird: MinRes = Prozesse · (MaxBedarf − 1) + 1.
- MinRes — Min. Ressourcen
- Prozesse — Prozessanzahl
- MaxBedarf — Max. Bedarf pro Prozess
Regulärer Ausdruck Zeichenanzahl berechnen
Anzahl der über einem Alphabet möglichen Zeichenketten fester Länge: Möglichkeiten = Alphabet^Länge.
- Möglichkeiten — Möglichkeiten
- Länge — Stringlänge
DFA Zustandsübergänge berechnen
Maximale Anzahl Zustandsübergänge eines deterministischen endlichen Automaten: Übergaenge = Zustaende · Alphabet (|δ| = |Q|·|Σ|).
- Übergaenge — Übergänge
- Zustaende — Zustandsanzahl
- Alphabet — Alphabetgröße
Grammatik Ableitungsschritte berechnen
Minimale Ableitungslänge in Chomsky-Normalform für ein Wort der Länge n: MinSchritte = 2·n − 1.
- MinSchritte — Min. Ableitungsschritte
- Wortlänge — Wortlänge
FIRST/FOLLOW-Menge Größe berechnen
Maximale Größe einer FIRST- bzw. FOLLOW-Menge einer kontextfreien Grammatik: MaxGröße = Terminale + 1 (inklusive ε bzw. $/EOF).
- MaxGröße — Max. Mengengröße
- Terminale — Terminalanzahl
LL(1) Parsertabelle Größe berechnen
Anzahl der Felder in einer LL(1)-Parsertabelle: Einträge = Nichtterminale · Terminale (|M| = |N|·|T+$|).
- Einträge — Tabelleneinträge
- Nichtterminale — Nichtterminale
- Terminale — Terminale
Token-Länge Lexer berechnen
Gesamtlänge des Quellcodes aus Tokenanzahl und durchschnittlicher Tokenlänge: Gesamtlänge = Tokens · DurchschnLänge.
- Gesamtlänge — Gesamtlänge
- Tokens — Tokenanzahl
- DurchschnLänge — Ø Tokenlänge
Syntaxbaumtiefe berechnen
Minimale Tiefe eines binären Syntaxbaums mit gegebener Blattanzahl: MinTiefe = ⌈log₂(Blaetter + 1)⌉.
- MinTiefe — Min. Tiefe
- Blaetter — Blattknoten
NFA zu DFA Zustandsexplosion berechnen
Maximale Zustandsanzahl des durch Potenzmengenkonstruktion erzeugten DFA: MaxDFAZustaende = 2^NFAZustaende.
- MaxDFAZustaende — Max. DFA-Zustände
- NFAZustaende — NFA-Zustände
Shannon-Entropie berechnen
Mittlerer Informationsgehalt einer diskreten Quelle: H = −Σ pᵢ · log₂(pᵢ). Formel hier für drei Symbole mit Wahrscheinlichkeiten p1, p2, p3.
Informationsgehalt berechnen
Informationsgehalt eines Einzelereignisses: I = −log₂(p) = log₂(1/p). Seltene Ereignisse tragen mehr Information.
- I — Informationsgehalt
- p — Wahrscheinlichkeit
Redundanz berechnen
Relative Redundanz einer Quelle: R = 1 − H / Hmax. Hmax = log₂(Symbolanzahl) ist die maximale Entropie bei Gleichverteilung.
- R — Redundanz
- H — Entropie
- Hmax — Max. Entropie
Kodierungseffizienz berechnen
Verhältnis aus Entropie und mittlerer Codewortlänge: Effizienz = H / L. Werte nahe 1 stehen für nahezu optimale Kodierung.
- Effizienz — Kodierungseffizienz
- H — Entropie
- L — Mittlere Codewortlänge
Huffman min. Codewortlänge berechnen
Untere Schranke der Codewortlänge bei festen Binärcodes: MinLaenge = ⌈log₂(Symbolanzahl)⌉. Huffman erreicht diesen Wert bei Gleichverteilung.
- MinLaenge — Min. Codewortlänge
- Symbolanzahl — Symbolanzahl
Mittlere Codewortlänge berechnen
Gewichtete mittlere Codewortlänge eines Präfixcodes: L = Σ pᵢ · lᵢ. Formel hier für drei Symbole mit Wahrscheinlichkeiten und Codewortlängen.
Kanalkapazität (Shannon) berechnen
Shannon-Hartley-Theorem: C = B · log₂(1 + S/N). Obere Schranke für fehlerfreie Datenrate auf einem analogen Kanal mit Gauß-Rauschen.
- C — Kanalkapazität
- B — Bandbreite
- SN — Signal-Rausch-Verhältnis
Bitfehlerrate (BER) berechnen
Bitfehlerrate als Quotient fehlerhafter Bits zu übertragenen Bits: BER = FehlerBits / GesamtBits. Typische Werte 10⁻³ bis 10⁻¹².
- BER — Bitfehlerrate
- FehlerBits — Fehlerhafte Bits
- GesamtBits — Übertragene Bits
Hamming-Distanz berechnen
Aus der minimalen Hamming-Distanz d eines Blockcodes folgen Erkennbar = d − 1 Fehler und Korrigierbar = ⌊(d − 1) / 2⌋ Fehler.
- Erkennbar — Erkennbare Fehler
- d — Hamming-Distanz
Hamming-Code Prüfbits berechnen
Anzahl Prüfbits r für m Datenbits im (m+r,m)-Hamming-Code: kleinstes r mit 2^r ≥ m + r + 1.
Parität (gerade) berechnen
Paritätsbit für gerade Parität: Paritaetsbit = Einsen mod 2. Das Bit wird so gesetzt, dass die Gesamtzahl der Einsen gerade ist.
Parität (ungerade) berechnen
Paritätsbit für ungerade Parität: Paritaetsbit = (Einsen + 1) mod 2. Die Gesamtzahl der Einsen inklusive Prüfbit ist anschließend ungerade.
CRC-Prüfbits berechnen
Gesamtlänge einer Nachricht mit CRC-Prüfsumme: Gesamtlaenge = Datenbits + Grad. Der Grad des Generatorpolynoms entspricht der Anzahl angehängter CRC-Bits.
- Gesamtlaenge — Gesamtlänge
- Datenbits — Datenbits
- Grad — Generatorpolynom-Grad
Pixel zu Weltkoordinate berechnen
Konvertiert eine Pixelkoordinate in eine Weltkoordinate über Skalierung und Offset: Welt = Pixel · Skalierung + Offset.
- Welt — Weltkoordinate
- Pixel — Pixelkoordinate
Skalierung 2D berechnen
Skaliert die X-Komponente eines 2D-Punkts mit dem Faktor Sx: NeuX = X · Sx. Für die Y-Komponente gilt analog NeuY = Y · Sy.
- NeuX — Neue X-Koordinate
- X — X-Koordinate
- Sx — Skalierungsfaktor X
Rotation 2D (X-Komponente) berechnen
Rotiert die X-Komponente eines 2D-Punkts um den Ursprung um den Winkel θ (in Grad): NeuX = X · cos(θ) − Y · sin(θ). Für Y gilt NeuY = X · sin(θ) + Y · cos(θ).
Translation 2D berechnen
Verschiebt die X-Komponente eines 2D-Punkts um Tx: NeuX = X + Tx. Für Y gilt analog NeuY = Y + Ty.
- NeuX — Neue X-Koordinate
- X — X-Koordinate
- Tx — Verschiebung X
Perspektivische Projektion berechnen
Projiziert einen 3D-Punkt entlang der Sichtachse auf die Bildebene einer Lochkamera: Xp = f · X / Z. Weiter entfernte Punkte erscheinen kleiner.
- Xp — Projizierte X-Koordinate
- X — 3D X-Koordinate
- Z — Tiefe (Z)
- f — Brennweite
Seitenverhältnis (Aspect Ratio) berechnen
Verhältnis von Bildbreite zu Bildhöhe: AR = Breite / Höhe. Beispiele: 16:9 ≈ 1,778; 4:3 ≈ 1,333; 21:9 ≈ 2,333.
- AR — Aspect Ratio
- Breite — Breite
- Höhe — Höhe
DPI (Punkte pro Zoll) berechnen
Druck- und Anzeigeauflösung als Pixel pro Zoll: DPI = Pixel / Zoll. Druck-Standard liegt typischerweise bei 300 dpi, klassische Bildschirme bei 72–96 dpi.
- DPI — DPI
- Pixel — Pixelanzahl
- Zoll — Physische Größe
Farbtiefe berechnen
Anzahl darstellbarer Farben bei einer Farbtiefe in Bit pro Pixel: Farben = 2^Farbtiefe. 8 Bit ergeben 256, 24 Bit (True Color) gut 16,8 Mio. Farben.
- Farben — Farbanzahl
- Farbtiefe — Farbtiefe
Framerate (FPS) berechnen
Bilder pro Sekunde aus Frameanzahl und Messzeitraum: FPS = Frames / Zeit. Übliche Zielwerte: 24 fps Kino, 60 fps Gaming, 90+ fps für VR.
- FPS — Framerate
- Frames — Frames
- Zeit — Zeitraum
Renderzeit pro Frame berechnen
Verfügbares Zeitbudget pro Frame in Millisekunden: Renderzeit = 1000 / FPS. Bei 60 fps bleiben pro Frame rund 16,7 ms, bei 144 fps etwa 6,9 ms.
- Renderzeit — Renderzeit
- FPS — Framerate
RGB zu Graustufe berechnen
Wahrnehmungsgewichtete Umrechnung von RGB in einen Grauwert (Luminanz nach BT.601): Grau = 0,299 · R + 0,587 · G + 0,114 · B. Grün trägt am stärksten, Blau am wenigsten bei.
RGB zu HSL (Lightness) berechnen
Helligkeit (Lightness) im HSL-Farbraum als Mittelwert aus Maximum und Minimum der normierten RGB-Werte: L = (Max + Min) / 2.
RGB zu HSL (Saturation) berechnen
Sättigung (Saturation) im HSL-Farbraum: S = (Max − Min) / (1 − |2L − 1|). Bei reinem Schwarz oder Weiß (L = 0 bzw. L = 1) ist die Sättigung definitionsgemäß 0.
Gammakorrektur berechnen
Nichtlineare Helligkeitskorrektur: Vout = Vin^(1 / Gamma). Üblicher sRGB-Wert ist Gamma ≈ 2,2. Werte > 1 hellen auf, Werte < 1 dunkeln ab.
- Vout — Ausgabewert
- Vin — Eingabewert
- Gamma — Gamma
Weltkoordinate zu Pixel berechnen
Konvertiert eine Weltkoordinate zurück in eine Pixelkoordinate: Pixel = (Welt − Offset) / Skalierung.
- Pixel — Pixelkoordinate
- Welt — Weltkoordinate
MIPS (Millionen Instruktionen pro Sekunde) berechnen
Klassische Performance-Kennzahl: MIPS = Instruktionen / (Zeit · 10⁶). Misst die Instruktionsrate einer CPU in Millionen Instruktionen pro Sekunde.
- MIPS — MIPS
- Instruktionen — Instruktionen
- Zeit — Ausführungszeit
FLOPS (Gleitkomma-Operationen pro Sekunde) berechnen
Gleitkomma-Performance: FLOPS = Operationen / Zeit. Standardkennzahl für numerische Workloads und HPC.
- FLOPS — FLOPS
- Operationen — Gleitkomma-Operationen
- Zeit — Ausführungszeit
CPI (Zyklen pro Instruktion) berechnen
Durchschnittliche Anzahl Taktzyklen pro Instruktion: CPI = Taktzyklen / Instruktionen. Niedriger CPI = höhere Effizienz pro Takt.
- CPI — CPI
- Taktzyklen — Taktzyklen
- Instruktionen — Instruktionen
CPU-Taktzeit berechnen
Dauer eines Taktzyklus: Taktzeit = 1 / Taktfrequenz. Kehrwert der Taktrate.
- Taktzeit — Taktperiode
- Taktfrequenz — Taktfrequenz
Ausführungszeit berechnen
Gesamtausführungszeit eines Programms: Zeit = Instruktionen · CPI / Taktfrequenz. Verknüpft Instruktionszahl, CPI und Taktrate.
- Zeit — Ausführungszeit
- Instruktionen — Instruktionen
- CPI — CPI
- Taktfrequenz — Taktfrequenz
Amdahls Gesetz (Speedup) berechnen
Maximaler Speedup durch Parallelisierung: S = 1 / ((1 − p) + p / n). p = parallelisierbarer Anteil, n = Prozessoren. Der serielle Rest begrenzt den Speedup.
- S — Speedup
- n — Prozessoren
Gustafsons Gesetz (skalierter Speedup) berechnen
Skalierter Speedup bei wachsender Problemgröße: S = (1 − p) + p · n. Optimistischer als Amdahl, da mit n auch die Arbeit pro Prozessor mitwächst.
- S — Skalierter Speedup
- n — Prozessoren
- p — Paralleler Anteil
Cache-Trefferrate berechnen
Anteil der Cache-Treffer an den Zugriffen: HitRate = Treffer / Zugriffe. Zentrale Kennzahl für Cache-Effizienz.
- HitRate — Trefferrate
- Treffer — Cache-Treffer
- Zugriffe — Zugriffe
Effektive Zugriffszeit berechnen
Gewichtete mittlere Zugriffszeit über Cache und Hauptspeicher: EAT = h · Tc + (1 − h) · Tm. h = Trefferrate.
- EAT — Effektive Zugriffszeit
- h — Trefferrate
Speicherbandbreite berechnen
Theoretische Datenrate des Speichers: Bandbreite = Busbreite · Takt · Transfers. Bei DDR ist Transfers = 2 (Double Data Rate).
- Bandbreite — Bandbreite
- Takt — Taktfrequenz
Latenz-Bandbreite-Produkt berechnen
Datenmenge, die zu jedem Zeitpunkt in der Pipeline unterwegs ist: LBP = Latenz · Bandbreite. Wichtig für TCP-Fenster und Pipelining.
- LBP — Latenz-Bandbreite-Produkt
- Latenz — Latenz
- Bandbreite — Bandbreite
Parallelisierungseffizienz berechnen
Effizienz einer Parallelisierung: Effizienz = Speedup / Prozessoren. Wert nahe 1 = nahezu lineare Skalierung.
- Effizienz — Effizienz
- Speedup — Speedup
- Prozessoren — Prozessoren