Note: This page has been translated by MathWorks. Please click here

To view all translated materials including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materials including this page, select Japan from the country navigator on the bottom of this page.

Produce parity-check and generator matrices for Hamming code

`h = hammgen(m)`

h = hammgen(m,pol)

[h,g] = hammgen(...)

[h,g,n,k] = hammgen(...)

For all syntaxes, the codeword length is `n`

. `n`

has
the form 2^{m} – 1 for some positive
integer `m`

greater than or equal to 2. The message
length, `k`

, has the form `n`

– `m`

.

`h = hammgen(m)`

produces
an `m`

-by-`n`

parity-check matrix
for a Hamming code having codeword length `n = 2^m-1`

. The input `m`

is a positive
integer greater than or equal to 2. The message length of the code
is `n`

– `m`

. The binary
primitive polynomial used to produce the Hamming code is the default
primitive polynomial for GF(`2^m`

), represented by `gfprimdf`

`(m)`

.

`h = hammgen(m,pol)`

produces
an `m`

-by-`n`

parity-check matrix
for a Hamming code having codeword length `n = 2^m-1`

. The input `m`

is a positive
integer greater than or equal to 2. The message length of the code
is `n`

– `m`

. `pol`

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

)
that is used to produce the Hamming code. Alternatively, you can specify `pol`

as
a polynomial character vector. `hammgen`

produces
an error if `pol`

represents a polynomial that is
not, in fact, primitive.

`[h,g] = hammgen(...)`

is
the same as `h = hammgen(...)`

except that it also
produces the `k`

-by-n generator matrix `g`

that
corresponds to the parity-check matrix `h`

. `k`

,
the message length, equals n`-m`

, or `2^m-1-m`

.

`[h,g,n,k] = hammgen(...)`

is
the same as `[h,g] = hammgen(...)`

except that it
also returns the codeword length `n`

and the message
length `k`

.

If your value of `m`

is less than 25 and if
your primitive polynomial is the default primitive polynomial for
GF(`2^m`

), the syntax `hammgen(m)`

is
likely to be faster than the syntax `hammgen(m,pol)`

.

Unlike `gftuple`

, which processes
one `m`

-tuple at a time, `hammgen`

generates
the entire sequence from 0 to `2^m-1`

. The computation
algorithm uses all previously computed values to produce the computation
result.

Was this topic helpful?