## Documentation Center |

`decoded = rsdec(code,n,k)decoded = rsdec(code,n,k,genpoly)decoded = rsdec(...,`

`decoded = rsdec(code,n,k)` attempts
to decode the received signal in `code` using an
[`n`,`k`] Reed-Solomon decoding
process with the narrow-sense generator polynomial. `code` is
a Galois
array of symbols having m bits each. Each `n`-element
row of `code` represents a corrupted systematic codeword,
where the parity symbols are at the end and the leftmost symbol is
the most significant symbol. `n` is at most 2^{m}-1.
If `n` is not exactly 2^{m}-1, `rsdec` assumes
that `code` is a corrupted version of a shortened
code.

In the Galois array `decoded`, each row represents
the attempt at decoding the corresponding row in `code`.
A *decoding failure* occurs if `rsdec` detects
more than `(n-k)/2` errors in a row of `code`.
In this case, `rsdec` forms the corresponding row
of `decoded` by merely removing `n-k` symbols
from the end of the row of `code`.

`decoded = rsdec(code,n,k,genpoly)` is
the same as the syntax above, except that a nonempty value of `genpoly` specifies
the generator polynomial for the code. In this case, `genpoly` is
a Galois row vector that lists the coefficients, in order of descending
powers, of the generator polynomial. The generator polynomial must
have degree `n-k`. To use the default narrow-sense
generator polynomial, set `genpoly` to `[]`.

`decoded = rsdec(...,paritypos)` specifies
whether the parity symbols in

`[decoded,cnumerr] = rsdec(...)` returns
a column vector `cnumerr`, each element of which
is the number of corrected errors in the corresponding row of `code`.
A value of `-1` in `cnumerr` indicates
a decoding failure in that row in `code`.

`[decoded,cnumerr,ccode] = rsdec(...)` returns `ccode`,
the corrected version of `code`. The Galois array `ccode` has
the same format as `code`. If a decoding failure
occurs in a certain row of `code`, the corresponding
row in `ccode` contains that row unchanged.

The example below encodes three message words using a (7,3)
Reed-Solomon encoder. It then corrupts the code by introducing one
error in the first codeword, two errors in the second codeword, and
three errors in the third codeword. Then `rsdec` tries
to decode the corrupted code.

m = 3; % Number of bits per symbol n = 2^m-1; k = 3; % Word lengths for code msg = gf([2 7 3; 4 0 6; 5 1 1],m); % Three rows of m-bit symbols code = rsenc(msg,n,k); errors = gf([2 0 0 0 0 0 0; 3 4 0 0 0 0 0; 5 6 7 0 0 0 0],m); noisycode = code + errors; [dec,cnumerr] = rsdec(noisycode,n,k)

The output is below.

dec = GF(2^3) array. Primitive polynomial = D^3+D+1 (11 decimal) Array elements = 2 7 3 4 0 6 0 7 6 cnumerr = 1 2 -1

The output shows that `rsdec` successfully
corrects the errors in the first two codewords and recovers the first
two original message words. However, a (7,3) Reed-Solomon code can
correct at most two errors in each word, so `rsdec` cannot
recover the third message word. The elements of the vector `cnumerr` indicate
the number of corrected errors in the first two words and also indicate
the decoding failure in the third word.

For additional examples, see Create and Decode Reed-Solomon Codes.

[1] Wicker, S. B., *Error Control
Systems for Digital Communication and Storage*, Upper Saddle
River, NJ, Prentice Hall, 1995.

[2] Berlekamp, E. R., *Algebraic
Coding Theory*, New York, McGraw-Hill, 1968.

Was this topic helpful?