Simple encoding procedure: The message as a sequence of coefficients

In the original construction of Reed & Solomon (1960), the message ${\displaystyle m=(m_{0},\dots ,m_{k-1})\in F^{k}}$ is mapped to the polynomial ${\displaystyle p_{m}}$ with

$${\displaystyle p_{m}(a)=\sum _{i=0}^{k-1}m_{i}a^{i}\,.}$$

The codeword of ${\displaystyle m}$ is obtained by evaluating ${\displaystyle p_{m}}$ at ${\displaystyle n}$ different points ${\displaystyle a_{0},\dots ,a_{n-1}}$ of the field ${\displaystyle F}$. Thus the classical encoding function ${\displaystyle C:F^{k}\to F^{n}}$ for the Reed–Solomon code is defined as follows:

$${\displaystyle C(m)={\begin{bmatrix}p_{m}(a_{0})\\p_{m}(a_{1})\\\cdots \\p_{m}(a_{n-1})\end{bmatrix}}}$$

This function ${\displaystyle C}$ is a linear mapping, that is, it satisfies ${\displaystyle C(m)=Am}$ for the following ${\displaystyle n\times k}$-matrix ${\displaystyle A}$ with elements from ${\displaystyle F}$:

$${\displaystyle C(m)=Am={\begin{bmatrix}1&a_{0}&a_{0}^{2}&\dots &a_{0}^{k-1}\\1&a_{1}&a_{1}^{2}&\dots &a_{1}^{k-1}\\\vdots &\vdots &\vdots &\ddots &\vdots \\1&a_{n-1}&a_{n-1}^{2}&\dots &a_{n-1}^{k-1}\end{bmatrix}}{\begin{bmatrix}m_{0}\\m_{1}\\\vdots \\m_{k-1}\end{bmatrix}}}$$

This matrix is a Vandermonde matrix over ${\displaystyle F}$. In other words, the Reed–Solomon code is a linear code, and in the classical encoding procedure, its generator matrix is ${\displaystyle A}$.

Systematic encoding procedure: The message as an initial sequence of values

There is an alternative encoding procedure that produces a systematic Reed–Solomon code. Here, we use a different polynomial ${\displaystyle p_{m}}$. In this variant, the polynomial ${\displaystyle p_{m}}$ is defined as the unique polynomial of degree less than ${\displaystyle k}$ such that

$${\displaystyle p_{m}(a_{i})=m_{i}{\text{ for all }}i\in \{0,\dots ,k-1\}.}$$

To compute this polynomial ${\displaystyle p_{m}}$ from ${\displaystyle m}$, one can use Lagrange interpolation. Once it has been found, it is evaluated at the other points ${\displaystyle a_{k},\dots ,a_{n-1}}$.

$${\displaystyle C(m)={\begin{bmatrix}p_{m}(a_{0})\\p_{m}(a_{1})\\\cdots \\p_{m}(a_{n-1})\end{bmatrix}}}$$

This variant is systematic since the first ${\displaystyle k}$ entries, ${\displaystyle p_{m}(a_{0}),\dots ,p_{m}(a_{k-1})}$, are exactly ${\displaystyle m_{0},\dots ,m_{k-1}}$ by the definition of ${\displaystyle p_{m}}$.

Discrete Fourier transform and its inverse

A discrete Fourier transform is essentially the same as the encoding procedure; it uses the generator polynomial ${\displaystyle p_{m}}$ to map a set of evaluation points into the message values as shown above:

$${\displaystyle C(m)={\begin{bmatrix}p_{m}(a_{0})\\p_{m}(a_{1})\\\cdots \\p_{m}(a_{n-1})\end{bmatrix}}}$$

The inverse Fourier transform could be used to convert an error free set of n < q message values back into the encoding polynomial of k coefficients, with the constraint that in order for this to work, the set of evaluation points used to encode the message must be a set of increasing powers of α:

$${\displaystyle a_{i}=\alpha ^{i}}$$

$${\displaystyle a_{0},\dots ,a_{n-1}=\{1,\alpha ,\alpha ^{2},\dots ,\alpha ^{n-1}\}}$$

However, Lagrange interpolation performs the same conversion without the constraint on the set of evaluation points or the requirement of an error free set of message values and is used for systematic encoding, and in one of the steps of the Gao decoder.

Systematic encoding procedure

The encoding procedure for the BCH view of Reed–Solomon codes can be modified to yield a systematic encoding procedure, in which each codeword contains the message as a prefix, and simply appends error correcting symbols as a suffix. Here, instead of sending ${\displaystyle s(x)=p(x)g(x)}$, the encoder constructs the transmitted polynomial ${\displaystyle s(x)}$ such that the coefficients of the ${\displaystyle k}$ largest monomials are equal to the corresponding coefficients of ${\displaystyle p(x)}$, and the lower-order coefficients of ${\displaystyle s(x)}$ are chosen exactly in such a way that ${\displaystyle s(x)}$ becomes divisible by ${\displaystyle g(x)}$. Then the coefficients of ${\displaystyle p(x)}$ are a subsequence of the coefficients of ${\displaystyle s(x)}$. To get a code that is overall systematic, we construct the message polynomial ${\displaystyle p(x)}$ by interpreting the message as the sequence of its coefficients.

Formally, the construction is done by multiplying ${\displaystyle p(x)}$ by ${\displaystyle x^{t}}$ to make room for the ${\displaystyle t=n-k}$ check symbols, dividing that product by ${\displaystyle g(x)}$ to find the remainder, and then compensating for that remainder by subtracting it. The ${\displaystyle t}$ check symbols are created by computing the remainder ${\displaystyle s_{r}(x)}$:

$${\displaystyle s_{r}(x)=p(x)\cdot x^{t}\ {\bmod {\ }}g(x).}$$

The remainder has degree at most ${\displaystyle t-1}$, whereas the coefficients of ${\displaystyle x^{t-1},x^{t-2},\dots ,x^{1},x^{0}}$ in the polynomial ${\displaystyle p(x)\cdot x^{t}}$ are zero. Therefore, the following definition of the codeword ${\displaystyle s(x)}$ has the property that the first ${\displaystyle k}$ coefficients are identical to the coefficients of ${\displaystyle p(x)}$:

$${\displaystyle s(x)=p(x)\cdot x^{t}-s_{r}(x)\,.}$$

As a result, the codewords ${\displaystyle s(x)}$ are indeed elements of ${\displaystyle \mathbf {C} }$, that is, they are divisible by the generator polynomial ${\displaystyle g(x)}$:^[10]

$${\displaystyle s(x)\equiv p(x)\cdot x^{t}-s_{r}(x)\equiv s_{r}(x)-s_{r}(x)\equiv 0\mod g(x)\,.}$$

Formulation

The transmitted message, ${\displaystyle (c_{0},\ldots ,c_{i},\ldots ,c_{n-1})}$, is viewed as the coefficients of a polynomial s(x):

$${\displaystyle s(x)=\sum _{i=0}^{n-1}c_{i}x^{i}}$$

As a result of the Reed-Solomon encoding procedure, s(x) is divisible by the generator polynomial g(x):

$${\displaystyle g(x)=\prod _{j=1}^{n-k}(x-\alpha ^{j}),}$$

where α is a primitive element.

Since s(x) is a multiple of the generator g(x), it follows that it "inherits" all its roots.

$${\displaystyle s(x){\bmod {(}}x-\alpha ^{j})=g(x){\bmod {(}}x-\alpha ^{j})=0}$$

Therefore,

$${\displaystyle s(\alpha ^{j})=0,\ j=1,2,\ldots ,n-k}$$

The transmitted polynomial is corrupted in transit by an error polynomial e(x) to produce the received polynomial r(x).

$${\displaystyle r(x)=s(x)+e(x)}$$

$${\displaystyle e(x)=\sum _{i=0}^{n-1}e_{i}x^{i}}$$

Coefficient e_i will be zero if there is no error at that power of x and nonzero if there is an error. If there are ν errors at distinct powers i_k of x, then

$${\displaystyle e(x)=\sum _{k=1}^{\nu }e_{i_{k}}x^{i_{k}}}$$

The goal of the decoder is to find the number of errors (ν), the positions of the errors (i_k), and the error values at those positions (e_ik). From those, e(x) can be calculated and subtracted from r(x) to get the originally sent message s(x).

Syndrome decoding

The decoder starts by evaluating the polynomial as received at points ${\displaystyle \alpha ^{1}\dots \alpha ^{n-k}}$. We call the results of that evaluation the "syndromes", S_j. They are defined as:

$${\displaystyle {\begin{aligned}S_{j}&=r(\alpha ^{j})=s(\alpha ^{j})+e(\alpha ^{j})=0+e(\alpha ^{j})\\&=e(\alpha ^{j})\\&=\sum _{k=1}^{\nu }e_{i_{k}}\left(\alpha ^{j}\right)^{i_{k}},\quad j=1,2,\ldots ,n-k\end{aligned}}}$$

Note that ${\displaystyle s(\alpha ^{j})=0}$ because ${\displaystyle s(x)}$ has roots at ${\displaystyle \alpha ^{j}}$, as shown in the previous section.

The advantage of looking at the syndromes is that the message polynomial drops out. In other words, the syndromes only relate to the error, and are unaffected by the actual contents of the message being transmitted. If the syndromes are all zero, the algorithm stops here and reports that the message was not corrupted in transit.

Error locators and error values

For convenience, define the error locators X_k and error values Y_k as:

$${\displaystyle X_{k}=\alpha ^{i_{k}},\ Y_{k}=e_{i_{k}}}$$

Then the syndromes can be written in terms of these error locators and error values as

$${\displaystyle S_{j}=\sum _{k=1}^{\nu }Y_{k}X_{k}^{j}}$$

This definition of the syndrome values is equivalent to the previous since ${\displaystyle (\alpha ^{j})^{i_{k}}=\alpha ^{j*i_{k}}=(\alpha ^{i_{k}})^{j}=X_{k}^{j}}$.

The syndromes give a system of n − k ≥ 2ν equations in 2ν unknowns, but that system of equations is nonlinear in the X_k and does not have an obvious solution. However, if the X_k were known (see below), then the syndrome equations provide a linear system of equations that can easily be solved for the Y_k error values.

$${\displaystyle {\begin{bmatrix}X_{1}^{1}&X_{2}^{1}&\cdots &X_{\nu }^{1}\\X_{1}^{2}&X_{2}^{2}&\cdots &X_{\nu }^{2}\\\vdots &\vdots &\ddots &\vdots \\X_{1}^{n-k}&X_{2}^{n-k}&\cdots &X_{\nu }^{n-k}\\\end{bmatrix}}{\begin{bmatrix}Y_{1}\\Y_{2}\\\vdots \\Y_{\nu }\end{bmatrix}}={\begin{bmatrix}S_{1}\\S_{2}\\\vdots \\S_{n-k}\end{bmatrix}}}$$

Consequently, the problem is finding the X_k, because then the leftmost matrix would be known, and both sides of the equation could be multiplied by its inverse, yielding Y_k

In the variant of this algorithm where the locations of the errors are already known (when it is being used as an erasure code), this is the end. The error locations (X_k) are already known by some other method (for example, in an FM transmission, the sections where the bitstream was unclear or overcome with interference are probabilistically determinable from frequency analysis). In this scenario, up to ${\displaystyle n-k}$ errors can be corrected.

The rest of the algorithm serves to locate the errors, and will require syndrome values up to ${\displaystyle 2v}$, instead of just the ${\displaystyle v}$ used thus far. This is why twice as many error correcting symbols need to be added as can be corrected without knowing their locations.

Error locator polynomial

There is a linear recurrence relation that gives rise to a system of linear equations. Solving those equations identifies those error locations X_k.

Define the error locator polynomial Λ(x) as

$${\displaystyle \Lambda (x)=\prod _{k=1}^{\nu }(1-xX_{k})=1+\Lambda _{1}x^{1}+\Lambda _{2}x^{2}+\cdots +\Lambda _{\nu }x^{\nu }}$$

The zeros of Λ(x) are the reciprocals ${\displaystyle X_{k}^{-1}}$. This follows from the above product notation construction since if ${\displaystyle x=X_{k}^{-1}}$ then one of the multiplied terms will be zero ${\displaystyle (1-X_{k}^{-1}\cdot X_{k})=1-1=0}$, making the whole polynomial evaluate to zero.

$${\displaystyle \Lambda (X_{k}^{-1})=0}$$

Let ${\displaystyle j}$ be any integer such that ${\displaystyle 1\leq j\leq \nu }$. Multiply both sides by ${\displaystyle Y_{k}X_{k}^{j+\nu }}$ and it will still be zero.

$${\displaystyle {\begin{aligned}&Y_{k}X_{k}^{j+\nu }\Lambda (X_{k}^{-1})=0.\\[1ex]&Y_{k}X_{k}^{j+\nu }\left(1+\Lambda _{1}X_{k}^{-1}+\Lambda _{2}X_{k}^{-2}+\cdots +\Lambda _{\nu }X_{k}^{-\nu }\right)=0.\\[1ex]&Y_{k}X_{k}^{j+\nu }+\Lambda _{1}Y_{k}X_{k}^{j+\nu }X_{k}^{-1}+\Lambda _{2}Y_{k}X_{k}^{j+\nu }X_{k}^{-2}+\cdots +\Lambda _{\nu }Y_{k}X_{k}^{j+\nu }X_{k}^{-\nu }=0.\\[1ex]&Y_{k}X_{k}^{j+\nu }+\Lambda _{1}Y_{k}X_{k}^{j+\nu -1}+\Lambda _{2}Y_{k}X_{k}^{j+\nu -2}+\cdots +\Lambda _{\nu }Y_{k}X_{k}^{j}=0.\end{aligned}}}$$

Sum for k = 1 to ν and it will still be zero.

$${\displaystyle \sum _{k=1}^{\nu }\left(Y_{k}X_{k}^{j+\nu }+\Lambda _{1}Y_{k}X_{k}^{j+\nu -1}+\Lambda _{2}Y_{k}X_{k}^{j+\nu -2}+\cdots +\Lambda _{\nu }Y_{k}X_{k}^{j}\right)=0}$$

Collect each term into its own sum.

$${\displaystyle \left(\sum _{k=1}^{\nu }Y_{k}X_{k}^{j+\nu }\right)+\left(\sum _{k=1}^{\nu }\Lambda _{1}Y_{k}X_{k}^{j+\nu -1}\right)+\left(\sum _{k=1}^{\nu }\Lambda _{2}Y_{k}X_{k}^{j+\nu -2}\right)+\cdots +\left(\sum _{k=1}^{\nu }\Lambda _{\nu }Y_{k}X_{k}^{j}\right)=0}$$

Extract the constant values of ${\displaystyle \Lambda }$ that are unaffected by the summation.

$${\displaystyle \left(\sum _{k=1}^{\nu }Y_{k}X_{k}^{j+\nu }\right)+\Lambda _{1}\left(\sum _{k=1}^{\nu }Y_{k}X_{k}^{j+\nu -1}\right)+\Lambda _{2}\left(\sum _{k=1}^{\nu }Y_{k}X_{k}^{j+\nu -2}\right)+\cdots +\Lambda _{\nu }\left(\sum _{k=1}^{\nu }Y_{k}X_{k}^{j}\right)=0}$$

These summations are now equivalent to the syndrome values, which we know and can substitute in! This therefore reduces to

$${\displaystyle S_{j+\nu }+\Lambda _{1}S_{j+\nu -1}+\cdots +\Lambda _{\nu -1}S_{j+1}+\Lambda _{\nu }S_{j}=0}$$

Subtracting ${\displaystyle S_{j+\nu }}$ from both sides yields

$${\displaystyle S_{j}\Lambda _{\nu }+S_{j+1}\Lambda _{\nu -1}+\cdots +S_{j+\nu -1}\Lambda _{1}=-S_{j+\nu }}$$

Recall that j was chosen to be any integer between 1 and v inclusive, and this equivalence is true for any and all such values. Therefore, we have v linear equations, not just one. This system of linear equations can therefore be solved for the coefficients Λ_i of the error location polynomial:

$${\displaystyle {\begin{bmatrix}S_{1}&S_{2}&\cdots &S_{\nu }\\S_{2}&S_{3}&\cdots &S_{\nu +1}\\\vdots &\vdots &\ddots &\vdots \\S_{\nu }&S_{\nu +1}&\cdots &S_{2\nu -1}\end{bmatrix}}{\begin{bmatrix}\Lambda _{\nu }\\\Lambda _{\nu -1}\\\vdots \\\Lambda _{1}\end{bmatrix}}={\begin{bmatrix}-S_{\nu +1}\\-S_{\nu +2}\\\vdots \\-S_{\nu +\nu }\end{bmatrix}}}$$

The above assumes the decoder knows the number of errors ν, but that number has not been determined yet. The PGZ decoder does not determine ν directly but rather searches for it by trying successive values. The decoder first assumes the largest value for a trial ν and sets up the linear system for that value. If the equations can be solved (i.e., the matrix determinant is nonzero), then that trial value is the number of errors. If the linear system cannot be solved, then the trial ν is reduced by one and the next smaller system is examined. (Gill n.d., p. 35)

Find the roots of the error locator polynomial

Use the coefficients Λ_i found in the last step to build the error location polynomial. The roots of the error location polynomial can be found by exhaustive search. The error locators X_k are the reciprocals of those roots. The order of coefficients of the error location polynomial can be reversed, in which case the roots of that reversed polynomial are the error locators ${\displaystyle X_{k}}$ (not their reciprocals ${\displaystyle X_{k}^{-1}}$). Chien search is an efficient implementation of this step.

Calculate the error values

Once the error locators X_k are known, the error values can be determined. This can be done by direct solution for Y_k in the error equations matrix given above, or using the Forney algorithm.

Calculate the error locations

Calculate i_k by taking the log base ${\displaystyle \alpha }$ of X_k. This is generally done using a precomputed lookup table.

Fix the errors

Finally, e(x) is generated from i_k and e_ik and then is subtracted from r(x) to get the originally sent message s(x), with errors corrected.

Example

Consider the Reed–Solomon code defined in GF(929) with α = 3 and t = 4 (this is used in PDF417 barcodes) for a RS(7,3) code. The generator polynomial is

$${\displaystyle g(x)=(x-3)(x-3^{2})(x-3^{3})(x-3^{4})=x^{4}+809x^{3}+723x^{2}+568x+522}$$

If the message polynomial is p(x) = 3 x² + 2 x + 1, then a systematic codeword is encoded as follows.

$${\displaystyle s_{r}(x)=p(x)\,x^{t}{\bmod {g}}(x)=547x^{3}+738x^{2}+442x+455}$$

$${\displaystyle s(x)=p(x)\,x^{t}-s_{r}(x)=3x^{6}+2x^{5}+1x^{4}+382x^{3}+191x^{2}+487x+474}$$

Errors in transmission might cause this to be received instead.

$${\displaystyle r(x)=s(x)+e(x)=3x^{6}+2x^{5}+123x^{4}+456x^{3}+191x^{2}+487x+474}$$

The syndromes are calculated by evaluating r at powers of α.

$${\displaystyle S_{1}=r(3^{1})=3\cdot 3^{6}+2\cdot 3^{5}+123\cdot 3^{4}+456\cdot 3^{3}+191\cdot 3^{2}+487\cdot 3+474=732}$$

$${\displaystyle S_{2}=r(3^{2})=637,\;S_{3}=r(3^{3})=762,\;S_{4}=r(3^{4})=925}$$

$${\displaystyle {\begin{bmatrix}732&637\\637&762\end{bmatrix}}{\begin{bmatrix}\Lambda _{2}\\\Lambda _{1}\end{bmatrix}}={\begin{bmatrix}-762\\-925\end{bmatrix}}={\begin{bmatrix}167\\004\end{bmatrix}}}$$

Using Gaussian elimination:

$${\displaystyle {\begin{bmatrix}001&000\\000&001\end{bmatrix}}{\begin{bmatrix}\Lambda _{2}\\\Lambda _{1}\end{bmatrix}}={\begin{bmatrix}329\\821\end{bmatrix}}}$$

The coefficients can be reversed to produce roots with positive exponents, but typically this isn't used:

with the log of the roots corresponding to the error locations (right to left, location 0 is the last term in the codeword).

To calculate the error values, apply the Forney algorithm.

Subtracting ${\displaystyle e_{1}x^{3}+e_{2}x^{4}=74x^{3}+122x^{4}}$ from the received polynomial r(x) reproduces the original codeword s.

Example

Using the same data as the Peterson Gorenstein Zierler example above:

The final value of C is the error locator polynomial, Λ(x).

Example

Using the same data as the Peterson–Gorenstein–Zierler example above:

Encoder

Here we present a simple MATLAB implementation for an encoder.

function encoded = rsEncoder(msg, m, prim_poly, n, k)
    % RSENCODER Encode message with the Reed-Solomon algorithm
    % m is the number of bits per symbol
    % prim_poly: Primitive polynomial p(x). Ie for DM is 301
    % k is the size of the message
    % n is the total size (k+redundant)
    % Example: msg = uint8('Test')
    % enc_msg = rsEncoder(msg, 8, 301, 12, numel(msg));

    % Get the alpha
    alpha = gf(2, m, prim_poly);

    % Get the Reed-Solomon generating polynomial g(x)
    g_x = genpoly(k, n, alpha);

    % Multiply the information by X^(n-k), or just pad with zeros at the end to
    % get space to add the redundant information
    msg_padded = gf([msg zeros(1, n - k)], m, prim_poly);

    % Get the remainder of the division of the extended message by the
    % Reed-Solomon generating polynomial g(x)
    [~, remainder] = deconv(msg_padded, g_x);

    % Now return the message with the redundant information
    encoded = msg_padded - remainder;

end

% Find the Reed-Solomon generating polynomial g(x), by the way this is the
% same as the rsgenpoly function on matlab
function g = genpoly(k, n, alpha)
    g = 1;
    % A multiplication on the galois field is just a convolution
    for k = mod(1 : n - k, n)
        g = conv(g, [1 alpha .^ (k)]);
    end
end

Decoder

Now the decoding part:

function [decoded, error_pos, error_mag, g, S] = rsDecoder(encoded, m, prim_poly, n, k)
    % RSDECODER Decode a Reed-Solomon encoded message
    %   Example:
    % [dec, ~, ~, ~, ~] = rsDecoder(enc_msg, 8, 301, 12, numel(msg))
    max_errors = floor((n - k) / 2);
    orig_vals = encoded.x;
    % Initialize the error vector
    errors = zeros(1, n);
    g = [];
    S = [];

    % Get the alpha
    alpha = gf(2, m, prim_poly);

    % Find the syndromes (Check if dividing the message by the generator
    % polynomial the result is zero)
    Synd = polyval(encoded, alpha .^ (1:n - k));
    Syndromes = trim(Synd);

    % If all syndromes are zeros (perfectly divisible) there are no errors
    if isempty(Syndromes.x)
        decoded = orig_vals(1:k);
        error_pos = [];
        error_mag = [];
        g = [];
        S = Synd;
        return;
    end

    % Prepare for the euclidean algorithm (Used to find the error locating
    % polynomials)
    r0 = [1, zeros(1, 2 * max_errors)]; r0 = gf(r0, m, prim_poly); r0 = trim(r0);
    size_r0 = length(r0);
    r1 = Syndromes;
    f0 = gf([zeros(1, size_r0 - 1) 1], m, prim_poly);
    f1 = gf(zeros(1, size_r0), m, prim_poly);
    g0 = f1; g1 = f0;

    % Do the euclidean algorithm on the polynomials r0(x) and Syndromes(x) in
    % order to find the error locating polynomial
    while true
        % Do a long division
        [quotient, remainder] = deconv(r0, r1);
        % Add some zeros
        quotient = pad(quotient, length(g1));

        % Find quotient*g1 and pad
        c = conv(quotient, g1);
        c = trim(c);
        c = pad(c, length(g0));

        % Update g as g0-quotient*g1
        g = g0 - c;

        % Check if the degree of remainder(x) is less than max_errors
        if all(remainder(1:end - max_errors) == 0)
            break;
        end

        % Update r0, r1, g0, g1 and remove leading zeros
        r0 = trim(r1); r1 = trim(remainder);
        g0 = g1; g1 = g;
    end

    % Remove leading zeros
    g = trim(g);

    % Find the zeros of the error polynomial on this galois field
    evalPoly = polyval(g, alpha .^ (n - 1 : - 1 : 0));
    error_pos = gf(find(evalPoly == 0), m);

    % If no error position is found we return the received work, because
    % basically is nothing that we could do and we return the received message
    if isempty(error_pos)
        decoded = orig_vals(1:k);
        error_mag = [];
        return;
    end

    % Prepare a linear system to solve the error polynomial and find the error
    % magnitudes
    size_error = length(error_pos);
    Syndrome_Vals = Syndromes.x;
    b(:, 1) = Syndrome_Vals(1:size_error);
    for idx = 1 : size_error
        e = alpha .^ (idx * (n - error_pos.x));
        err = e.x;
        er(idx, :) = err;
    end

    % Solve the linear system
    error_mag = (gf(er, m, prim_poly) \ gf(b, m, prim_poly))';
    % Put the error magnitude on the error vector
    errors(error_pos.x) = error_mag.x;
    % Bring this vector to the galois field
    errors_gf = gf(errors, m, prim_poly);

    % Now to fix the errors just add with the encoded code
    decoded_gf = encoded(1:k) + errors_gf(1:k);
    decoded = decoded_gf.x;

end

% Remove leading zeros from Galois array
function gt = trim(g)
    gx = g.x;
    gt = gf(gx(find(gx, 1) : end), g.m, g.prim_poly);
end

% Add leading zeros
function xpad = pad(x, k)
    len = length(x);
    if len < k
        xpad = [zeros(1, k - len) x];
    end
end

Example

Using RS(7,3), GF(929), and the set of evaluation points a_i = i − 1

If the message polynomial is

The codeword is

Errors in transmission might cause this to be received instead.

The key equations are:

$${\displaystyle b_{i}E(a_{i})-Q(a_{i})=0}$$

Assume maximum number of errors: e = 2. The key equations become: