Block encoder

`code = encode(msg,n,k,'`

`linear/`

* fmt*',genmat)

code = encode(msg,n,k,'

`cyclic/`

`fmt`

`poly`

)code = encode(msg,n,k,'

`hamming/`

`fmt`

code = encode(msg,n,k)

[code,added] = encode(...)

The `encode`

function encodes messages using
one of the following error-correction coding methods:

Linear block

Cyclic

Hamming

For all of these methods, the codeword length is `n`

and
the message length is `k`

.

`msg`

, which represents the messages, can have
one of several formats. The table Information Formats below shows which formats are
allowed for `msg`

, how the argument * fmt* should
reflect the format of

`msg`

, and how the format of
the output `code`

depends on these choices. The examples
in the table are for `k = 4`

. If `fmt`

`binary`

format.
This is because the function uses a binary format internally, while
the roundoff error associated with converting many bits to large decimal
numbers and back might be substantial.`decimal` |

**Information Formats**

Dimension
of `msg` | Value of fmt Argument | Dimension of `code` |
---|---|---|

Binary column or row vector | `binary` | Binary column or row vector |

Example: ```
msg = [0 1 1
0, 0 1 0 1, 1 0 0 1].'
``` | ||

Binary matrix with `k` columns | `binary` | Binary matrix with `n` columns |

Example: ```
msg = [0 1 1
0; 0 1 0 1; 1 0 0 1]
``` | ||

Column or row vector of
integers in the range [0, `2^k-1` ] | `decimal` | Column or row vector of
integers in the range [0, `2^n-1` ] |

Example: ```
msg = [6, 10,
9].'
``` |

`code = encode(msg,n,k,'`

encodes `linear/`

* fmt*',genmat)

`msg`

using `genmat`

as
the generator matrix for the linear block encoding method. `genmat`

,
a `k`

-by-`n`

matrix, is required
as input.`code = encode(msg,n,k,'`

encodes `cyclic/`

* fmt*',gen

`poly`

)`msg`

and
creates a systematic cyclic code. `genpoly`

is a
row vector that gives the coefficients, in order of ascending powers,
of the binary generator polynomial. The default value of `genpoly`

is `cyclpoly`

`(n,k)`

. By definition,
the generator polynomial for an [n,k] cyclic code must have degree
n-k and must divide x`code = encode(msg,n,k,'`

encodes `hamming/`

* fmt*',prim_poly)

`msg`

using
the Hamming encoding method. For this syntax, `n`

must
have the form 2`k`

must equal `n`

-m. `prim_poly`

is
a row vector that gives the binary coefficients, in order of ascending
powers, of the primitive polynomial for GF(2`prim_poly`

is
the default primitive polynomial `gfprimdf`

`(`

m`)`

.`code = encode(msg,n,k)`

is
the same as `code = encode(msg,n,k,'hamming/binary')`

.

`[code,added] = encode(...)`

returns
the additional variable `added`

. `added`

is
the number of zeros that were placed at the end of the message matrix
before encoding in order for the matrix to have the appropriate shape.
"Appropriate" depends on `n`

, `k`

,
the shape of `msg`

, and the encoding method.

The example below illustrates the three different information
formats (binary vector, binary matrix, and decimal vector) for Hamming
code. The three messages have identical content in different formats;
as a result, the three codes that `encode`

creates
have identical content in correspondingly different formats.

m = 4; n = 2^m-1; % Codeword length = 15 k = 11; % Message length % Create 100 messages, k bits each. msg1 = randi([0,1],100*k,1); % As a column vector msg2 = vec2mat(msg1,k); % As a k-column matrix msg3 = bi2de(msg2)'; % As a row vector of decimal integers % Create 100 codewords, n bits each. code1 = encode(msg1,n,k,'hamming/binary'); code2 = encode(msg2,n,k,'hamming/binary'); code3 = encode(msg3,n,k,'hamming/decimal'); if ( vec2mat(code1,n)==code2 & de2bi(code3',n)==code2 ) disp('All three formats produced the same content.') end

The output is

All three formats produced the same content.

The next example creates a cyclic code,
adds noise, and then decodes the noisy code. It uses the `decode`

function.

n = 3; k = 2; % A (3,2) cyclic code msg = randi([0,1],100,k); % 100 messages, k bits each code = encode(msg,n,k,'cyclic/binary'); % Add noise. noisycode = rem(code + randerr(100,n,[0 1;.7 .3]), 2); newmsg = decode(noisycode,n,k,'cyclic'); % Try to decode. % Compute error rate for decoding the noisy code. [number,ratio] = biterr(newmsg,msg); disp(['The bit error rate is ',num2str(ratio)])

The output is below. Your error rate results might vary because the noise is random.

The bit error rate is 0.08

The next example encodes the same message using Hamming
and cyclic methods. This example also creates Hamming code with the `'`

`linear`

`'`

option
of the `encode`

command. It then decodes each code
and recovers the original message.

n = 7; % Codeword length k = 4; % Message length m = log2(n+1); % Express n as 2^m-1. msg = randi([0,2^k-1],100,1); % Column of decimal integers % Create various codes. codehamming = encode(msg,n,k,'hamming/decimal'); [parmat,genmat] = hammgen(m); codehamming2 = encode(msg,n,k,'linear/decimal',genmat); if codehamming==codehamming2 disp('The ''linear'' method can create Hamming code.') end codecyclic = encode(msg,n,k,'cyclic/decimal'); % Decode to recover the original message. decodedhamming = decode(codehamming,n,k,'hamming/decimal'); decodedcyclic = decode(codecyclic,n,k,'cyclic/decimal'); if (decodedhamming==msg & decodedcyclic==msg) disp('All decoding worked flawlessly in this noiseless world.') end

The output is

The 'linear' method can create Hamming code. All decoding worked flawlessly in this noiseless world.

Was this topic helpful?