DE102020110787B3 - Schaltung und verfahren zum kodieren oder dekodieren eines datenworts - Google Patents

Abstract

Gemäß einer Ausführungsform wird eine Schaltung zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code beschrieben aufweisend eine Syndromberechnungsschaltung zum Berechnen eines Syndroms des Datenworts, wobei die Syndromberechnungsschaltung eine Kontrollmatrixberechnungsschaltung, die eingerichtet ist, für eine ihr zugeführte Binärdarstellung der Spaltennummer einer Spalte einer Code-Kontrollmatrix des Codes einen Teil-Spaltenvektor auszugeben, der zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet, und eine Akkumulierschaltung aufweist, die eingerichtet ist, die Spalten der Code-Kontrollmatrix für alle Bits des Datenworts, die gleich 1 sind, zu akkumulieren, wobei sie eingerichtet ist, zumindest einen Teil der Spalten durch Zuführen der Binärdarstellung der Spaltennummer der Spalte zu der Kontrollmatrixberechnungsschaltung und Bilden des Spaltenvektors aus der Binärdarstellung der Spaltennummer und dem von der Kontrollmatrixberechnungsschaltung ausgegebenen Teil-Spaltenvektor zu bilden und das Ergebnis des Akkumulierens als Syndrom auszugeben.

Description

• Ausführungsbeispiele betreffen allgemein Schaltungen und Verfahren zum Kodieren oder Dekodieren eines Datenworts.
• In Computer- und Kommunikationssystemen werden Daten mit redundanter Information ausgestattet, sodass bei der Übertragung oder Speicherung der Daten auftretende Fehler erkannt und korrigiert werden können. Hierzu werden Methoden aus der algebraischen Codierungstheorie verwendet. In der Praxis werden vor allem Blockcodes verwendet. Bei ihnen werden die Daten in Segmente gleicher Länge aufgeteilt und die Codierung wird durch eine feste lineare Transformation, angewandt auf die segmentierten Nutzdaten, realisiert.
• Einbitfehler können mit Hamming-Codes effizient korrigiert werden. Bei Mehrbitfehlern ist es oft erforderlich Codes zu verwenden, deren Implementierung in Hardware teuer ist. Ein allgemeiner linearer Code kann (z.B. auf einer Chipkarte) implementiert werden, indem man die Kontrollmatrix des Codes hinterlegt. Für größere Codewortlängen (und diese sind attraktiv, weil für sie der Anteil der redundanten Information relativ zu den zu schützenden Nutzdaten klein ist) hat die Kontrollmatrix jedoch eine beträchtliche Größe. Es ist daher wünschenswert, eine effiziente Kodierung und/oder Dekodierung bereitzustellen, deren notwendige Operationen ohne Rückgriff auf eine explizit bereitgestellte Kontrollmatrix ausführbar sind.
• Die Druckschrift US 2002 / 0 059 552 A1 beschreibt eine Kontrollmatrix, bei der jede Spalte aus einer Binärdarstellung der Spaltennummer, ergänzt durch das Komplement einer Komponente der Binärdarstellung der Spaltennummer, besteht.
• Gemäß einer Ausführungsform wird eine Schaltung zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code bereitgestellt aufweisend eine Syndromberechnungsschaltung zum Berechnen eines Syndroms des Datenworts, wobei die Syndromberechnungsschaltung eine Kontrollmatrixberechnungsschaltung aufweist, die eingerichtet ist, für eine ihr zugeführte Binärdarstellung der Spaltennummer einer Spalte einer Code-Kontrollmatrix des Codes einen Teil-Spaltenvektor auszugeben, der zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet, wobei die Kontrollmatrixberechnungsschaltung eingerichtet ist, den Teil-Spaltenvektor durch eine quadratische Kombination der Bits der Binärdarstellung der Spaltennummer zu erzeugen, und eine Akkumulierschaltung aufweist, die eingerichtet ist, die Spalten der Code-Kontrollmatrix für alle Bits des Datenworts, die gleich 1 sind, zu akkumulieren, wobei sie eingerichtet ist, zumindest einen Teil der Spalten durch Zuführen der Binärdarstellung der Spaltennummer der Spalte zu der Kontrollmatrixberechnungsschaltung und Bilden des Spaltenvektors aus der Binärdarstellung der Spaltennummer und dem von der Kontrollmatrixberechnungsschaltung ausgegebenen Teil-Spaltenvektor zu bilden und das Ergebnis des Akkumulierens als Syndrom auszugeben.
• Die Figuren geben nicht die tatsächlichen Größenverhältnisse wieder, sondern sollen dazu dienen, die Prinzipien der verschiedenen Ausführungsbeispiele zu illustrieren. Im Folgenden werden verschiedene Ausführungsbeispiele mit Bezug auf die folgenden Figuren beschrieben.
• 1 zeigt eine Datenverarbeitungsvorrichtung gemäß einem Ausführungsbeispiel.
• 2 zeigt eine Schaltung zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code aufweisend eine Syndromberechnungsschaltung zum Berechnen eines Syndroms des Datenworts.
• 3 zeigt ein Ablaufdiagramm, das ein Verfahren zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code veranschaulicht.
• Die folgende detaillierte Beschreibung bezieht sich auf die beiliegenden Figuren, die Details und Ausführungsbeispiele zeigen. Diese Ausführungsbeispiele sind so detailliert beschrieben, dass der Fachmann die Erfindung ausführen kann. Andere Ausführungsformen sind auch möglich und die Ausführungsbeispiele können in struktureller, logischer und elektrischer Hinsicht geändert werden, ohne vom Gegenstand der Erfindung abzuweichen. Die verschiedenen Ausführungsbeispiele schließen sich nicht notwendig gegenseitig aus, sondern es können verschiedene Ausführungsformen miteinander kombiniert werden, so dass neue Ausführungsformen entstehen. Im Rahmen dieser Beschreibung werden die Begriffe „verbunden“, „angeschlossen“ sowie „gekoppelt“ verwendet zum Beschreiben sowohl einer direkten als auch einer indirekten Verbindung, eines direkten oder indirekten Anschlusses sowie einer direkten oder indirekten Kopplung.
• Um die Korrektur von Fehlern in Daten, die beispielsweise bei der Datenübertragung oder beim Speichern oder Auslesen entstanden sind, zu ermöglichen, werden Daten typischerweise mittels eines Codes codiert. Ein Anwendungsbeispiel für eine solche Codierung (und zugehörige Dekodierung) ist in 1 gezeigt.
• 1 zeigt eine Datenverarbeitungsvorrichtung 100 gemäß einem Ausführungsbeispiel.
• Die Datenverarbeitungsvorrichtung 100 weist eine Datenverarbeitungseinheit 101, z.B. einen Prozessor (CPU), sowie einen Speicher 102 (z.B. einen nichtflüchtigen Speicher wie z.B. ein RRAM (Resistive Random Access Memory)) auf. Die Datenverarbeitungseinheit 101 kann Daten in dem Speicher 102 speichern und aus dem Speicher 102 auslesen. Dies erfolgt über eine Speicherzugriffsschaltung 103. Um Fehler, die beim Speichervorgang, während der Zeit, während der die Daten gespeichert sind, oder beim Auslesen zu detektieren und idealerweise zu korrigieren speichert die Speicherzugriffsschaltung 103 die Daten in codierter Form: Die Speicherzugriffseinheit 103 weist einen Kodierer 104 auf, der im Speicher 102 zu speichernde Daten codiert, bevor die Speicherzugriffseinheit 103 sie in dem Speicher 102 speichert. Für das Auslesen von Daten aus dem Speicher 102 weist die Speicherzugriffseinheit 103 einen Dekodierer 105 auf.
• Es sollte beachtet werden, dass Ausführungsformen auch in anderen Anwendungsfällen angewendet werden können als das Speichern von Daten in einem Speicher und das Auslesen der Daten. Beispielsweise können Daten vor einer Übermittlung über einen Kommunikationskanal durch einen Sender codiert werden und nach der Übertragung von einem Empfänger decodiert werden. In diesem Fall weist der Sender den Kodierer 104 auf und der Empfänger weist den Dekodierer 105 auf. An die Stelle von zu speichernden Daten treten zu übertragende Daten und an die Stelle von ausgelesenen Daten treten empfangene Daten. Die Datenverarbeitungsvorrichtung 100 ist dann allgemeiner eine Datenverarbeitungsanordnung, da Sender und Empfänger nicht notwendigerweise in einem Gerät angeordnet sind, sondern sich entfernt voneinander befinden können und beispielsweise über ein Netzwerk (z.B. über das Internet und/oder eine Mobilfunk-Kommunikationsnetzwerk) miteinander verbunden sind.
• Sei n eine positive ganze Zahl und $\text{V}={\mathbb{F}}_2^{\text{n}}$

  

  der kanonische n-dimensionale Vektorraum über dem binären Zahlenkörper ${\mathbb{F}}_2=\left\{\mathrm{0,1}\right\}.$

  

  Ein binärer linearer Code C der Länge n und der Dimension k ist ein k-dimensionaler Unterraum von V. Die Elemente in C heißen Codewörter oder Codevektoren. Die Zahl r = n - k heißt Redundanz des Codes. Ein beliebiges Nachrichtenwort w = (w₁, w₂, ..., w_k) der Länge k (z. B. ein Datenwort von im Speicher 102 zu speichernden Daten) wird mittels einer linearen Transformation $\text{L}:{\mathbb{F}}_2^{\text{k}}\to {\mathbb{F}}_2^{\text{n}}$

  

  in ein Codewort z = (z₁, z₂, ..., z_n) der Länge n verwandelt. Der Vorgang heißt Codierung und wird von dem Kodierer 104 durchgeführt. Es gilt $\text{L}\left({\mathbb{F}}_2^{\text{k}}\right)=\text{C}.$

  

  Die Speicherzugriffseinheit 103 speichert dieses Codewort an Stelle des ursprünglichen Nachrichtenworts im Speicher 102.
• Die Umkehrung, also die Rückgewinnung des Nachrichtenwortes w aus dem Codewort z oder einem fehlerhaften Codewort z' heißt Decodierung und wird von dem Dekodierer 105 durchgeführt.
• Eine wichtige Unterklasse linearer Codes sind die sogenannten systematischen linearen Codes. Während bei einem allgemeinen linearen Code jede Koordinate z_j des Codeworts z eine Linearkombination der Nachrichtenbits ist, sind bei einem systematischen Code k Koordinaten von z identisch mit den k Nachrichtenbits w₁, ..., w_k. Nur die verbleibenden r Koordinaten von z, sie heißten Kontrollbits, sind nichttriviale Linearkombinationen der Nachrichtenbits w₁, ..., w_k. Bei einem systematischen Code besteht der Vorgang der Codierung daher im Wesentlichen aus der Berechnung der r Kontrollbits. Und der Vorgang der Decodierung eines fehlerlosen Codeworts wird durch das Entfernen der r Kontrollbits aus dem Codewort bewerkstelligt. Was übrig bleibt, ist das Nachrichtenwort.
• Ein Code C hat die Minimumdistanz d, wenn sich zwei beliebige verschiedene Codewörter aus C in mindestens d Koordinaten voneinander unterscheiden. Ein linearer (n, k, d)-Code ist ein Code der Länge n, der Dimension k, und der Minimumdistanz d.
• Ein Code mit ungerader Minimumdistanz d = 2t + 1 ≥ 3 kann alle s-Bitfehler korrigieren mit 1 ≤ s ≤ t. Ein Code mit geradem d, also einer Minimumdistanz der Form d = 2t + 2, kann ebenfalls alle s-Bitfehler mit 1 ≤ s ≤ t korrigieren. Zum Beipiel können mit einem Code der Minimumdistanz d = 7 oder d = 8 alle 1-, 2- und 3-Bitfehler korrigiert werden.
• Jeder binäre lineare (n, k, d)-Code kann durch eine binäre r × n-Matrix dargestellt werden, einer sogenannten Kontrollmatrix (die aber nicht eindeutig bestimmt ist). Alle Eigenschaften eines Codes spiegeln sich in der Kontrollmatrix wider:
• • Die Länge n des Codes stimmt überein mit der Länge der Kontrollmatrix. Mit anderen Worten: Die Kontrollmatrix eines (n, k, d)-Codes hat genau n Spalten.
• • Die Breite der Kontrollmatrix ist gleich n - k und stimmt überein mit der Redundanz r = n - k des Codes. Die Kontrollmatrix hat den Rang r. Mit anderen Worten: Die Kontrollmatrix eines (n, k, d)-Codes hat n - k Zeilen und diese sind linear unabhängig über ${\mathbb{F}}_2.$
  
• • Der Code C ist der Nullraum der Kontrollmatrix H. D.h., $$\text{C}=\left\{\text{z}\in {\mathbb{F}}_2^{\text{n}}:{\text{Hz}}^{\text{T}}=0\right\}.$$
  
• • Für einen (n, k, d)-Code mit d = 2t + 1 oder d = 2t + 2 gilt: alle möglichen Summen aus jeweils s Spalten der Kontrollmatrix H sind paarweise verschieden für 1 ≤ s ≤ t. Wobei die Summe zweier Spaltenvektoren definiert ist durch gliedweise Addition ihrer Koordinaten im Körper ${\mathbb{F}}_2$
  
  (bitweises XOR).
• • Alle Codierungs-relevanten Aufgaben wie Codierung, Decodierung, insbesondere Syndromberechnung und Fehlerkorrektur, können bei einem systematischen Code realisiert werden durch Operationen mit den Spaltenvektoren der Kontrollmatrix, wobei zu jedem Zeitpunkt immer nur eine Spalte der Kontrollmatrix benötigt wird.
• Die Datenverarbeitungsvorrichtung 100 ist beispielsweise Teil einer Steuereinrichtung (z.B. in einem Fahrzeug) oder Teil einer Chipkarte (mit beliebigem Formfaktor).
• Je nach Anwendungsfall ist es erforderlich, dass die Speicherzugriffseinheit 103 die Kodierung und/oder die Dekodierung sehr schnell durchführt, z.B. in 1 oder 2 Taktzyklen der Datenverarbeitungseinheit 101, um ein Ausbremsen der Datenverarbeitungseinheit 101 zu vermeiden. Dies gilt insbesondere für die Anwendung im Automobilbereich. Nichtsdestotrotz ist es typischerweise wünschenswert, dass die Speicherzugriffseinheit 103 eine geringe Komplexität aufweist und kostengünstig hergestellt werden kann.
• Gemäß verschiedenen Ausführungsformen verwendet die Speicherzugriffseinheit 103 einen binären systematischen linearen Code für die Fehlerkontrolle (also zur Codierung und Dekodierung von zu speichernden bzw. gespeicherten Daten), der eine Kontrollmatrix der Form $$\left(\begin{array}{cccc}1& 2& \dots & \mathbf{n}\\ \text{F}\left(1\right)& \text{F}\left(2\right)& \dots & \text{F}\left(\mathbf{n}\right)\end{array}\right)$$

  

  mit einer einfach beschreibbaren Funktion F hat. Alle notwendigen Operationen werden mithilfe dieser Funktion F ausgeführt. Die Kontrollmatrix selbst wird dann nicht mehr benötigt.
• Die fettgedruckten Zahlen 1, 2, ... repräsentieren binäre Spaltenvektoren der Dimension m: $$1=\left(\begin{array}{c}1\\ 0\\ 0\\ ⋮\\ 0\end{array}\right),2=\left(\begin{array}{c}0\\ 1\\ 0\\ ⋮\\ 0\end{array}\right),\text{ 3}=\left(\begin{array}{c}1\\ 1\\ 0\\ ⋮\\ 0\end{array}\right),\cdots ,$$

  

  wobei 2^m-1 ≤ n ≤ 2^m - 1. Wenn n = 2^m - 1 ist, dann definiert die Kontrollmatrix H in Gleichung (1) einen Untercode des binären Hamming Codes der Länge n.
• Die Funktionswerte F(1), F(2), ... stellen binäre Spaltenvektoren der Länge l dar. Das heißt, $\text{F}:{\mathbb{F}}_2^{\text{m}}\to {\mathbb{F}}_2^{\text{l}}.$

  

  Eine notwendige (aber nicht hinreichende) Bedingung, dass die Kontrollmatrix H einen doppelfehlerkorrigierenden Code erzeugt, ist l ≥ m. Um einen tripelfehlerkorrigierenden Code zu erhalten muss l ≥ 2m sein. Um einen Code zu erhalten, mit dem alle s-Bitfehler mit 1 ≤ s ≤ t korrigiert werden können, muss l ≥ (t - 1)m gelten.
• Es existieren Codes mit l = m, l = 2m und l = (t - 1)m für die genannten Fehlerkorrekturstärken, und solche Codes sind natürlich aus Effizienzgründen vorzuziehen.
• Beispiele
• Die 5 × 31-Matrix $$\begin{array}{c}{\text{H}}_0=\\ \left(\begin{array}{ccccccccccccccccccccccccccccccc}1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1\\ 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1\end{array}\right)\end{array}$$

  

  ist die Kontrollmatrix des binären Hamming Codes der Länge n = 31. Die Spaltenvektoren der Matrix H₀ sind - von links nach rechts gelesen - die Binärdarstellungen der natürlichen Zahlen 1,2, ... ,31. Der Hamming Code hat die Minimumdistanz d = 3, und es können daher mit ihm Einbitfehler korrigiert werden.
• Da eine Kontrollmatrix mit fünf Zeilen die Einbitfehlerkorrektur in Codewörtern der Länge 31 ermöglicht, sollten zehn Zeilen ausreichen für die Zweibitfehlerkorrekur. Dazu wird die Matrix H₀ durch Hinzufügen von fünf weiteren Zeilen erweitert, sodass die neue 10 × 31-Matrix einen Code mit der Minimumdistanz d = 5 definiert.
• Die Matrix $$\begin{array}{c}{H}_1=\\ \left(\begin{array}{ccccccccccccccccccccccccccccccc}1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1\\ 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1\\ 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& 0\\ 0& 0& 0& 0& 0& 1& 1& 0& 1& 0& 1& 0& 1& 1& 0& 0& 0& 0& 0& 0& 0& 1& 1& 0& 1& 0& 1& 0& 1& 1& 0\\ 0& 0& 0& 0& 1& 0& 1& 0& 0& 0& 0& 1& 0& 1& 0& 0& 0& 1& 1& 0& 1& 1& 0& 0& 0& 1& 1& 1& 0& 0& 1\\ 0& 0& 0& 0& 1& 0& 1& 0& 0& 1& 1& 0& 1& 1& 0& 0& 0& 0& 0& 0& 1& 0& 1& 1& 1& 0& 0& 1& 0& 0& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 0& 0& 1& 1& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 0& 1& 0& 1& 0& 1\end{array}\right)\end{array}$$

  

  hat diese Eigenschaft. (Die $\left(\begin{array}{c}31\\ 1\end{array}\right)+\left(\begin{array}{c}31\\ 2\end{array}\right)+\left(\begin{array}{c}31\\ 3\end{array}\right)+\left(\begin{array}{c}31\\ 4\end{array}\right)=31+465+4495+31465=36456$

  

  Summen aus jeweils einer, zwei, drei oder vier Spalten der Matrix H₁ sind alle verschieden vom Nullvektor. Andererseits kann es passieren, dass die Summe aus fünf Spaltenvektoren die Alles-Null-Spalte ergibt. Es gilt zum Beispiel h₃ + h₅ + h₇ + h₈ + h₉ = 0. Daraus folgt, dass die Matrix H₁ einen Code mit Minimumdistanz d = 5 definiert.)
• Da die Matrix H₁ die Kontrollmatrix H₀ des Hamming Codes als Submatrix enthält, ist der durch H₁ definierte Code ein Untercode des Hamming Codes der Länge 31. Die Kontrollmatrix H₁ ist von der Form in Gleichung (1).
• Die Matrix H₁ kann formal dargestellt werden durch $$H_1=\left(\begin{array}{c}v\\ w\\ x\\ y\\ z\\ vw+xz\\ vy+wx\\ vx+wz+xy\\ vx+wy+yz\\ vz+wy+wz\end{array}\right).$$

  
• Wenn der 5-dimensionale Vektor (v, w, x, y, z)^T der Reihe nach die Vektoren $$1=\left(\begin{array}{c}1\\ 0\\ 0\\ 0\\ 0\end{array}\right),2=\left(\begin{array}{c}0\\ 1\\ 0\\ 0\\ 0\end{array}\right),\text{ 3}=\left(\begin{array}{c}1\\ 1\\ 0\\ 0\\ 0\end{array}\right),\cdots ,\text{ 31}=\left(\begin{array}{c}1\\ 1\\ 1\\ 1\\ 1\end{array}\right)$$

  

  durchläuft, dann durchläuft der 10-dimensionale Vektor in Gleichung (2) die 31 Spalten der obigen Matrix H₁.
• Der durch die Kontrollmatrix H₁ bzw. deren formale Beschreibung in Gleichung (2) definierte binäre Code ist ein (31,21,5) linearer systematischer Code. Die zehn Kontrollbits befinden sich in dem 31 Bit langen Codewort auf den Plätzen 1,2,4,8,16 und 3,6,12,24,17. Auf den verbleibenden 21 Plätzen im Codewort sitzen die Nachrichtenbits. (Die Positionen der zehn Kontrollbits sind nicht eindeutig bestimmt. Es gibt zahlreiche andere Möglichkeiten, die zehn Kontollbits zu platzieren. Jedoch ist nicht jede Platzierung möglich. Dies wird weiter unten noch genauer erläutert.)
• Die 15 × 31-Kontrollmatrix $$\begin{array}{c}{H}_2=\\ \left(\begin{array}{ccccccccccccccccccccccccccccccc}1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1\\ 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1\\ 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1\\ 0& 0& 0& 0& 0& 1& 1& 0& 0& 0& 0& 0& 0& 1& 1& 0& 0& 0& 0& 0& 0& 1& 1& 0& 0& 0& 0& 0& 0& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1\\ 0& 0& 0& 0& 1& 0& 1& 0& 0& 0& 0& 0& 1& 0& 1& 0& 0& 0& 0& 0& 1& 0& 1& 0& 0& 0& 0& 0& 1& 0& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 1& 0& 1& 0& 1& 0& 1& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 0& 1& 0& 1& 0& 1\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1\end{array}\right)\end{array}$$

  

  definiert einen linearen systematischen (31,16,7)-Code. Die Matrix H₂ kann formelmäßig dargestellt werden durch den variablen Spaltenvektor $$H_2=\left(\begin{array}{c}v\\ w\\ x\\ y\\ z\\ vw\\ wx\\ xy\\ yz\\ vz\\ vx\\ wy\\ xz\\ vy\\ wz\end{array}\right).$$

  
• Die 15 Kontrollbits können in dem 31 Bit langen Codewort auf die Plätze 1,2,4,8,16; 3,6,12,24,17 und 5,10,20,9,18 gelegt werden.
• Ein doppelfehlerkorrigierender linearer Code der Länge n = 63, Dimension k = 51, und mit der Minimumdistanz d = 5 ist gegeben durch $$H_3=\left(\begin{array}{c}u\\ v\\ w\\ x\\ y\\ z\\ uv+ux+vz+wy\\ uw+vw+vy+xz\\ ux+uy+vy+wx\\ uw+vz+wz+xy\\ uw+ux+vy+yz\\ uz+vx+vy+xz\end{array}\right).$$

  
• Dieser (63,51,5)-Code ist ebenfalls systematisch. Die 12 Kontrollbits befinden sich auf den Plätzen 1,2,4,8,16,32 und 3,6,12,24,48,33. Auf den restlichen Plätzen in dem 63 Bit langen Codewort befinden sich die 51 Nachrichtenbits.
• Der variable 18-dimensionale Spaltenvektor $$H_4=\left(\begin{array}{c}u\\ v\\ w\\ x\\ y\\ z\\ uv+ux\\ vw+vy\\ wx+wz\\ vy+xy\\ ux+yz\\ uz+wz\\ uw+vy\\ vx+wz\\ ux+wy\\ vy+xz\\ uy+wz\\ ux+vz\end{array}\right).$$

  

  beschreibt die 18 × 63-Kontrollmatrix H₄ eines (63,45,7) linearen systematischen Codes, der - wie auch der Code in Beispiel 3 - ein Untercode des Hamming Codes derselben Länge ist. Die 18 Kontrollbits sitzen auf den Plätzen 1,2,4,8,16,32; 3,6,12,24,48,33; 5,10,20,40,17,34.
• Im Folgenden wird die Verwendung von Codes mit einer Kontrollmatrix von der Form von Gleichung (1) haben, z.B. durch die Speicherzugriffseinheit, beschrieben.
• Man betrachte die Struktur der Kontrollmatrix in Gleichung (1). Die oberen Einträge in der Matrix, 1, 2, ..., n, repräsentieren die natürlichen Zahlen 1,2, ..., n. Jede natürliche Zahl ist dargestellt durch einen binären Vektor der Länge m. Um die Vektordarstellung zu betonen ist die natürliche Zahl in Fettdruck geschrieben. Die Länge m ergibt sich aus der Codewortlänge n durch m = [log₂n] + 1. Mit anderen Worten, wenn der Code die Länge n hat, dann ist m die eindeutig bestimmte natürliche Zahl mit der Eigenschaft $$2^{m-1}\le n<2^{m.}$$

  
• Für die Codewortlängen n ∈ {8,9,10,11,12,13,14,15} folgt zum Beispiel, dass m = 4 ist.
• In diesem Fall bedeutet $$1=\left(\begin{array}{c}1\\ 0\\ 0\\ 0\end{array}\right),2=\left(\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right),\text{ 3}=\left(\begin{array}{c}1\\ 1\\ 0\\ 0\end{array}\right),\text{ 4}=\left(\begin{array}{c}0\\ 0\\ 1\\ 0\end{array}\right),\cdots$$

  
• Die Zahl m stimmt überein mit der Anzahl der Variablen in der algebraischen Darstellung der Kontrollmatrix des Codes. Es wird deshalb auch von einem m-Variable-Code gesprochen. Zum Beispiel ist der Code der Länge 31 mit der Kontrollmatrix H₁ in Gleichung (2) ein 5-Variable-Code.
• Man betrachte die allgemeine Kontrollmatrix in Gleichung (1). Die j-te Spalte h_j der Matrix hat die Form $$h_j=\left(\begin{array}{c}j\\ F\left(j\right)\end{array}\right).$$

  

  Angenommen j hat die Länge m. Dann hat der Spaltenvektor h_j die Länge 2m, wenn es sich um einen doppelfehlerkorrigierenden Code handelt (Minimumdistanz d = 5). Wenn es sich um einen tripelfehlerkorrigierenden Code handelt (Minimumdistanz d = 7), dann hat h_j die Länge 3m. Der obere Teil j des Spaltenvektors h_j heißt die Spaltennummer. Der untere Teil F(j) ist der Funktionswertanteil von h_j.
• Die hier betrachteten linearen Codes werden durch eine Funktion $F:{\mathbb{F}}_2^m\to {\mathbb{F}}_2^l$

  

  beschrieben, wobei l = m ist für den doppel- und l = 2m für den tripelfehlerkorrigierenden Code.
• Für den Code der Länge 31 aus dem obigen Beispiel, der durch die Kontrollmatrix H₁ in Gleichung (2) definiert wird, ist beispielsweise $F:{\mathbb{F}}_2^{\text{5}}\to {\mathbb{F}}_2^{\text{5}}$

  

  mit $$F:\left(\begin{array}{c}v\\ w\\ x\\ y\\ z\end{array}\right)\mapsto \left(\begin{array}{c}vw+xz\\ vy+wx\\ vx+wz+xy\\ vx+wy+yz\\ vz+wy+wz\end{array}\right).$$

  
• Die Funktion $F:{\mathbb{F}}_2^m\to {\mathbb{F}}_2^l$

  

  wird durch l Boolsche Funktionen $F_i:{\mathbb{F}}_2^m\to {\mathbb{F}}_2^{}$

  

  beschrieben. Die Funktionen F_i = F_i(x₁,...,x_m), 1 ≤ i ≤ l, heißen die Komponenten von F. $$F\left(x_1,\dots ,x_m\right)=\left(\begin{array}{c}{F}_1\left(x_1,\dots ,x_m\right)\\ F_2\left(x_1,\dots ,x_m\right)\\ ⋮\\ F_l\left(x_1,\dots ,x_m\right)\end{array}\right).$$

  
• Die fünf Komponentenfunktionen der in diesem Beispiel angegebenen Funktion F sind F₁(v, w, x, y, z) = vw + xz, F₂(v, w, x, y, z) = vy + wx, F₃(v, w, x, y, z) = vx + wz + xy, F₄(v, w, x, y, z) = vx + wy + yz und F₅(v, w, x, y, z) = vz + wy + wz.
• Auf der Basis der Funktion F führt die Speicherzugriffseinheit die zum codierten Speichern und Auslesen von Daten erforderlichen Operationen - Codierung, Syndromberechnung, Fehlerkorrektur - aus. Im Folgenden wird erläutert, auf welche Weise dies gemäß einer Ausführungsform geschieht. Es wird im Folgenden Ausführungen vorausgesetzt, dass die Funktion F = F(x₁,...,x_m) und die Codewortlänge n bekannt sind.
• Spaltenvektorberechnung
• Sei j ∈ {1,2, ..., n} eine beliebige Spaltennummer. Es sei der zugehörige Spaltenvektor h_j der Kontrollmatrix zu berechnen. Sei $$j=\left(\begin{array}{c}{j}_1\\ j_2\\ ⋮\\ j_m\end{array}\right)$$

  

  die Binärdarstellung der natürlichen Zahl j in der Form eines Spaltenvektors j der Länge m, d.h., j = j₁ + 2j₂ + 4j₃ + ... + 2^m-1j_m. Dann ist die j-te Spalte der Kontrollmatrix gegeben durch $$h_j=\left(\begin{array}{c}j\\ F\left(j\right)\end{array}\right)=\left(\begin{array}{c}{j}_1\\ j_2\\ ⋮\\ j_m\\ F_1\left(j_1,\dots ,j_m\right)\\ F_2\left(j_1,\dots ,j_m\right)\\ ⋮\\ F_l\left(j_1,\dots ,j_m\right)\end{array}\right).$$

  
• Man betrachte als Beispiel den doppelfehlerkorrigierenden Code der Länge 31, der durch die Kontrollmatrix H₁ in Gleichung (2) gegeben ist. Hier ist m = 5 und $$F\left(v,w,x,y,z\right)=\left(\begin{array}{c}{F}_1\left(v,w,x,y,z\right)\\ F_2\left(v,w,x,y,z\right)\\ F_3\left(v,w,x,y,z\right)\\ F_4\left(v,w,x,y,z\right)\\ F_5\left(v,w,x,y,z\right)\end{array}\right)=\left(\begin{array}{c}vw+xz\\ vy+wx\\ vx+wz+xy\\ vx+wy+yz\\ vz+wy+wz\end{array}\right).$$

  
• Daraus kann jede einzelne Spalte der Kontrollmatrix berechnet werden. Zum Beispiel erhält man für die siebente Spalte $$h_7=\left(\begin{array}{c}7\\ F\left(7\right)\end{array}\right)=\left(\begin{array}{c}1\\ 1\\ 1\\ 0\\ 0\\ F_1\left(\mathrm{1,1,1,0,0}\right)\\ F_2\left(\mathrm{1,1,1,0,0}\right)\\ F_3\left(\mathrm{1,1,1,0,0}\right)\\ F_4\left(\mathrm{1,1,1,0,0}\right)\\ F_5\left(\mathrm{1,1,1,0,0}\right)\end{array}\right)=\left(\begin{array}{c}1\\ 1\\ 1\\ 0\\ 0\\ 1\\ 1\\ 1\\ 1\\ 0\end{array}\right).$$

  
• Im Folgenden wird ein Beispiel für ein Verfahren zur Berechnung der Spaltenvektoren der Kontrollmatrix, bezeichnet als „VEK“, in Pseudocode angegeben:
• VEK
• Eingabe: j ∈ {1, ..., n}
• Schritt 1: Berechne j = (j₁,...,j_m)^T
• Schritt 2: Berechne F(j) = (F₁(j), ...,F_l(j))^T
• Ausgabe: $$\text{VEK}\left(j\right)=h_j=\left(\begin{array}{c}j\\ F\left(j\right)\end{array}\right)$$
  
• Spaltenvektorverifikation
• Gegeben sei ein binärer Spaltenvektor v der Länge r = m + l. $$v=\left(\begin{array}{c}a\\ b\end{array}\right)=\left(\begin{array}{c}{a}_1\\ a_2\\ ⋮\\ a_m\\ b_1\\ b_2\\ ⋮\\ b_l\end{array}\right).$$

  
• Bei der Spaltenvektorverifikation soll ermittelt werden, ob dieser Vektor v ein Spaltenvektor der Kontrollmatrix des zugrundeliegenden durch die Funktion F und die Codewortlänge n definierten Codes ist.
• Eine notwendige Voraussetzung dafür, dass v ein Spaltenvektor der Kontrollmatrix ist, ist $$1\le a:=a_1+2a_2+\cdots 2^{m-1}{a}_m\le n.$$

  
• Angenommen dies ist der Fall. Dann ist a bzw. a eine zulässige Spaltennummer. Berechne die a-te Spalte der Kontrollmatrix mithilfe von VEK: $$\text{VEK}\left(a\right)=h_a\left(\begin{array}{c}a\\ F\left(a\right)\end{array}\right).$$

  

  Der gegebene Vektor v = (a, b)^T ist ein Spaltenvektor der Kontrollmatrix genau dann, wenn v = VEK(a) gilt. Und das ist genau dann der Fall, wenn b = F(a) ist.
• Wenn sich herausstellt, dass der untersuchte Vektor v ein Spaltenvektor der Kontrollmatrix ist, ist VER(v) = 1. Wenn v kein Spaltenvektor der Kontrollmatrix ist, ist VER(v) = 0.
• Im Folgenden wird ein Beispiel für ein Verfahren zur Spaltenvektorverifikation, bezeichnet als „VER“, in Pseudocode angegeben:
• VER
• Eingabe: $v=\left(v_1,\dots ,v_{m+l}\right)\in {\mathbb{F}}_2^{m+l}$
  
• Ausgabe: VER(v) ∈ {0,1}
• Schritt 1: Berechne a : = (v₁, ..., v_m)^T
• Schritt 2: Berechne b : = (v_m+1,...,v_m+l)^T
• Schritt 3: Berechne $a:={\displaystyle \sum {}_{i=1}^m{v}_i{2}^{i-1}}$
  
• Wenn a = 0 oder a > n, dann gebe VER(v) = 0 aus.
• Wenn 1 ≤ a ≤ n, dann gehe zu Schritt 4
• Schritt 4: Berechne F(a)
• Wenn F(a) = b, dann gebe VER(v) = 1 aus.
• Wenn F(a) ≠ b, dann gebe VER(v) = 0 aus.
• Syndromberechnung
• Sei H die Kontrollmatrix für einen linearen (n, k, d)-Code. Dann ist H eine binäre Matrix mit n - k Zeilen und n Spalten. Sei $y=\left(y_1,\dots ,y_n\right)\in {\mathbb{F}}_2^n$

  

  die empfangene Nachricht. Um eine Auskunft über die Fehlerfreiheit oder Fehlerhaftigkeit von y zu bekommen, berechnet der Dekodierer 105 das Syndrom von y: $$\text{Syn}\left(y\right)=H{y}^T.$$

  
• Das Syndrom des n Bit langen Zeilenvektors y ist also ein Spaltenvektor der Länge n - k. Wenn y fehlerfrei ist, dann ist Syn(y) der Nullvektor.
• Seien $h_1,\dots ,h_n\in {\mathbb{F}}_2^{n-k}$

  

  die Spalten der Kontrollmatrix H, das heißt $$H=\left(h_1,h_2,\dots ,h_n\right).$$

  
• Dann folgt $$\text{Syn}\left(\text{y}\right)=H{y}^T=y_1{h}_1+y_2{h}_2+\cdots +y_n{h}_n.$$

  
• Sei I = (i₁, ..., i_r} die Menge aller Indizes i für die die i-te Koordinate des Nachrichtenvektors y gleich 1 ist. Mit anderen Worten, I ist die Teilmenge von {1, ..., n} mit der Eigenschaft i ∈ I genau dann, wenn y_i = 1. Dann gilt $$\text{Syn}\left(\text{y}\right)=h_{i_1}+h_{i_2}+\cdots +h_{i_r}.$$

  
• Die Syndromberechnung auf der Basis der Funktion F geschieht daher folgendermaßen: Betrachte den Nachrichtenvektor y = (y₁, ..., y_n). Die Koordinaten von y die gleich 0 sind, haben keinen Einfluss auf das Syndrom. Für jede Koordinate y_i die gleich 1 ist, berechnet der Dekodierer 105 mit der Hilfe von VEK den Spaltenvektor $$h_i=\text{VEK}\left(i\right)$$

  
• Alle diese Spaltenvektoren werden aufsummiert. Der Summenvektor ist dann das Syndrom von y. (Aufsummieren bedeutet, dass die Spaltenvektoren bitweise per XOR addiert werden.)
• Im Folgenden wird ein Beispiel für ein Verfahren zur Syndromberechnung, bezeichnet als „SYN“, in Pseudocode angegeben:
• SYN
• Eingabe: $y=\left(y_1,\dots ,y_n\right)\in {\mathbb{F}}_2^n$
  
• Initialisiere: $s:=0\in {\mathbb{F}}_2^{m+l}$
  
• for i from 1 to n do
• if y_i = 1 then s : = s + VEK(i) else s : = send if
• end do;
• Ausgabe: s = Syn(y)
• Codierung
• Sei r der Rang der Kontrollmatrix H. Die Zahl r stimmt überein mit der Anzahl der Zeilen von H. Bei dem doppelfehlerkorrigierenden Code ist r = 2m. Bei dem tripelfehlerkorrigierenden Code ist r = 3m.
• Ein Codewort der Länge n enthält r Kontrollbits c₁, c₂, ..., c_r und n - r Nachrichtenbits a₁, a₂, ..., a_n-r. Bei einem systematischen Code treten die Nachrichtenbits direkt im Codewort auf.
• Üblicherweise werden die Kontrollbits an die Nachrichtenbits angehängt, sodass ein Codewort der Form $$\left(a_1,a_2,\dots ,a_{n-r},c_1,c_2,\dots ,c_r\right)$$

  

  entsteht. Diese Darstellung setzt allerdings voraus, dass die benutzte Kontrollmatrix H die Form $$H=\left(A|I\right)$$

  

  hat mit der r × r-Einheitsmatrix I am Schluß. Insbesondere treten alle r Einheitsvektoren $$\left(\begin{array}{l}1\hfill \\ 0\hfill \\ 0\hfill \\ ⋮\hfill \\ 0\hfill \\ 0\hfill \end{array}\right),\left(\begin{array}{l}0\hfill \\ 1\hfill \\ 0\hfill \\ ⋮\hfill \\ 0\hfill \\ 0\hfill \end{array}\right),\dots ,\left(\begin{array}{l}0\hfill \\ 0\hfill \\ 0\hfill \\ ⋮\hfill \\ 0\hfill \\ 1\hfill \end{array}\right)\in {\mathbb{F}}_2^r$$

  

  als Spalten in der Kontrollmatrix H auf. Das ist bei den vom Kodierer 103 gemäß verschiedenen Ausführungsformen verwendeten Codes nicht der Fall. Diese Codes haben, wie mit Bezug auf Gleichung (1) erwähnt, eine Kontrollmatrix der Form $$H=\left(\begin{array}{cccc}1& 2& \dots & \mathbf{n}\\ F\left(1\right)& F\left(2\right)& \dots & F\left(\mathbf{n}\right)\end{array}\right).$$

  
• In dieser Matrix treten nur die ersten m Einheitsvektoren aus ${\mathbb{F}}_2^r$

  

  auf, und zwar tun sie das an den Stellen 1,2,4, ..., 2^m-1. Daher ist die übliche Darstellung von Gleichung (4) für die Codewörter eines systematischen Codes hier nicht möglich. Im vorliegenden Fall werden stattdessen die r Kontrollbits c₁, ..., c_r an bestimmten Stellen im Codewort platziert. Auf den verbleibenden n - r Stellen werden der Reihe nach, von links nach rechts, die Nachrichtenbits a₁, a₂, ..., a_n-r platziert. Die r Stellen für die Kontrollbits müssen explizit angegeben werden in der Beschreibung des Codes.
• Es gibt viele Möglichkeiten die Kontrollbits zu platzieren, jedoch können sie nicht beliebig platziert werden. Voraussetzung für die Wahl der Kontrollbitpositionen ist, dass die r Spaltenvektoren der Kontrollmatrix an den Positionen der Kontrollbits eine quadratische r × r-Matrix M bilden, die invertierbar ist. Es ist immer möglich - und aus Effizienzgründen wird dies gemäß einer Ausführungsform vorgenommen - die Stellen 1,2,4, ..., 2^m-1 als Kontrollbitpositionen zu nutzen.
• Seien p₁, ..., p_r die gewählten Kontrollbitpositionen mit $$1\le p_1<p_2<\cdots <p_r\le n.$$

  
• Die Kontrollbits c₁, ..., c_r berechnet der Kodierer 104 aus den vorgegebenen Nachrichtenbits a₁, ..., a_n-r folgendermaßen: Berechne mit VEK die zugehörigen r Spaltenvektoren der Kontrollmatrix H: $$\text{VEK}\left(p_i\right)=\left(\begin{array}{c}{p}_i\\ F\left(p_i\right)\end{array}\right),i=\mathrm{1,}\dots ,r.$$

  
• Bilde die r × r-Matrix M gegeben durch $$M=\left(\text{VEK}\left(p_1\right),\dots ,\text{VEK}\left(p_r\right)\right).$$

  
• Die Matrix M muss invertierbar sein, sonst sind die gewählten Kontrollbitpositionen p₁, ..., p_r nicht möglich. Sei M^-1 die inverse Matrix zu M. Sei a = (a₁, a₂, ..., a_n-r) der Nachrichtenvektor. Der Nachrichtenvektor a wird, indem Platz geschaffen wird für die Kontrollbits, zu einem Vektor a' der Länge n erweitert. Der erweiterte Vektor a' enthält alle n - r Nachrichtenbits a_i und zusätzliche r Nullen, die zwischen die Nachrichtenbits eingeschoben werden. Am Ende liegt auf jeder Kontrollbitposition p_j eine der hinzugefügten Nullen.
• Als nächstes berechnet der Kodierer 104 mittels SYN das Syndrom von a'. Sei $$\text{SYN}\left(a\text{'}\right)=\left(\begin{array}{c}{z}_1\\ z_2\\ ⋮\\ z_r\end{array}\right).$$

  
• Die Kontrollbits c₁, ..., c_r werden erhalten durch $$\left(\begin{array}{c}{c}_1\\ c_2\\ ⋮\\ c_r\end{array}\right)=M^{-1}\left(\begin{array}{c}{z}_1\\ z_2\\ ⋮\\ z_r\end{array}\right).$$

  
• Die berechneten Kontrollbits c_j werden nun im Vektor a' an die Stellen der zuvor eingebrachten Nullen gesetzt. Der entstehende Vektor a'' ist das endgültige Codewort.
• Als Beispiel betrachte man den doppelfehlerkorrigierenden Code der Länge n = 31, der durch die Matrix H₁ gegeben ist. Es ist m = 5 und r = 2m = 10. Die zehn Kontrollbitpositionen sind 1,2,3,4,6,8,12,16,17 und 24. Daher ist $$M=\left(\begin{array}{llllllllll}1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill \end{array}\right).$$

  
• Die Matrix M ist invertierbar und $$M^{-1}=\left(\begin{array}{llllllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill \end{array}\right).$$

  
• Aus (5) ergibt sich $$\begin{array}{r}\hfill 5c_1\\ \hfill c_2\\ \hfill c_3\\ \hfill c_4\\ \hfill c_5\end{array}\begin{array}{l}=z_1+z_6+z_{10},\hfill \\ =z_2+z_6+z_7,\hfill \\ =z_6,\hfill \\ =z_3+z_7+z_8,\hfill \\ =z_7,\hfill \end{array}\begin{array}{r}\hfill c_6\\ \hfill c_7\\ \hfill c_8\\ \hfill c_9\\ \hfill c_{10}\end{array}\begin{array}{l}=z_4+z_8+z_9,\hfill \\ =z_8,\hfill \\ =z_5+z_9+z_{10},\hfill \\ =z_{10},\hfill \\ =z_9.\hfill \end{array}$$

  
• Das Nachrichtenwort a = (a₁, a₂, a₃, ..., a₂₁) wird also codiert in das Codewort $$\begin{array}{l}a\text{'}\text{'}=(c_1,c_2,c_3,c_4,a_1,c_5,a_2,c_6,a_3,a_4,a_5,c_7,a_6,a_7,a_8,c_8,c_9,\\ a_9,a_{10},a_{11},a_{12},a_{13},a_{14},c_{10},a_{15},a_{16},a_{17},a_{18},a_{19},a_{20},a_{21}).\end{array}$$

  
• Im Folgenden wird ein Beispiel für ein Verfahren zur Codierung eines Nachrichtenvektors $a\in {\mathbb{F}}_2^{n-r}$

  

  in sein Codewort $a\text{'}\text{'}\in {\mathbb{F}}_2^n,$

  

  bezeichnet als „ENC“ (für encoding), in Pseudocode angegeben. Es wird vorausgesetzt, dass die Kontrollbitpositionen p₁, ..., p_r und somit auch die Matrizen M und M^-1 bekannt sind.
• ENC
• Eingabe: $a=\left(a_1,a_2,\dots ,a_{n-r}\right)\in {\mathbb{F}}_2^{n-r}.$
  
• Schritt 1: Berechne a'
• Schritt 2: Berechne z : = SYN(a')
• Schritt 3: Berechne c = M^-1z
• Schritt 4: Berechne a''
• Ausgabe: a''
• Fehlerkorrektur
• Die Speicherzugriffseinheit 103 speichert Codewörter im Speicher (oder im Falle eines Nachrichtenkanals werden Codewörter übertragen). Sei y = (y₁, ..., y_n) ein ausgelesenes Wort (bzw. ein empfangenes Nachrichtenwort). Aufgrund von möglichen Speicherfehlern oder Auslesefehlern (bzw. Übertragungsfehlern) ist y nicht notwendigerweise ebenfalls ein Codewort. Der Dekodierer 105 berechnet zunächst das Syndrom von y mithilfe von SYN. Das Syndrom s = SYN(y) ist ein Spaltenvektor der Länge r. Die empfangene Nachricht y ist ein Codewort genau dann, wenn ihr Syndrom s der Nullvektor in ${\mathbb{F}}_2^r$

  

  ist. Wenn kein Fehler bei der Übertragung aufgetreten ist, dann ist die empfangene Nachricht identisch mit dem gesendeten Codewort und das Syndrom ist 0. Umgekehrt wird ein verschwindendes Syndrom als starker Hinweis für die Fehlerfreiheit von y gewertet und man geht dann davon aus, dass y mit dem gesendeten Codewort übereinstimmt (eine Annahme, die in den meisten Fällen richtig ist).
• Wenn ein Ein-, Zwei- oder Dreibitfehler bei der Übertragung von y aufgetreten ist, dann ist das Syndrom von y mit Sicherheit ungleich 0 bei doppel- und tripelfehlerkorrigierenden Codes.
• Bei einem aufgetretenen 1-Bitfehler an der Stelle i ∈ {1, ..., n} stimmt das Symptom s = Syn(y) überein mit der i-ten Spalte h_i der Kontrollmatrix H. Es gilt also $$s=h_i=\left(\begin{array}{c}i\\ F\left(i\right)\end{array}\right).$$

  
• Bei zwei aufgetretenen Bitfehlern an den Stellen i und j gilt $$s=h_i+h_j=\left(\begin{array}{c}i\\ F\left(i\right)\end{array}\right)+\left(\begin{array}{c}j\\ F\left(j\right)\end{array}\right).$$

  
• Bei einem aufgetretenen Dreibitfehler in den Positionen i, j, k gilt $$s=h_i+h_j+h_k=\left(\begin{array}{c}i\\ F\left(i\right)\end{array}\right)+\left(\begin{array}{c}j\\ F\left(j\right)\end{array}\right)+\left(\begin{array}{c}k\\ F\left(k\right)\end{array}\right).$$

  
• Für eine Fehlerkorrektur berechnet der Dekodierer 105 aus dem bekannten Syndromvektor s die Fehlerpositionen i, (i,j) bzw. (i,j,k). Sind die Fehlerpositionen bekannt, dann korrigiert der Dekodierer 105 das ausgelesene Wort (bzw. die empfangene Nachricht) an den entsprechenden Stellen. (Dreibitfehler können natürlich nur in dem Code mit Minimumdistanz d = 7 korrigiert werden).
• Im Folgenden wird ein Beispiel für ein Verfahren zur Einbitfehlerkorrektur, bezeichnet als „UNO“, in Pseudocode angegeben. Das Verfahren UNO liefert die Position j eines aufgetretenen Einbitfehlers. Es erhält als Eingabe das von Null verschiedene Syndrom s des ausgelesenen Worts (bzw. der empfangenen Nachricht) y.
• UNO
• Eingabe: $s={\left(s_1,\dots ,s_r\right)}^T\in {\mathbb{F}}_2^r\backslash \left\{0\right\}$
  
• Berechne b : = VER(s)
• Wenn b = 0 dann schreite fort mit DUE
• Wenn b = 1 dann berechne j : = s₁ + 2s₂ + 4s₃ + ... + 2^m-1s_m Ausgabe: j
• Wenn ein 2-Bitfehler aufgetreten ist, dann hat das Syndrom s die Form $$s=h_i+h_j,$$

  

  wobei die Indizes i und j unbekannt sind.
• Sei h_t ein beliebiger Spaltenvektor der Kontrollmatrix H. Man betrachte den Vektor $$u:=s+h_t=h_i+h_j+h_t.$$

  
• Für t ∈ {1, ..., n}\{i, j} ist u die Summe aus drei Spaltenvektoren und VER(u) = 0.
• Dagegen ist für die Werte t = i und t = j der Vektor u identisch mit einem Spaltenvektor der Kontrollmatrix. Wenn t = i ist, folgt $$u=h_j=\left(\begin{array}{c}j\\ F\left(j\right)\end{array}\right).$$

  
• Und wenn t = j ist, dann folgt $$u=h_i=\left(\begin{array}{c}i\\ F\left(i\right)\end{array}\right).$$

  
• In diesen beiden Fällen ist VER(u) = 1.
• Im Folgenden wird ein Beispiel für ein entsprechendes Verfahren zur Zweibitfehlerkorrektur, bezeichnet als „DUE“, in Pseudocode angegeben. Das Verfahren DUE erhält als Eingabe einen Syndromvektor s mit s ≠ 0 und VER(s) = 0. Wenn ein Zweibitfehler vorliegt, liefert das Verfahren die beiden Fehlerpositionen als Ausgabe. Wenn mehr als zwei Fehler aufgetreten sind, liefert DUE die Ausgabe „Mehrbitfehler“.
• DUE
• Eingabe: $s\in {\mathbb{F}}_2^r\backslash \left\{0\right\}\text{ mit VER}\left(s\right)=0$
  
• Initialisiere: i = 1
• Schritt 1: Berechne v : = VEK(i)
• Schritt 2: Berechne w : = v + s = (w₁, ..., w_r)^T
• Schritt 3: Berechne b : = VER(w)
• Wenn b = 1 dann berechne $j:={\displaystyle {\sum }_{i=1}^m{w}_i{2}^{i-1}}$
  
  und gebe (i,j) aus.
• Wenn b = 0 und i < n dann i : = i + 1 und gehe zurück zu Schritt 1.
• Wenn b = 0 und i = n dann gebe „Mehrbitfehler“ aus.
• Wenn der zugrundeliegende Code die Minimumdistanz d = 5 hat, kann ein aufgetretener Mehrbitfehler (im Sinn von „mehr als zwei Bitfehler“, also z.B. ein Dreibitfehler) nicht korrigiert werden. Wenn der Code die Minimumdistanz d = 7 hat, können Dreibitfehler ebenfalls korrigiert werden.
• Dazu geht der Dekodierer 105 folgendermaßen vor.
• Bei einem aufgetretenen Dreibitfehler hat das Syndrom die Form $$s=h_a+h_b+h_c$$

  

  mit unbekannten Fehlerpositionen a, b, c ∈ {1,2, ..., n}. Beginnend mit t = 1 - und wenn nötig für weitere Werte von t - berechnet der Dekodierer 105 $$h_t=\text{VEK}\left(t\right)=\left(\begin{array}{c}t\\ F\left(t\right)\end{array}\right)$$

  

  und addiert den Spaltenvektor h_t zu s hinzu. Der Summenvektor z : = s + h_t wird dann DUE als Eingabe übergeben.
• Wenn t ∉ {a, b, c}, dann wurde durch die Addition von h_t die Lage verschlimmert (so als wäre ein 4-Bitfehler aufgetreten). In diesem Fall liefert DUE die Ausgabe „Mehrbitfehler“.
• Wenn t ∈ {a, b, c}, dann ist z = s + h_t die Summe aus nur mehr zwei Spaltenvektoren der Kontrollmatrix. In diesem Fall liefert DUE eine Ausgabe der Form (i,j) ∈ {(a, b), (a, c), (b, c)}. Die Positionen des Dreibitfehlers sind dann i, j und t.
• Im Folgenden werden Beispiele für eine schnelle Syndromberechnung beschrieben, die vom Dekodierer 105 (aber auch vom Kodierer 105) eingesetzt werden kann.
• Man betrachte die Matrix aus Gleichung (1). Sei n = 2^m - 1. Der Matrix wird eine Alles-Null-Spalte auf der linken Seite hinzugefügt. Die so erweiterte Matrix ist $$\widehat{H}=\left(\begin{array}{ccccc}0& 1& 2& \dots & n\\ F\left(0\right)& F\left(1\right)& F\left(2\right)& \dots & F\left(n\right)\end{array}\right).$$

  
• Die erweiterte Matrix Ĥ ist zwar nicht mehr Kontrollmatrix des zugrundeliegenden Codes, sie bietet jedoch einen Vorteil für die schnelle Syndromberechnung aufgrund der durch das Hinzufügen der Alles-Null-Spalte erzielten Übereinstimmung zwischen der linken und der rechten Hälfte der Matrix im oberen Bereich. Zum Beispiel wird die 10 × 31-Kontrollmatrix H₁ zu der 10 × 32-Matrix $$\begin{array}{c}\widehat{H_1}=\\ \left(\begin{array}{ccccccccccccccccccccccccccccccc}0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& & 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 1& 0& 10\text{ 1 }\\ 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& & 0& 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 1& 0& \text{0 1 1 }\\ 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1& 1& & 0& 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1\text{ 1 1 }\\ 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1& 1& 1& & 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 1& 1& 1& 1\text{ 1 1 }\\ & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & \\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& & 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1& 1\text{ 1 1 }\\ & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & \\ 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& 0& 0& 0& 1& & 0& 0& 0& 1& 1& 1& 1& 0& 0& 0& 0& 1& 1& 1\text{ 1 0 }\\ 0& 0& 0& 0& 0& 0& 1& 1& 0& 1& 0& 1& 0& 1& 1& 0& & 0& 0& 0& 0& 0& 0& 1& 1& 0& 1& 0& 1& 0& 1\text{ 1 0 }\\ 0& 0& 0& 0& 0& 1& 0& 1& 0& 0& 0& 0& 1& 0& 1& 0& & 0& 0& 1& 1& 0& 1& 1& 0& 0& 0& 1& 1& 1& \text{0 0 1 }\\ 0& 0& 0& 0& 0& 1& 0& 1& 0& 0& 1& 1& 0& 1& 1& 0& & 0& 0& 0& 0& 0& 1& 0& 1& 1& 1& 0& 0& 1& \text{0 0 1 }\\ 0& 0& 0& 0& 0& 0& 0& 0& 0& 0& 1& 1& 0& 0& 1& 1& & 0& 1& 1& 0& 0& 1& 1& 0& 0& 1& 0& 1& 0& \text{1 0 1 }\end{array}\right)\end{array}$$

  
• Die Matrix $\widehat{H_1}$

  

  zerfällt in 6 Teilmatrizen. Man beachte, dass die beiden 4 × 16-Teilmatrizen im oberen Bereich der Matrix miteinander identisch sind. Die mittlere 1 × 16-Teilmatrix ist konstant 0. Die 1 × 16-Teilmatrix rechts daneben ist konstant 1.
• Die beiden 5 × 16-Teilmatrizen im unteren Teil der Matrix H₁ sind zwar nicht miteinander identisch, sie sind jedoch mit einander „verwandt“: Die rechte 5 × 16-Teilmatrix ist eine maskierte Version der linken 5 × 16-Teilmatrix, wobei eine „lineare Maske“ zum Einsatz kommt. Was damit gemeint ist, wird im Folgenden klar werden.
• Sei $y=\left(y_1,y_2,\dots ,y_n\right)\in {\mathbb{F}}_2^n$

  

  ein Nachrichtenvektor und n = 2^m - 1. Bei der Syndromberechnung von y werden alle Spalten h_i der zugrundeliegenden Kontrollmatrix für die y_i = 1 gilt berechnet und aufsummiert. Die oben (insbesondere im Verfahren SYN) beschriebene Syndromberechnung geschieht seriell: Es werden der Reihe nach die benötigten Spalten der Kontrollmatrix berechnet und miteinander aufsummiert. Die Idee bei der schnellen Syndromberechnung kann darin gesehen werden, die Spalten der Kontrollmatrix paarweise abzuarbeiten.
• Aufgrund der genannten Beziehungen zwischen der linken und rechten Hälfte der erweiterten Matrix ${\widehat{H}}_1$

  

  genügt es die Spaltenvektoren h_i für die linke Hälfte zu berechnen, also für i = 0,1, ... ,15 im gerade betrachteten Fall und für i = 0,1, ..., 2^m-1 - 1 im allgemeinen Fall. Die Vektoren in der rechten Hälfte der Matrix lassen sich aus denen der linken Hälfte berechnen.
• Man betrachte den allgemeinen Fall eines Codes der Länge n = 2^m - 1, gegeben durch die Funktion F(x₁, ..., x_m), wobei $F:{\mathbb{F}}_2^m\to {\mathbb{F}}_2^l$

  

  ist. Der j-te Spaltenvektor der zugehörigen erweiterten Kontrollmatrix Ĥ₁ hat die Form $$h_j=\left(\begin{array}{c}j\\ F\left(j\right)\end{array}\right)=\left(\begin{array}{c}{j}_1\\ j_2\\ ⋮\\ j_m\\ F_1\left(j_1,\dots ,j_m\right)\\ F_2\left(j_1,\dots ,j_m\right)\\ ⋮\\ F_l\left(j_1,\dots ,j_m\right)\end{array}\right),0\le j\le 2^m-1.$$

  
• In der linken Hälfte der Matrix Ĥ₁ ist die Koordinate j_m konstant 0. Daher können die Spaltenvektoren der linken Hälfte von Ĥ₁ etwas einfacher beschrieben (und deshalb in Hardware etwas effizienter generiert) werden. Sei $$E\left(x_1\mathrm{,...,}{x}_{m-1}\right):=F\left(x_1\mathrm{,...,}{x}_{m-1}\mathrm{,0}\right).$$

  
• Das heißt, $$E\left(x_1\mathrm{,...,}{x}_{m-1}\right)=\left(\begin{array}{c}{E}_1\left(x_1\mathrm{,...,}{x}_{m-1}\right)\\ E_2\left(x_1\mathrm{,...,}{x}_{m-1}\right)\\ ⋮\\ E_l\left(x_1\mathrm{,...,}{x}_{m-1}\right)\end{array}\right)=\left(\begin{array}{c}{F}_1\left(x_1\mathrm{,...,}{x}_{m-1}\mathrm{,0}\right)\\ F_2\left(x_1\mathrm{,...,}{x}_{m-1}\mathrm{,0}\right)\\ ⋮\\ F_l\left(x_1\mathrm{,...,}{x}_{m-1}\mathrm{,0}\right)\end{array}\right).$$

  
• Von nun an werden die Spaltenvektoren h_i = VEK(i) auf der linken Seite der Matrix Ĥ mit SP(i) bezeichnet. Für i = 0,1, ..., 2^m-1 - 1 gilt also $$\text{SP}\left(i\right)=h_i=\left(\stackrel{i}{{\displaystyle E\left(i\right)}}\right)=\left(\begin{array}{c}{i}_1\\ ⋮\\ i_{m-1}\\ 0\\ E_1\left(i_1\mathrm{,...,}{i}_{m-1}\right)\\ ⋮\\ E_1\left(i_1\mathrm{,...,}{i}_{m-1}\right)\end{array}\right)\in {{\displaystyle \mathbb{F}}}_2^{m+l}.$$

  
• Die Spaltenvektoren der rechten Hälfte der Matrix Ĥ₁ können aus denen der linken Hälfte gewonnen werden durch Addition (d.h. koordinatenweisem XOR) einer affinen Maske MA, sodass für i = 0,1, ..., 2^m-1 - 1 gilt $$h_{i+2^{m-1}}=\text{SP}\left(i\right)+\text{MA}\left(i\right).$$

  
• Der Maskenvektor MA(i) hat die Form $$\text{MA}\left(i\right)=\left(\stackrel{2^{m-1}}{{\displaystyle A\left(i\right)}}\right)=\left(\begin{array}{c}0\\ ⋮\\ 0\\ 1\\ A_1\left(i_1\mathrm{,...,}{i}_{m-1}\right)\\ ⋮\\ A_l\left(i_1\mathrm{,...,}{i}_{m-1}\right)\end{array}\right)\in {{\displaystyle \mathbb{F}}}_2^{m+l},$$

  

  wobei $\left(i_1\mathrm{,...,}{i}_{m-1}\right)\in {{\displaystyle \mathbb{F}}}_2^{m-1}$

  

  die Binärdarstellung der ganzen Zahl i ist (d.h. i = i₁ + 2i₂ + ... + 2^m-2i_m-1). Die Funktion A = A(x₁, ..., x_m-1) ist gegeben durch $$A\left(x_1\mathrm{,...,}{x}_{m-1}\right)=F\left(x_1\mathrm{,...,}{x}_{m-1}\mathrm{,1}\right)-F\left(x_{\mathrm{1,...,}{x}_{m-1}}\mathrm{,0}\right).$$

  
• Die Komponentenfunktionen E₁(x₁, ..., x_m-1), ..., E_l(x₁, ..., x_m-1) von E(x₁, ..., x_m-1) sind durchwegs Boolsche Funktionen vom algebraischen Grad ≤ 2. Die Komponentenfunktionen A₁(x₁, ..., x_m-1), ..., A_l(x₁, ... , x_m-1) von A(x₁, ..., x_m-1) sind allesamt Boolsche Funktionen vom algebraischen Grad ≤ 1 (also linear oder affin oder konstant).
• Die schnelle Syndromberechnung kann auch mit höheren Parallelisierungsgraden durchgeführt werden. So kann die Idee der schnellen Syndromberechnung mit dem Parallelisierungsgrad 2 darin gesehen werden, die Spaltenvektoren der Matrix Ĥ (der um den Nullvektor erweiterten Kontrollmatrix H) paarweise abzuarbeiten. Es werden die Paare $\left(h_i,h_{i+2^{m-1}}\right)$

  

  für i = 0,1, ..., 2^m-1 - 1 durchlaufen. Sei y = (y₁, y₂, ..., y_n) der Nachrichtenvektor und ŷ = (y₀, y₁, …, y_n) der verlängerte Nachrichtenvektor mit y₀ = 0. (Es gelte weiterhin n = 2^m - 1). Sei i ∈ {0,1, ..., 2^m-1 - 1} und j = i + 2^m-1.
• Man betrachte $$s=y_i{h}_i+y_j{h}_j.$$

  
• Der Beitrag dieser Summe zum Syndrom Syn(y) hängt von den konkreten Werten von y_i und y_j ab. Bei der Syndromberechnung unterscheidet die Speicherzugriffseinheit 103 vier Fälle:
• Fall 1: (y_i, y_j) = (0,0). Dann ist y_ih_i + y_jh_j = 0.
• Fall 2: (y_i, y_j) = (1,0). Dann ist y_ih_i + y_jh_j = h_i = SP(i).
• Fall 3: (y_i, y_j) = (0,1). Dann ist y_ih_i + y_jh_j = h_j = SP(i) + MA(i).
• Fall 4: (y_i, y_j) = (1,1). Dann ist y_ih_i + y_jh_j = h_i + h_j = MA(i).
• Daraus ergibt sich das folgende Verfahren zur schnellen Syndromberechnung, bezeichnet als „SYN2“.
• SYN2
• Eingabe: $y=\left(y_0,y_1\mathrm{,...,}{y}_n\right)\in {{\displaystyle \mathbb{F}}}_2^{n+1}$
  
• Initialisiere: $s:=0\in {{\displaystyle \mathbb{F}}}_2^{m+1}$
  
• for i from 0 to 2^m-1 - 1 do
• if (y_i, y_j) = (0,0) then s : = s end if;
• if (y_i, y_j) = (1,0) then s : = s + SP(i) end if;
• if (y_i, y_j) = (0,1) then s : = s + SP(i) + MA(i) end if;
• if (y_i, y_j) = (1,1) then s : = s + MA(i) end if;
• end do;
• Ausgabe: s = Syn(y)
• Als Beispiel betrachte man den durch H₁ gegebenen Code, der durch die Funktion $$F\left(v,w,x,y,z\right)=\left(\begin{array}{c}vw+xz\\ vy+wx\\ vx+wz+xy\\ vx+wy+yz\\ vz+wy+wz\end{array}\right)$$

  

  definiert ist. Wenn man in F die Variable z durch 0 ersetzt, erhält man die Funktion $$E\left(v,w,x,y\right)=\left(\begin{array}{c}vw\\ vy+wx\\ vx+xy\\ vx+wy\\ wy\end{array}\right).$$

  
• Wenn man in F in allen Monomen, die z enthalten, die Variable z durch 1 ersetzt, und alle Monome in denen z gar nicht vorkommt, entfernt, dann erhält man die Funktion $$A\left(v,w,x,y\right)=\left(\begin{array}{c}x\\ 0\\ w\\ y\\ v+w\end{array}\right).$$

  
• Mit der Hilfe der Funktionen E und A werden sodann die benötigten Vektoren $$\text{SP}\left(i\right)=\left(\stackrel{i}{{\displaystyle E\left(i\right)}}\right)und\text{ MA}\left(i\right)=\left(\stackrel{16}{{\displaystyle A\left(i\right)}}\right)$$

  

  gebildet. Hier ist i = (i₁, i₂, i₃, i₄) die Binärdarstellung des Index i ∈ {0,1, ... ,15} und $$16=\left(\begin{array}{c}0\\ 0\\ 0\\ 0\\ 1\end{array}\right).$$

  
• Man beachte, dass die Kosten für die Implementierung der Funktionen E(v, w, x, y) und A(v, w, x, y) in Hardware kleiner sind als die für die Funktion F(v, w, x, y, z). Das Ersetzen der Funktion F durch die Funktionen E und A verursacht also keine erhöhten Implementierungskosten.
• Man beachte ferner, dass bei der Syndromberechnung mit SYN der Parameter i die Zahlen von 1 bis 31 durchlaufen muss. Bei der Syndromberechnung mit SYN2 durchläuft der Parameter i die Zahlen von 0 bis 15.
• Man kann SYN2 als eine Art Parallelimplementierung von SYN bezeichnen. Aber es ist nicht nur eine Parallelimplementierung. Bei einer Parallelimplementierung mit dem Parallelisierungsgrad 2, zum Beispiel, möchte man typischerweise, dass ein Wert doppelt so schnell berechnet wird wie mit dem ursprünglichen Verfahren. Typischerweise nimmt man dafür in Kauf, eine doppelt so große Hardware-Fläche zu implementieren und einen doppelt so hohen Stromverbrauch zu haben. Bei dem beschriebenen Verfahren SYN2 erhöhen sich jedoch die Hardwarekosten und der Stromverbrauch nicht oder nur geringfügig.
• Eine noch schnellere Syndromberechnung (Schnelle Syndromberechnung mit Parallelisierungsgrad 4) kann erreicht werden indem man jeweils vier Spalten der Matrix Ĥ gleichzeitig bearbeitet. Man betrachte die erweiterte Matrix Ĥ₁ von Gleichung (6). Sie kann wie folgt in vier Bereiche unterteilt werden: $$\begin{array}{l}{\widehat{H}}_1=\\ \left(\begin{array}{cccc}\begin{array}{cccccccc}0& 1& 0& 1& 0& 1& 0& 1\\ 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 0& 1& 1& 1& 1\end{array}& \begin{array}{cccccccc}0& 1& 0& 1& 0& 1& 0& 1\\ 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 0& 1& 1& 1& 1\end{array}& \begin{array}{cccccccc}0& 1& 0& 1& 0& 1& 0& 1\\ 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 0& 1& 1& 1& 1\end{array}& \begin{array}{cccccccc}0& 1& 0& 1& 0& 1& 0& 1\\ 0& 0& 1& 1& 0& 0& 1& 1\\ 0& 0& 0& 0& 1& 1& 1& 1\end{array}\\ & & & \\ \begin{array}{cccccccc}0& 0& 0& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 0& 0\end{array}& \begin{array}{cccccccc}1& 1& 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 0& 0& 0& 0& 0\end{array}& \begin{array}{cccccccc}0& 0& 0& 0& 0& 0& 0& 0\\ 1& 1& 1& 1& 1& 1& 1& 1\end{array}& \begin{array}{cccccccc}1& 1& 1& 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1& 1& 1& 1\end{array}\\ & & & \\ \begin{array}{cccccccc}0& 0& 0& 1& 0& 0& 0& 1\\ 0& 0& 0& 0& 0& 0& 1& 1\\ 0& 0& 0& 0& 0& 1& 0& 1\\ 0& 0& 0& 0& 0& 1& 0& 1\\ 0& 0& 0& 0& 0& 0& 1& 1\end{array}& \begin{array}{cccccccc}0& 0& 0& 1& 0& 0& 0& 1\\ 0& 1& 0& 1& 0& 1& 1& 0\\ 0& 0& 0& 0& 1& 0& 1& 0\\ 0& 0& 1& 1& 0& 1& 1& 0\\ 0& 0& 1& 1& 0& 0& 1& 1\end{array}& \begin{array}{cccccccc}0& 0& 0& 1& 1& 1& 1& 0\\ 0& 0& 0& 0& 0& 0& 1& 1\\ 0& 0& 1& 1& 0& 1& 1& 0\\ 0& 0& 0& 0& 0& 1& 0& 1\\ 0& 1& 1& 0& 0& 1& 1& 0\end{array}& \begin{array}{cccccccc}0& 0& 0& 1& 1& 1& 1& 0\\ 0& 1& 0& 1& 0& 1& 1& 0\\ 0& 0& 1& 1& 1& 0& 0& 1\\ 1& 1& 0& 0& 1& 0& 0& 1\\ 0& 1& 0& 1& 0& 1& 0& 1\end{array}\end{array}\right)\end{array}$$

  
• Die vier 3 × 8-Teilmatrizen im oberen Bereich der Matrix Ĥ₁ sind untereinander identisch. Die vier 2 × 8-Teilmatrizen in der Mitte enthalten jeweils konstante Spalten. Die zweite, dritte und vierte 5 × 8-Teilmatrix im unteren Bereich ist jeweils eine maskierte Version der ersten 5 × 8-Teilmatrix. Auf der Grundlage dieser speziellen Struktur ergibt sich das unten in Pseudocode angegebene, mit SYN4 bezeichnete Verfahren.
• Sei $$E\left(x_1\mathrm{,...,}{x}_{m-2}\right)\left(\begin{array}{c}{E}_1\left(x_1\mathrm{,...,}{x}_{m-2}\right)\\ E_2\left(x_1\mathrm{,...,}{x}_{m-2}\right)\\ ⋮\\ El\left(x_1\mathrm{,...,}{x}_{m-2}\right)\end{array}\right)=\left(\begin{array}{c}{F}_1\left(x_1\mathrm{,...,}{x}_{m-2}\mathrm{,0,0}\right)\\ F_2\left(x_1\mathrm{,...,}{x}_{m-2}\mathrm{,0,0}\right)\\ ⋮\\ F_1\left(x_1\mathrm{,...,}{x}_{m-2}\mathrm{,0,0}\right)\end{array}\right).$$

  
• Dann gilt für i = 0,1, ..., 2^m-2 - 1 $$\text{SP}\left(i\right)=h_i=\left(\stackrel{i}{{\displaystyle E\left(i\right)}}\right)=\left(\begin{array}{c}{i}_1\\ ⋮\\ i_{m-2}\\ \begin{array}{c}0\\ 0\end{array}\\ E_1\left(i_1\mathrm{,...,}{i}_{m-1}\right)\\ ⋮\\ E_1\left(i_1\mathrm{,...,}{i}_{m-1}\right)\end{array}\right)\in {{\displaystyle \mathbb{F}}}_2^{m+l}.$$

  
• Es werden die zwei folgenden (lineare) Funktionen definiert: $$\begin{array}{c}A\left(x_1\mathrm{,...,}{x}_{m-2}\right)=F\left(x_1\mathrm{,...,}{x}_{m-2}\mathrm{,1,0}\right)-F\left(x_1\mathrm{,...,}{x}_{m-2}\mathrm{,0,0}\right);\\ B\left(x_1\mathrm{,...,}{x}_{m-2}\right)=F\left(x_1\mathrm{,...,}{x}_{m-2}\mathrm{,1,0}\right)-F\left(x_1\mathrm{,...,}{x}_{m-2}\mathrm{,0,0}\right).\end{array}$$

  
• Mit den Funktionen A(x₁, ..., x_m-2) und B(x₁, ..., x_m-2) werden die Maskenvektoren MA(i) und MB(i) berechnet: $$\text{MA}\left(i\right)=\left(\stackrel{2^{m-2}}{{\displaystyle A\left(i\right)}}\right)=\left(\begin{array}{c}\begin{array}{c}0\\ 0\end{array}\\ ⋮\\ 1\\ 0\\ A_1\left(i_1\mathrm{,...,}{i}_{m-2}\right)\\ ⋮\\ A_1\left(i_1\mathrm{,...,}{i}_{m-2}\right)\end{array}\right);$$

  

  $$\text{MB}\left(i\right)=\left(\stackrel{2^{m-1}}{{\displaystyle B\left(i\right)}}\right)=\left(\begin{array}{c}\begin{array}{c}0\\ 0\end{array}\\ ⋮\\ 0\\ 1\\ B_1\left(i_1\mathrm{,...,}{i}_{m-2}\right)\\ ⋮\\ B_1\left(i_1\mathrm{,...,}{i}_{m-2}\right)\end{array}\right),$$

  

  wobei (i₁, ..., i_m-2) die Binärdarstellung der ganzen Zahl i ∈ {0,1, ..., 2^m-2 - ­1} bedeutet.
• Die Spaltenvektoren SP(i) im ersten Viertel der Matrix Ĥ werden gemäß Gleichung (7) berechnet. Die Spaltenvektoren im zweiten, dritten und vierten Viertel der Matrix H erhält man durch $$h_{i=2^{m-2}}=\text{SP}\left(i\right)+\text{MA}\left(i\right);$$

  

  $$h_{i+2^{m-1}}=\text{SP}\left(i\right)+\text{MB}\left(i\right);$$

  

  $$h_{i+3\cdot 2^{m-2}}\text{SP}\left(i\right)+\text{MA}\left(i\right)+\text{MB}\left(i\right)+\text{K}$$

  

  für i = 0,1, ..., 2^m-2 - 1. Dabei ist $\text{K}\in {{\displaystyle \mathbb{F}}}_2^{m+l}$

  

  ein konstanter Vektor (also ein Vektor, der nicht von i abhängt). Und zwar ist $$K:=\left(\begin{array}{c}0\\ ⋮\\ 0\\ k_1\\ ⋮\\ k_l\end{array}\right)\in {{\displaystyle \mathbb{F}}}_2^{m+l}$$

  

  definiert durch k_t = 1 genau dann, wenn die Boolsche Komponentenfunktion F_t(x₁, ..., x_m) das Monom x_m-1x_m enthält (t ∈ {1, ..., l}).
• Sei ŷ = (y₀, y₁, ..., y_n) der verlängerte Nachrichtenvektor mit y₀ = 0 und n = 2^m - 1.
• Für i ∈ {0,1,..., 2^m-2 - 1} wird definiert $$j:=i+1\cdot 2^{m-2},p:=i+2\cdot 2^{m-2},q:=i+3\cdot 2^{m-2}.$$

  
• Für die Syndromberechnung wird für jedes i ∈ {0,1, ..., 2^m-2 - 1} die Summe $$y_i{h}_i+y_j{h}_j+y_p{h}_p+y_q{h}_q$$

  

  berechnet. Die Summe (8) kann 16 mögliche Formen annehmen entsprechend den 16 Möglichkeiten für das Quadrupel $\left(y_i,y_j,y_p,y_q\right)\in {{\displaystyle \mathbb{F}}}_2^4.$

  

  Die 16 möglichen Summenresultate sind in der nachfolgenden Tabelle dargestellt.

  (yi, yj, yp, yq)	yihi + yjhj + yphp + yqhq
  (0,0,0,0)	0
  (0,0,0,1)	SP(i) + MA(i) + MB(i) + K
  (0,0,1,0)	SP(i) + MB(i)
  (0,0,1,1)	MA(i) + K
  (0,1,0,0)	SP(i) + MA(i)
  (0,1,0,1)	MB(i) + K
  (0,1,1,0)	MA(i) + MB(i)
  (0,1,1,1)	SP(i) + K
  (1,0,0,0)	SP(i)
  (1,0,0,1)	MA(i) + MB(i) + K
  (1,0,1,0)	MB(i)
  (1,0,1,1)	SP(i) + MA(i) + K
  (1,1,0,0)	MA(i)
  (1,1,0,1)	SP(i) + MB(i) + K
  (1,1,1,0)	SP(i) + MA(i) + MB(i)
  (1,1,1,1)	K

• Daraus ergibt sich das Verfahren SYN4, das im Folgenden in Pseudocode angegeben ist.
• SYN4
• Eingabe: $y=\left(y_0,y_1\mathrm{,...,}{y}_n\right)\in {{\displaystyle \mathbb{F}}}_2^{n+1}$
  
• Initialisiere: $s:=0\in {{\displaystyle \mathbb{F}}}_2^{m+1}$
  
• for i from 0 to 2^m-2 - 1 do
• if y_iy_jy_py_q = 0000 then s : = s end if;
• if y_iy_jy_py_q = 0001 then s : = s + SP(i) + MA(i) + MB(i) + K end if;
• if y_iy_jy_py_q = 0010 then s : = s + SP(i) + MB(i) end if;
• if y_iy_jy_py_q = 0011 then s : = s + MA(i) + K end if;
• if y_iy_jy_py_q = 0100 then s : = s + SP(i) + MA(i) end if;
• if y_iy_jy_py_q = 0101 then s : = s + MB(i) + K end if;
• if y_iy_jy_py_q = 0110 then s : = s + MA(i) + MB(i) end if;
• if y_iy_jy_py_q = 0111 then s : = s + SP(i) + K end if;
• if y_iy_jy_py_q = 1000 then s : = s + SP(i) end if;
• if y_iy_jy_py_q = 1001 then s : = s + MA(i) + MB(i) + K end if;
• if y_iy_jy_py_q = 1010 then s : = s + MB(i) end if;
• if y_iy_jy_py_q = 1011 then s : = s + SP(i) + MA(i) + K end if;
• if y_iy_jy_py_q = 1100 then s : = s + MA(i) end if;
• if y_iy_jy_py_q = 1101 then s : = s + SP(i) + MB(i) + K end if;
• if y_iy_jy_py_q = 1110 then s : = s + SP(i) + MA(i) + MB(i) end if;
• if y_iy_jy_py_q = 1111 then s : = s + K end if;
• end do;
• Ausgabe: s = Syn(y)
• Als Beispiel wird der Code betrachtet, der durch die Kontrollmatrix H₁ und die Funktion $$F\left(v,w,x,y,z\right)=\left(\begin{array}{c}vw+xz\\ vy+wx\\ vx+wz+xy\\ vx+wy+yz\\ vz+wy+wz\end{array}\right)$$

  

  gegeben ist.
• Die Funktion E(v, w, x) wird erhalten, indem die Variablen y und z gleich 0 gesetzt werden: $$E\left(v,w,x\right)=\left(\begin{array}{c}vw\\ wx\\ vx\\ vx\\ 0\end{array}\right)$$

  
• Die Funktionen A(v, w, x) und B(v, w, x) erhält man durch $$A\left(v,w,x\right)=F\left(v,w,x\mathrm{,1,0}\right)-F\left(v,w,x\mathrm{,0,0}\right)=\left(\begin{array}{c}0\\ v\\ x\\ w\\ w\end{array}\right).$$

  

  und $$B\left(v,w,x\right)=F\left(v,w,x\mathrm{,0,1}\right)-F\left(v,w,x\mathrm{,0,0}\right)=\left(\begin{array}{c}x\\ 0\\ w\\ 0\\ v+w\end{array}\right).$$

  
• Der konstante Vektor K ist $$\text{K=}\left(\begin{array}{c}0\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0\\ 0\\ 1\\ 0\end{array}\right).$$

  
• Die 1 in der neunten Koordinate von K muss gesetzt werden, weil die vierte Komponentenfunktion F₄(v, w, x, y, z) = vx + wy + yz das Monom yz enthält. In den anderen Komponentenfunktionen von F (d.h., in F₁, F₂, F₃ und F₅) kommt dagegen das Monom yz nicht vor. Deshalb ist die sechste, siebente, achte und die zehnte Koordinate von K gleich 0.
• Zusammenfassend wird gemäß verschiedenen Ausführungsformen eine Kodier/Dekodierschaltung bereitgestellt, wie sie in 2 dargestellt ist.
• 2 zeigt eine Schaltung 200 zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code aufweisend eine Syndromberechnungsschaltung 201 zum Berechnen eines Syndroms des Datenworts.
• Die Syndromberechnungsschaltung 201 weist eine Kontrollmatrixberechnungsschaltung 202 auf, die eingerichtet ist, für eine ihr zugeführte Binärdarstellung der Spaltennummer einer Spalte einer Code-Kontrollmatrix des Codes einen Teil-Spaltenvektor auszugeben, der zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet.
• Die Syndromberechnungsschaltung 201 weist ferner eine Akkumulierschaltung 203 auf, die eingerichtet ist, die Spalten der Code-Kontrollmatrix für alle Bits des Datenworts, die gleich 1 sind, zu akkumulieren, wobei sie eingerichtet ist, zumindest einen Teil der Spalten durch Zuführen der Binärdarstellung der Spaltennummer der Spalte zu der Kontrollmatrixberechnungsschaltung und Bilden des Spaltenvektors aus der Binärdarstellung der Spaltennummer und dem von der Kontrollmatrixberechnungsschaltung ausgegebenen Teil-Spaltenvektor zu bilden. Die Akkumulierschaltung 203 ist ferner eingerichtet, das Ergebnis des Akkumulierens als Syndrom auszugeben.
• In anderen Worten werden die Beiträge von Bits in einem Datenwort, zu dem ein Syndrom berechnet werden soll, zum Syndrom berechnet, indem der Kontrollmatrixspaltenvektor für ein Bit aus der dem Spaltenvektor zugeordneten Spaltennummer erzeugt wird. Der Kontrollmatrixspaltenvektor für ein Bit (d.h. der Spaltenvektor der Kontrollmatrix, der zu einem Bit gehört) ist der Spaltenvektor der Kontrollmatrix mit der Position der Spalte in der Kontrollmatrix gleich der Position des Bits im Datenwort (und damit die Spalte mit der Spaltennummer gleich der Bitnummer des Bits, falls die Spalten der Matrix und die Bits des Datenworts gleich nummeriert werden). Der Kontrollmatrixspaltenvektor für ein Bit ist also der Spaltenvektor der Kontrollmatrix, mit der das Bit multipliziert wird, wenn das Datenwort (von rechts) mit der Kontrollmatrix multipliziert wird.
• Der Teil-Spaltenvektor der Kontrollmatrix, der zusammen mit der Spaltennummer des Spaltenvektors den Spaltenvektor bildet, ist durch eine (z.B. quadratische) Kombination der Bits der Spaltennummern gegeben.
• Eine der Erfindung zu Grunde liegende Idee kann somit darin gesehen werden, einen linearen (binären) Code zur Fehlerdetektion und Fehlerkorrektur zu verwenden, dessen zugehörige Kontrollmatrix eine formelhafte Beschreibung zulässt. Dann muss die Kontrollmatrix nicht explizit bereitgestellt werden (z.B. in einem Speicher der Schaltung 200 gespeichert werden), sondern sie ist implizit durch den formelhaften Ausdruck (d.h. die formelhafte Beschreibung) gegeben. Gemäß einer Ausführungsform werden alle erforderlichen Operationen, wie z.B. die Codierung, Syndromberechnung und Decodierung mittels Manipulationen mit einzelnen Spalten der Kontrollmatrix bewerkstelligt, wobei zu jedem Zeitpunkt immer nur eine Spalte der Kontrollmatrix benötigt wird. Entsprechend werden gemäß einer Ausführungsform die benötigten Spalten der relevanten Kontrollmatrix aus ihrem formelhaften Ausdruck bei Bedarf („on the fly“) berechnet und genutzt.
• Die Herangehensweise von 2 ermöglicht eine beschleunigte Fehlerkorrektur: Die Einbitfehlerkorrektur ist praktisch gleich aufwändig wie die (immer notwendige) Syndromberechnung. Die Zweibitfehlerkorrektur erfordert nur n Spaltenoperationen (gegenüber n(n-1)/2 für einen allgemeinen linearen Code). Und die Dreibitfehlerkorrektur erfordert nur n(n-2)/2 Operationen (gegenüber n(n-1)(n-2)/6 Operation für den allgemeinen linearen Code der Länge n.)
• Insbesondere im Vergleich mit der Verwendung von zyklischen Codes, die auch ohne explizite Hinterlegung einer Kontrollmatrix verwendet werden können, ermöglicht die Herangehensweise von 2 eine Implementierung mit deutlich reduzierter Komplexität, da für zyklische Codes sehr aufwändige Berechnungen erforderlich sind.
• 3 zeigt ein Ablaufdiagramm 300, das ein Verfahren zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code veranschaulicht.
• In dem Verfahren wird das Syndrom des Datenworts in 301 berechnet.
• Dabei wird in 302 von einer Kontrollmatrixberechnungsschaltung für eine ihr zugeführte Binärdarstellung der Spaltennummer einer Spalte einer Code-Kontrollmatrix des Codes ein Teil-Spaltenvektor ausgegeben, der zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet.
• Die Spalten der Code-Kontrollmatrix für alle Bits des Datenworts, die gleich 1 sind, werden in 304 akkumuliert, wobei zumindest ein Teil der Spalten durch Zuführen der Binärdarstellung der Spaltennummer der Spalte zu der Kontrollmatrixberechnungsschaltung und Bilden, in 303, des Spaltenvektors aus der Binärdarstellung der Spaltennummer und einem von der Kontrollmatrixberechnungsschaltung in 302 ausgegebenen Teil-Spaltenvektor gebildet werden.
• In 305 wird das Ergebnis des Akkumulierens als Syndrom ausgegeben.
• Im Folgenden werden verschiedene Ausführungsbeispiele angegeben.
• Ausführungsbeispiel 1 ist eine Schaltung zum Kodieren oder Dekodieren eines Datenworts, wie sie mit Bezug auf 2 beschrieben ist, wobei die Kontrollmatrixberechnungsschaltung eingerichtet ist, den Teil-Spaltenvektor durch eine quadratische Kombination der Bits der Binärdarstellung der Spaltennummer zu erzeugen.
• Ausführungsbeispiel 3 ist die Schaltung gemäß Ausführungsbeispiel 1 oder 2, wobei die Kontrollmatrixberechnungsschaltung für jede Zeile des Teil-Spaltenvektors eine jeweilige mittels Logik-Gattern in Hardware realisierte Boolesche Funktion zur Berechnung der Komponente des Teil-Spaltenvektors aus der Binärdarstellung der Spaltennummer aufweist.
• Ausführungsbeispiel 4 ist die Schaltung gemäß einem der Ausführungsbeispiele 1 bis 3, wobei der Teil-Spaltenvektor zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet, wenn er daran angehängt ist.
• Ausführungsbeispiel 5 ist die Schaltung gemäß einem der Ausführungsbeispiele 1 bis 4, wobei das Datenwort ein zu kodierendes Datenwort ist.
• Ausführungsbeispiel 6 ist die Schaltung gemäß Ausführungsbeispiel 5, wobei das Datenwort über einen Kommunikationskanal zu übertragende Daten aufweist oder in einem Speicher zu speichernde Daten aufweist.
• Ausführungsbeispiel 7 ist die Schaltung gemäß Ausführungsbeispiel 5 oder 6, wobei die Schaltung eine Kodierschaltung zum Kodieren des Datenworts aufweist, wobei die Kodierschaltung eingerichtet ist, aus dem Datenwort durch Einfügen von Positionen für Kontrollbits ein erweitertes Datenwort zu erzeugen, wobei sie die Positionen für die Kontrollbits mit Null initialisiert, das erweiterte Datenwort der Syndromberechnungsschaltung zur Berechnung des Syndroms des erweiterten Datenworts zuzuführen und die Kontrollbits aus dem von der Syndromberechnungsschaltung berechneten Syndrom des erweiterten Datenworts zu berechnen.
• Ausführungsbeispiel 8 ist die Schaltung gemäß Ausführungsbeispiel 7, wobei die Kodierschaltung eingerichtet ist, die Kontrollbits durch Multiplikation des Syndroms des erweiterten Datenworts mit der Inversen der aus den Spalten der Kontrollmatrix zu den Positionen der Datenbits in dem erweiterten Datenwort gebildeten Matrix zu berechnen.
• Ausführungsbeispiel 9 ist die Schaltung gemäß einem der Ausführungsbeispiele 1 bis 4, wobei das Datenwort ein zu dekodierendes Datenwort ist.
• Ausführungsbeispiel 10 ist die Schaltung gemäß Ausführungsbeispiel 9, wobei das Datenwort ein über einen Kommunikationskanal empfangenes Nachrichtenwort ist oder ein aus einem Speicher ausgelesenes Datenwort ist.
• Ausführungsbeispiel 11 ist die Schaltung gemäß Ausführungsbeispiel 9 oder 10, wobei die Schaltung eine Dekodierschaltung zum Dekodieren des Datenworts aufweist, wobei die Dekodierschaltung eingerichtet ist, das Datenwort der Syndromberechnungsschaltung zuzuführen, zu ermitteln, ob das von der Syndromberechnungsschaltung berechnete Syndrom gleich dem Nullvektor ist und festzustellen, dass ein Fehler aufgetreten ist, wenn das Syndrom ungleich dem Nullvektor ist.
• Ausführungsbeispiel 12 ist die Schaltung gemäß Ausführungsbeispiel 11, wobei die Dekodierschaltung eingerichtet ist, die Position von ein oder mehreren Fehlern in dem Datenwort aus dem von der Syndromberechnungsschaltung berechneten Syndrom zu ermitteln.
• Ausführungsbeispiel 13 ist die Schaltung gemäß einem der Ausführungsbeispiele 1 bis 12, wobei die Akkumulierschaltung eingerichtet ist, Bits des Datenworts abzuarbeiten, indem sie für jedes Bit überprüft, ob das Bit gleich 1 ist und, wenn das Bit gleich 1 ist, einen entsprechenden Beitrag des Bits zum Syndrom in der Akkumulierung zu berücksichtigen.
• Ausführungsbeispiel 14 ist die Schaltung gemäß einem der Ausführungsbeispiele 1 bis 13, wobei die Akkumulierschaltung, eingerichtet ist, die Bits des Datenworts der Code-Kontrollmatrix in Paaren abzuarbeiten, wobei sie eingerichtet ist, je nach Kombination der Werte des Bits des Datenworts einen entsprechenden Beitrag des Paars von Bits zum Syndrom in der Akkumulierung zu berücksichtigen.
• Ausführungsbeispiel 15 ist die Schaltung gemäß Ausführungsbeispiel 14, wobei die Paare von Bits, die gemeinsam abgearbeitet werden, Paare von Bits sind, zu denen Spalten der Kontrollmatrix gehören, deren Spaltennummern bis auf eine vorgegebene Stelle gleich sind.
• Ausführungsbeispiel 16 ist die Schaltung gemäß einem der Ausführungsbeispiele 1 bis 13, wobei die Akkumulierschaltung, eingerichtet ist, die Bits des Datenworts der Code-Kontrollmatrix in Viertupeln abzuarbeiten, wobei sie eingerichtet ist, je nach Kombination der Werte des Bits des Datenworts einen entsprechenden Beitrag des Viertupels von Bits zum Syndrom in der Akkumulierung zu berücksichtigen.
• Ausführungsbeispiel 17 ist die Schaltung gemäß Ausführungsbeispiel 16, wobei die Viertupel von Bits, die gemeinsam abgearbeitet werden, Viertupel von Bits sind, zu denen Spalten der Kontrollmatrix gehören, deren Spaltennummern bis auf zwei vorgegebene Stellen gleich sind.
• Ausführungsbeispiel 18 ist die Schaltung gemäß einem der Ausführungsbeispiele 14 bis 17, wobei die Akkumulierschaltung eingerichtet ist, den Beitrag eines Paares oder eines Viertupels von Bits zum Syndrom für zumindest einen Teil von Wertkombinationen der Bits des Paares oder des Viertupels mittels einer Maske, die den Unterschied zwischen den Beiträgen von zwei Bits des Paares oder Viertupels, die gleich eins sind, zum Syndrom angibt, zu ermitteln.
• Ausführungsbeispiel 19 ist ein Verfahren zum Kodieren oder Dekodieren eines Datenworts, wie es mit Bezug auf 3 beschrieben ist, wobei die Kontrollmatrixberechnungsschaltung den Teil-Spaltenvektor durch eine quadratische Kombination der Bits der Binärdarstellung der Spaltennummer erzeugt.
• Ausführungsbeispiel 21 ist das Verfahren gemäß Ausführungsbeispiel 19 oder 20, wobei die Kontrollmatrixberechnungsschaltung für jede Zeile des Teil-Spaltenvektors eine jeweilige Boolesche Funktion zur Berechnung der Komponente des Teil-Spaltenvektors aus der Binärdarstellung der Spaltennummer mittels Logik-Gattern in Hardware realisiert.
• Ausführungsbeispiel 22 ist das Verfahren gemäß einem der Ausführungsbeispiele 19 bis 21, wobei der Teil-Spaltenvektor zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet, wenn er daran angehängt ist.
• Ausführungsbeispiel 23 ist das Verfahren gemäß einem der Ausführungsbeispiele 19 bis 22, wobei das Datenwort ein zu kodierendes Datenwort ist.
• Ausführungsbeispiel 24 ist das Verfahren gemäß Ausführungsbeispiel 23, wobei das Datenwort über einen Kommunikationskanal zu übertragende Daten aufweist oder in einem Speicher zu speichernde Daten aufweist.
• Ausführungsbeispiel 25 ist das Verfahren gemäß Ausführungsbeispiel 23 oder 24, aufweisend Kodieren des Datenworts, wobei die aus dem Datenwort durch Einfügen von Positionen für Kontrollbits ein erweitertes Datenwort erzeugt wird, wobei die Positionen für die Kontrollbits mit Null initialisiert werden, das erweiterte Datenwort einer Syndromberechnungsschaltung zur Berechnung des Syndroms des erweiterten Datenworts zugeführt wird und die Kontrollbits aus dem von der Syndromberechnungsschaltung berechneten Syndrom des erweiterten Datenworts berechnet werden.
• Ausführungsbeispiel 26 ist das Verfahren gemäß Ausführungsbeispiel 25, aufweisend Berechnen der Kontrollbits durch Multiplikation des Syndroms des erweiterten Datenworts mit der Inversen der aus den Spalten der Kontrollmatrix zu den Positionen der Datenbits in dem erweiterten Datenwort gebildeten Matrix.
• Ausführungsbeispiel 27 ist das Verfahren gemäß einem der Ausführungsbeispiele 19 bis 22, wobei das Datenwort ein zu dekodierendes Datenwort ist.
• Ausführungsbeispiel 28 ist das Verfahren gemäß Ausführungsbeispiel 27, wobei das Datenwort ein über einen Kommunikationskanal empfangenes Nachrichtenwort ist oder ein aus einem Speicher ausgelesenes Datenwort ist.
• Ausführungsbeispiel 29 ist das Verfahren gemäß Ausführungsbeispiel 27 oder 28, aufweisend Dekodieren des Datenworts, wobei das Datenwort einer Syndromberechnungsschaltung zugeführt wird, ermitteln wird, ob das von der Syndromberechnungsschaltung berechnete Syndrom gleich dem Nullvektor ist und festgestellt wird, dass ein Fehler aufgetreten ist, wenn das Syndrom ungleich dem Nullvektor ist.
• Ausführungsbeispiel 30 ist das Verfahren gemäß Ausführungsbeispiel 29, aufweisend Ermitteln der Position von ein oder mehreren Fehlern in dem Datenwort aus dem von der Syndromberechnungsschaltung berechneten Syndrom.
• Ausführungsbeispiel 31 ist das Verfahren gemäß einem der Ausführungsbeispiele 19 bis 30, aufweisend Abarbeiten von Bits des Datenworts abzuarbeiten, indem für jedes Bit überprüft wird, ob das Bit gleich 1 ist und, wenn das Bit gleich 1 ist, ein entsprechender Beitrag des Bits zum Syndrom in der Akkumulierung berücksichtigt wird.
• Ausführungsbeispiel 32 ist das Verfahren gemäß einem der Ausführungsbeispiele 19 bis 31, aufweisend Abarbeiten der Bits des Datenworts der Code-Kontrollmatrix in Paaren, wobei je nach Kombination der Werte des Bits des Datenworts ein entsprechender Beitrag des Paars von Bits zum Syndrom in der Akkumulierung berücksichtigt wird.
• Ausführungsbeispiel 33 ist das Verfahren gemäß Ausführungsbeispiel 32, wobei die Paare von Bits, die gemeinsam abgearbeitet werden, Paare von Bits sind, zu denen Spalten der Kontrollmatrix gehören, deren Spaltennummern bis auf eine vorgegebene Stelle gleich sind.
• Ausführungsbeispiel 34 ist das Verfahren gemäß einem der Ausführungsbeispiele 19 bis 31, aufweisend Abarbeiten der Bits des Datenworts der Code-Kontrollmatrix in Viertupeln, wobei je nach Kombination der Werte des Bits des Datenworts ein entsprechender Beitrag des Viertupels von Bits zum Syndrom in der Akkumulierung berücksichtigt wird.
• Ausführungsbeispiel 35 ist das Verfahren gemäß Ausführungsbeispiel 34, wobei die Viertupel von Bits, die gemeinsam abgearbeitet werden, Viertupel von Bits sind, zu denen Spalten der Kontrollmatrix gehören, deren Spaltennummern bis auf zwei vorgegebene Stellen gleich sind.
• Ausführungsbeispiel 36 ist das Verfahren gemäß einem der Ausführungsbeispiele 32 bis 35, aufweisend Ermitteln des Beitrags eines Paares oder eines Viertupels von Bits zum Syndrom für zumindest einen Teil von Wertkombinationen der Bits des Paares oder des Viertupels mittels einer Maske, die den Unterschied zwischen den Beiträgen von zwei Bits des Paares oder Viertupels, die gleich eins sind, zum Syndrom angibt.
• Gemäß einem weiteren Ausführungsbeispiel wird eine Schaltung zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code bereitgestellt, die Syndromberechnungsmittel zum Berechnen eines Syndroms des Datenworts aufweist, wobei die Syndromberechnungsmittel aufweisen:
• Kontrollmatrixberechnungsmittel zum Ausgeben, für eine ihnen zugeführte Binärdarstellung der Spaltennummer einer Spalte einer Code-Kontrollmatrix des Codes, eines Teil-Spaltenvektors, der zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet;
• Akkumuliermittel zum Akkumulieren der Spalten der Code-Kontrollmatrix für alle Bits des Datenworts, die gleich 1 sind, wobei die Akkumuliermittel zum Bilden zumindest eines Teils der Spalten durch Zuführen der Binärdarstellung der Spaltennummer der Spalte zu der Kontrollmatrixberechnungsschaltung und Bilden des Spaltenvektors aus der Binärdarstellung der Spaltennummer und dem von der Kontrollmatrixberechnungsschaltung ausgegebenen Teil-Spaltenvektor und zum Ausgeben des Ergebnisses des Akkumulierens als Syndrom sind.
• Die Komponenten der Schaltung zum Kodieren oder Dekodieren können durch ein oder mehrere Schaltkreise realisiert sein. In einer Ausführungsform ist ein „Schaltkreis“ als jegliche Einheit zu verstehen, die eine Logik implementiert, und die sowohl Hardware, Software, Firmware oder eine Kombination daraus sein kann. Somit kann ein „Schaltkreis“ in einer Ausführungsform ein hart-verdrahteter Logik-Schaltkreis oder ein programmierbarer Logik-Schaltkreis sein, wie beispielsweise ein programmierbarer Prozessor. Unter einem „Schaltkreis“ kann auch ein Prozessor, der Software ausführt, zu verstehen sein, z.B. jegliche Art von Computer-Programm. Unter einem „Schaltkreis“ kann in einer Ausführungsform jegliche Art der Implementierung der hierin beschriebenen Funktionen zu verstehen sein. Gemäß einer Ausführungsform wird die Schaltung zum Kodieren oder Dekodieren jedoch in Form fest-verdrahteter Hardware-Schaltungen realisiert, sodass die Schaltung zum Kodieren oder Dekodieren frei von einem programmierbaren Prozessor (zumindest frei von einem General Purpose Processor, d.h. Universalprozessor) implementiert wird. Insbesondere wird gemäß einer Ausführungsform die Kontrollmatrixberechnungsschaltung mittels hart-verdrahteter Schaltelemente implementiert, beispielsweise durch mehrere Anordnungen von Logik-Gattern, wobei jede Logik-Gatter-Anordnung eine Funktion realisiert, die eine Komponente der Teil-Spaltenvektoren (also eine Komponente der Funktion F in Gleichung (1)) berechnet.
• Obwohl die Erfindung vor allem unter Bezugnahme auf bestimmte Ausführungsformen gezeigt und beschrieben wurde, sollte es von denjenigen, die mit dem Fachgebiet vertraut sind, verstanden werden, dass zahlreiche Änderungen bezüglich Ausgestaltung und Details daran vorgenommen werden können, ohne vom Wesen und Bereich der Erfindung, wie er durch die nachfolgenden Ansprüche definiert wird, abzuweichen. Der Bereich der Erfindung wird daher durch die angefügten Ansprüche bestimmt, und es ist beabsichtigt, dass sämtliche Änderungen, welche unter den Wortsinn oder den Äquivalenzbereich der Ansprüche fallen, umfasst werden.
• Bezugszeichenliste

100

Datenverarbeitungsvorrichtung

101

Datenverarbeitungseinheit 101

102

Speicher

103

Speicherzugriffsschaltung

104

Kodierer

105

Dekodierer

200

Kodier/Dekodierschaltung

201

Syndromberechnungsschaltung

202

Kontrollmatrixberechnungsschaltung

203

Akkumulierschaltung

300

Ablaufdiagramm

301-305

Ablaufschritte

Claims (18)

1. Schaltung zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code aufweisend eine Syndromberechnungsschaltung zum Berechnen eines Syndroms des Datenworts, wobei die Syndromberechnungsschaltung aufweist: Eine Kontrollmatrixberechnungsschaltung, die eingerichtet ist, für eine ihr zugeführte Binärdarstellung der Spaltennummer einer Spalte einer Code-Kontrollmatrix des Codes einen Teil-Spaltenvektor auszugeben, der zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet, wobei die Kontrollmatrixberechnungsschaltung eingerichtet ist, den Teil-Spaltenvektor durch eine quadratische Kombination der Bits der Binärdarstellung der Spaltennummer zu erzeugen; Eine Akkumulierschaltung, die eingerichtet ist, die Spalten der Code-Kontrollmatrix für alle Bits des Datenworts, die gleich 1 sind, zu akkumulieren, wobei sie eingerichtet ist, zumindest einen Teil der Spalten durch Zuführen der Binärdarstellung der Spaltennummer der Spalte zu der Kontrollmatrixberechnungsschaltung und Bilden des Spaltenvektors aus der Binärdarstellung der Spaltennummer und dem von der Kontrollmatrixberechnungsschaltung ausgegebenen Teil-Spaltenvektor zu bilden; und das Ergebnis des Akkumulierens als Syndrom auszugeben.
2. Schaltung gemäß Anspruch 1, wobei die Kontrollmatrixberechnungsschaltung für jede Zeile des Teil-Spaltenvektors eine jeweilige mittels Logik-Gattern in Hardware realisierte Boolesche Funktion zur Berechnung der Komponente des Teil-Spaltenvektors aus der Binärdarstellung der Spaltennummer aufweist.
3. Schaltung gemäß einem der Ansprüche 1 bis 2, wobei der Teil-Spaltenvektor zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet, wenn er daran angehängt ist.
4. Schaltung gemäß einem der Ansprüche 1 bis 3, wobei das Datenwort ein zu kodierendes Datenwort ist.
5. Schaltung gemäß Anspruch 4, wobei das Datenwort über einen Kommunikationskanal zu übertragende Daten aufweist oder in einem Speicher zu speichernde Daten aufweist.
6. Schaltung gemäß Anspruch 4 oder 5, wobei die Schaltung eine Kodierschaltung zum Kodieren des Datenworts aufweist, wobei die Kodierschaltung eingerichtet ist, aus dem Datenwort durch Einfügen von Positionen für Kontrollbits ein erweitertes Datenwort zu erzeugen, wobei sie die Positionen für die Kontrollbits mit Null initialisiert, das erweiterte Datenwort der Syndromberechnungsschaltung zur Berechnung des Syndroms des erweiterten Datenworts zuzuführen und die Kontrollbits aus dem von der Syndromberechnungsschaltung berechneten Syndrom des erweiterten Datenworts zu berechnen.
7. Schaltung gemäß Anspruch 6, wobei die Kodierschaltung eingerichtet ist, die Kontrollbits durch Multiplikation des Syndroms des erweiterten Datenworts mit der Inversen der aus den Spalten der Kontrollmatrix zu den Positionen der Datenbits in dem erweiterten Datenwort gebildeten Matrix zu berechnen.
8. Schaltung gemäß einem der Ansprüche 1 bis 3, wobei das Datenwort ein zu dekodierendes Datenwort ist.
9. Schaltung gemäß Anspruch 8, wobei das Datenwort ein über einen Kommunikationskanal empfangenes Nachrichtenwort ist oder ein aus einem Speicher ausgelesenes Datenwort ist.
10. Schaltung gemäß Anspruch 8 oder 9, wobei die Schaltung eine Dekodierschaltung zum Dekodieren des Datenworts aufweist, wobei die Dekodierschaltung eingerichtet ist, das Datenwort der Syndromberechnungsschaltung zuzuführen, zu ermitteln, ob das von der Syndromberechnungsschaltung berechnete Syndrom gleich dem Nullvektor ist und festzustellen, dass ein Fehler aufgetreten ist, wenn das Syndrom ungleich dem Nullvektor ist.
11. Schaltung gemäß Anspruch 10, wobei die Dekodierschaltung eingerichtet ist, die Position von ein oder mehreren Fehlern in dem Datenwort aus dem von der Syndromberechnungsschaltung berechneten Syndrom zu ermitteln.
12. Schaltung gemäß einem der Ansprüche 1 bis 11, wobei die Akkumulierschaltung eingerichtet ist, Bits des Datenworts abzuarbeiten, indem sie für jedes Bit überprüft, ob das Bit gleich 1 ist und, wenn das Bit gleich 1 ist, einen entsprechenden Beitrag des Bits zum Syndrom in der Akkumulierung zu berücksichtigen.
13. Schaltung gemäß einem der Ansprüche 1 bis 12, wobei die Akkumulierschaltung, eingerichtet ist, die Bits des Datenworts der Code-Kontrollmatrix in Paaren abzuarbeiten, wobei sie eingerichtet ist, je nach Kombination der Werte des Bits des Datenworts einen entsprechenden Beitrag des Paars von Bits zum Syndrom in der Akkumulierung zu berücksichtigen.
14. Schaltung gemäß Anspruch 13, wobei die Paare von Bits, die gemeinsam abgearbeitet werden, Paare von Bits sind, zu denen Spalten der Kontrollmatrix gehören, deren Spaltennummern bis auf eine vorgegebene Stelle gleich sind.
15. Schaltung gemäß einem der Ansprüche 1 bis 12, wobei die Akkumulierschaltung, eingerichtet ist, die Bits des Datenworts der Code-Kontrollmatrix in Viertupeln abzuarbeiten, wobei sie eingerichtet ist, je nach Kombination der Werte des Bits des Datenworts einen entsprechenden Beitrag des Viertupels von Bits zum Syndrom in der Akkumulierung zu berücksichtigen.
16. Schaltung gemäß Anspruch 15, wobei die Viertupel von Bits, die gemeinsam abgearbeitet werden, Viertupel von Bits sind, zu denen Spalten der Kontrollmatrix gehören, deren Spaltennummern bis auf zwei vorgegebene Stellen gleich sind.
17. Schaltung gemäß einem der Ansprüche 13 bis 16, wobei die Akkumulierschaltung eingerichtet ist, den Beitrag eines Paares oder eines Viertupels von Bits zum Syndrom für zumindest einen Teil von Wertkombinationen der Bits des Paares oder des Viertupels mittels einer Maske, die den Unterschied zwischen den Beiträgen von zwei Bits des Paares oder Viertupels, die gleich eins sind, zum Syndrom angibt, zu ermitteln.
18. Verfahren zum Kodieren oder Dekodieren eines Datenworts gemäß einem linearen Code aufweisend: Berechnen eines Syndroms des Datenworts, wobei eine Kontrollmatrixberechnungsschaltung für eine ihr zugeführte Binärdarstellung der Spaltennummer einer Spalte einer Code-Kontrollmatrix des Codes einen Teil-Spaltenvektor ausgibt, der zusammen mit der Binärdarstellung der Spaltennummer die Spalte der Code-Kontrollmatrix bildet, wobei die Kontrollmatrixberechnungsschaltung den Teil-Spaltenvektor durch eine quadratische Kombination der Bits der Binärdarstellung der Spaltennummer erzeugt; die Spalten der Code-Kontrollmatrix für alle Bits des Datenworts, die gleich 1 sind, akkumuliert werden, wobei zumindest einen Teil der Spalten durch Zuführen der Binärdarstellung der Spaltennummer der Spalte zu der Kontrollmatrixberechnungsschaltung und Bilden des Spaltenvektors aus der Binärdarstellung der Spaltennummer und einer von der Kontrollmatrixberechnungsschaltung ausgegebenen Teil-Spaltenvektor gebildet werden, und wobei das Ergebnis des Akkumulierens als Syndrom ausgegeben wird.

Images