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

Optional Inputs

InputDefault Value
genpoly cyclpoly(n,k)
prim_poly gfprimdf(n-k)


For All Syntaxes

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 is not specified as input, its default value is binary.

    Note:   If 2^n or 2^k is large, 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

Dimension of msgValue of fmt ArgumentDimension of code
Binary column or row vector binaryBinary column or row vector
Example: msg = [0 1 1 0, 0 1 0 1, 1 0 0 1].'
Binary matrix with k columns binaryBinary 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] decimalColumn or row 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 polynomial string or 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 xn-1.

code = encode(msg,n,k,'hamming/fmt',prim_poly) encodes msg using the Hamming encoding method. For this syntax, n must have the form 2m-1 for some integer m greater than or equal to 3, and k must equal n-m. prim_poly is a polynomial string or a row vector that gives the binary coefficients, in order of ascending powers, of the primitive polynomial for GF(2m) 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.


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.')

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.')
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.')

The output is

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

More About

expand all


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

Introduced before R2006a

Was this topic helpful?