Aufgaben:Exercise 2.10Z: Code Rate and Minimum Distance: Difference between revisions

From LNTwww
No edit summary
Noah (talk | contribs)
No edit summary
Line 1: Line 1:
{{quiz-Header|Buchseite=Kanalcodierung/Definition und Eigenschaften von Reed–Solomon–Codes}}
{{quiz-Header|Buchseite=Channel_Coding/Definition_and_Properties_of_Reed-Solomon_Codes}}


[[File:P_ID2526__KC_Z_2_10.png|right|frame|Die beiden Erfinder der Reed–Solomon–Codes]]
[[File:P_ID2526__KC_Z_2_10.png|right|frame|The two inventors of the Reed-Solomon codes]]
Die von  [https://de.wikipedia.org/wiki/Irving_Stoy_Reed Irving Stoy Reed]  und  [https://de.wikipedia.org/wiki/Gustave_Solomon Gustave Solomon]  Anfang der 1960er Jahre entwickelten Codes werden in diesem Tutorial wie folgt bezeichnet:  
The codes developed by  [https://en.wikipedia.org/wiki/Irving_S._Reed "Irving Stoy Reed"]  and  [https://en.wikipedia.org/wiki/Gustave_Solomon "Gustave Solomon"]  in the early 1960s are referred to in this tutorial as follows:  
:$${\rm RSC} \, (n, \, k, \, d_{\rm min}) _q.$$   
:$${\rm RSC} \, (n, \, k, \, d_{\rm min}) _q.$$   


Die Codeparameter haben folgende Bedeutungen:
The code parameters have the following meanings:
* $q = 2^m$  ist ein Hinweis auf die Größe des Galoisfeldes   ⇒   ${\rm GF}(q)$,
* $q = 2^m$  is an indication of the size of the Galois field   ⇒   ${\rm GF}(q)$,
* $n = q - 1$  ist die Codelänge (Symbolanzahl eines Codewortes),  
* $n = q - 1$  is the code length (symbol number of a code word),  
* $k$  gibt die Dimension an (Symbolanzahl eines Informationsblocks),
* $k$  indicates the dimension (symbol number of an information block),
* $d_{\rm min}$  bezeichnet die minimale Distanz zwischen zwei Codeworten. Für jeden Reed–Solomon–Codes gilt  $d_{\rm min} = n - k + 1$.
* $d_{\rm min}$  denotes the minimum distance between two codewords. For any Reed-Solomon code, $d_{\rm min} = n - k + 1$.
*Mit keinem anderen Code mit gleichem  $k$  und  $n$  ergibt sich ein größerer Wert.
*No other code with the same  $k$  and  $n$  yields a larger value.




Line 19: Line 19:




Hints:
* The exercise belongs to the chapter  [[Channel_Coding/Definition_and_Properties_of_Reed-Solomon_Codes| "Definition and properties of Reed–Solomon Codes"]].
* Information relevant to this exercise can be found on the  [[Channel_Coding/Definition_and_Properties_of_Reed-Solomon_Codes#Code_name_and_code_rate|Code name and code rate]] page.


''Hinweise:''
* Die Aufgabe gehört zum Kapitel  [[Channel_Coding/Definition_und_Eigenschaften_von_Reed%E2%80%93Solomon%E2%80%93Codes| Definition und Eigenschaften von Reed–Solomon–Codes]].
* Die für diese Aufgabe relevanten Informationen finden Sie auf der Seite  [[Channel_Coding/Definition_und_Eigenschaften_von_Reed%E2%80%93Solomon%E2%80%93Codes#Codebezeichnung_und_Coderate|Codebezeichnung und Coderate]].








 
===Questions===
===Fragebogen===
<quiz display=simple>
<quiz display=simple>
{Geben Sie die Kenngrößen des&nbsp; ${\rm RSC} \, (255, \, 223, \, d_{\rm min})_q$&nbsp; an.
{Specify the characteristics of the&nbsp; ${\rm RSC} \, (255, \, 223, \, d_{\rm min})_q$&nbsp;.
|type="{}"}
|type="{}"}
$q \hspace{0.2cm} = \ ${ 256 }
$q \hspace{0.2cm} = \ ${ 256 }
Line 38: Line 37:
$d_{\rm min} \ = \ ${ 33 }
$d_{\rm min} \ = \ ${ 33 }


{Geben Sie die Kenngrößen des&nbsp; $\rm RSC \, (2040, \, 1784, \, d_{\rm min})_2$&nbsp; an.
{Specify the characteristics of the&nbsp; $\rm RSC \, (2040, \, 1784, \, d_{\rm min})_2$&nbsp;.
|type="{}"}
|type="{}"}
$R \hspace{0.2cm} = \ ${ 0.8745 3% }
$R \hspace{0.2cm} = \ ${ 0.8745 3% }
$d_{\rm min} \ = \ ${ 33 }
$d_{\rm min} \ = \ ${ 33 }


{Wieviele Bitfehler&nbsp; $(N_3)$&nbsp; darf ein Empfangswort&nbsp; $\underline{y}$&nbsp; maximal aufweisen, damit es <u>mit Sicherheit richtig decodiert wird</u>?
{How many bit errors&nbsp; $(N_3)$&nbsp; may a received word&nbsp; $\underline{y}$&nbsp; have at most, so that it is <u>certainly decoded correctly</u>?
|type="{}"}
|type="{}"}
$N_{3} \ = \ $ { 16 }
$N_{3} \ = \ $ { 16 }


{Wieviele Bitfehler&nbsp; $(N_4)$&nbsp; darf ein Empfangswort&nbsp; $\underline{y}$&nbsp; im günstigsten Fall aufweisen, damit es noch <u>richtig decodiert werden könnte</u>?
{How many bit errors&nbsp; $(N_4)$&nbsp; may a received word&nbsp; $\underline{y}$&nbsp; have in the best case so that it could still be <u>correctly decoded</u>?
|type="{}"}
|type="{}"}
$N_{4} \ = \ $ { 128 }
$N_{4} \ = \ $ { 128 }
</quiz>
</quiz>


===Musterlösung===
===Solution===
{{ML-Kopf}}
{{ML-Kopf}}
'''(1)'''&nbsp; Aus der Codelänge $n = 255$ folgt $q \ \underline{= 256}$.  
'''(1)'''&nbsp; From the code length $n = 255$ follows $q \ \underline{= 256}$.  


*Die Coderate ergibt sich zu $R = {223}/{255} \hspace{0.15cm}\underline {=0.8745}\hspace{0.05cm}.$
*The code rate is given by $R = {223}/{255} \hspace{0.15cm}\underline {=0.8745}\hspace{0.05cm}.$


*Die minimale Distanz beträgt $d_{\rm min} = n - k +1 = 255 - 223 +1  
*The minimum distance is $d_{\rm min} = n - k +1 = 255 - 223 +1  
  \hspace{0.15cm}\underline {=33}\hspace{0.05cm}.$
  \hspace{0.15cm}\underline {=33}\hspace{0.05cm}.$


*Damit können
*This allows
:* $e = d_{\rm min} - 1 \ \underline{= 32}$ Symbolfehler erkannt werden, und
:* $e = d_{\rm min} - 1 \ \underline{= 32}$ symbol errors can be detected, and.
:* $t = e/2$ (abgerundet), also $\underline{t = 16}$ Symbolfehler korrigiert werden.
:* $t = e/2$ (rounded down), so $\underline{t = 16}$ symbol errors can be corrected.
 




'''(2)'''&nbsp; Der Code $\rm RSC \, (2040, \, 1784, \, d_{\rm min})_2$ ist die Binärrepräsentation des unter (1) behandelten ${\rm RSC} \, (255, \, 223, \, 33)_{256}$ mit genau der gleichen Coderate $R \ \underline{= 0.8745}$ und ebenfalls gleicher Minimaldistanz $d_{\rm min} \ \underline{= 33}$ wie dieser. Hier werden pro Codesymbol $8$ Bit  (1  Byte) verwendet.


'''(2)'''&nbsp; The code $\rm RSC \, (2040, \, 1784, \, d_{\rm min})_2$ is the binary representation of the ${\rm RSC} discussed in (1) \, (255, \, 223, \, 33)_{256}$ with exactly the same code rate $R \ \underline{= 0.8745}$ and also the same minimum distance $d_{\rm min} \ \underline{= 33}$ as this one. Here $8$ bits (1 byte) are used per code symbol.




'''(3)'''&nbsp; Aus $d_{\rm min} = 33$ folgt wieder $t = 16 \ \Rightarrow \ N_{3} \ \underline{= 16}$.
*Ist in jedem Codesymbol genau ein Bit verfälscht, so bedeutet dies gleichzeitig auch 16 Symbolfehler.
*Dies ist der maximale Wert, den der Reed&ndash;Solomon&ndash;Decoder noch verkraften kann.


'''(3)'''&nbsp; From $d_{\rm min} = 33$ follows again $t = 16 \ \Rightarrow \ N_{3} \ \underline{= 16}$.
*If exactly one bit is corrupted in each code symbol, this also means 16 symbol errors.
*This is the maximum value that the Reed&ndash;Solomon decoder can still handle.




'''(4)'''&nbsp; Der RS&ndash;Decoder kann 16 verfälschte Codesymbole korrigieren,  
'''(4)'''&nbsp; The RS decoder can correct 16 corrupted code symbols,  
*wobei es egal ist, ob in einem Codesymbol nur ein Bit oder alle $m = 8$ Bit verfälscht wurden.  
*whereby it does not matter whether in a code symbol only one bit or all $m = 8$ bits have been corrupted.  
*Deshalb können bei der günstigsten Fehlerverteilung bis zu $N_4 = 8 \cdot 16 \ \underline{= 128}$ Bit verfälscht sein, ohne dass das Codewort falsch decodiert wird.
*Therefore, with the most favorable error distribution, up to $N_4 = 8 \cdot 16 \ \underline{= 128}$ bits can be corrupted without the code word being incorrectly decoded.
{{ML-Fuß}}
{{ML-Fuß}}



Revision as of 20:19, 2 September 2022

The two inventors of the Reed-Solomon codes

The codes developed by  "Irving Stoy Reed"  and  "Gustave Solomon"  in the early 1960s are referred to in this tutorial as follows:

$${\rm RSC} \, (n, \, k, \, d_{\rm min}) _q.$$

The code parameters have the following meanings:

  • $q = 2^m$  is an indication of the size of the Galois field   ⇒   ${\rm GF}(q)$,
  • $n = q - 1$  is the code length (symbol number of a code word),
  • $k$  indicates the dimension (symbol number of an information block),
  • $d_{\rm min}$  denotes the minimum distance between two codewords. For any Reed-Solomon code, $d_{\rm min} = n - k + 1$.
  • No other code with the same  $k$  and  $n$  yields a larger value.





Hints:



Questions

1 Specify the characteristics of the  ${\rm RSC} \, (255, \, 223, \, d_{\rm min})_q$ .

$q \hspace{0.2cm} = \ $
$e \hspace{0.2cm} = \ $
$t \hspace{0.2cm} = \ $
$R \hspace{0.2cm} = \ $
$d_{\rm min} \ = \ $

2 Specify the characteristics of the  $\rm RSC \, (2040, \, 1784, \, d_{\rm min})_2$ .

$R \hspace{0.2cm} = \ $
$d_{\rm min} \ = \ $

3 How many bit errors  $(N_3)$  may a received word  $\underline{y}$  have at most, so that it is certainly decoded correctly?

$N_{3} \ = \ $

4 How many bit errors  $(N_4)$  may a received word  $\underline{y}$  have in the best case so that it could still be correctly decoded?

$N_{4} \ = \ $


Solution

(1)  From the code length $n = 255$ follows $q \ \underline{= 256}$.

  • The code rate is given by $R = {223}/{255} \hspace{0.15cm}\underline {=0.8745}\hspace{0.05cm}.$
  • The minimum distance is $d_{\rm min} = n - k +1 = 255 - 223 +1
\hspace{0.15cm}\underline {=33}\hspace{0.05cm}.$
  • This allows
  • $e = d_{\rm min} - 1 \ \underline{= 32}$ symbol errors can be detected, and.
  • $t = e/2$ (rounded down), so $\underline{t = 16}$ symbol errors can be corrected.


(2)  The code $\rm RSC \, (2040, \, 1784, \, d_{\rm min})_2$ is the binary representation of the ${\rm RSC} discussed in (1) \, (255, \, 223, \, 33)_{256}$ with exactly the same code rate $R \ \underline{= 0.8745}$ and also the same minimum distance $d_{\rm min} \ \underline{= 33}$ as this one. Here $8$ bits (1 byte) are used per code symbol.


(3)  From $d_{\rm min} = 33$ follows again $t = 16 \ \Rightarrow \ N_{3} \ \underline{= 16}$.

  • If exactly one bit is corrupted in each code symbol, this also means 16 symbol errors.
  • This is the maximum value that the Reed–Solomon decoder can still handle.


(4)  The RS decoder can correct 16 corrupted code symbols,

  • whereby it does not matter whether in a code symbol only one bit or all $m = 8$ bits have been corrupted.
  • Therefore, with the most favorable error distribution, up to $N_4 = 8 \cdot 16 \ \underline{= 128}$ bits can be corrupted without the code word being incorrectly decoded.