Communications Toolbox

encode

Block encoder

Syntax

• code = encode(msg,n,k,'linear/fmt',genmat);
  code = encode(msg,n,k,'cyclic/fmt',genpoly);
  code = encode(msg,n,k,'bch/fmt',genpoly);
  code = encode(msg,n,k,'hamming/fmt',prim_poly);
  code = encode(msg,n,k);
  [code,added] = encode(...);
  

Optional Inputs

Input	Default Value
fmt	binary
genpoly	cyclpoly(n,k) for cyclic codes; bchpoly(n,k) for BCH codes
prim_poly	gfprimdf(n-k)

Description

For All Syntaxes

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

• Linear block
• Cyclic
• BCH (Bose, Ray-Chaudhuri, Hocquenghem)
• 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 is not specified as input, then its default value is binary.

Note    If 2^n or 2^k is large, then you should use the default binary format instead of the decimal 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.

Information Formats 

Format of msg	Value of "fmt" Argument	Format of code
Binary column vector	binary	Binary column 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 vector of integers in the range [0, 2^k-1]	decimal	Column vector of integers in the range [0, 2^n-1]
Example: msg = [6, 10, 9]'

For Specific Syntaxes

code = encode(msg,n,k,'linear/fmt',genmat) encodes 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,'cyclic/fmt',genpoly) encodes 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ⁿ-1.

code = encode(msg,n,k,'bch/fmt',genpoly) encodes msg using the BCH encoding method. genpoly is a row vector that gives the coefficients, in order of ascending powers, of the degree-(n-k) binary BCH generator polynomial. The default value of genpoly is bchpoly(n,k). For this syntax, n must have the form 2^m-1 for some integer m greater than or equal to 3. k must be a valid message length as reported in the second column of params in the command

• params = bchpoly(n)
  

code = encode(msg,n,k,'hamming/fmt',prim_poly) encodes msg using the Hamming encoding method. For this syntax, n must have the form 2^m-1 for some integer m greater than or equal to 3, and 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^m) that is used in the encoding process. The default value of 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.

Examples

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 = randint(100*k,1,[0,1]); % As a column vector
  msg2 = vec2mat(msg1,k); % As a k-column matrix
  msg3 = bi2de(msg2); % As a column 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 = randint(100,k,[0,1]); % 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, BCH, and cyclic methods. Before creating BCH code, it uses the bchpoly command to find out what codeword and message lengths are valid. 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 = 6; % Try codeword length = 6.
  % Find any valid message length for BCH code.
  params = bchpoly(n);
  n = params(1,1); % Redefine codeword length in case earlier one
  % was invalid.
  k = params(1,2); % Message length
  m = log2(n+1); % Express n as 2^m-1.
  msg = randint(100,1,[0,2^k-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
  codebch = encode(msg,n,k,'bch/decimal');
  codecyclic = encode(msg,n,k,'cyclic/decimal');
  
  % Decode to recover the original message.
  decodedhamming = decode(codehamming,n,k,'hamming/decimal');
  decodedbch = decode(codebch,n,k,'bch/decimal');
  decodedcyclic = decode(codecyclic,n,k,'cyclic/decimal');
  if (decodedhamming==msg & decodedbch==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.
  

Algorithm

Depending on the encoding method, encode relies on such lower-level functions as hammgen, cyclgen, and bchenco.

See Also

decode, bchpoly, cyclpoly, cyclgen, hammgen, bchenco

dpcmopt

eyediagram