# gftuple

Simplify or convert Galois field element formatting

## Syntax

`tp = gftuple(a,m)`

tp = gftuple(a,prim_poly)

tp = gftuple(a,m,p)

tp = gftuple(a,prim_poly,p)

tp = gftuple(a,prim_poly,p,prim_ck)

[tp,expform] = gftuple(...)

## Description

**Note**

This function performs computations in
GF(`p`

^{m}), where p is prime.
To perform equivalent computations in GF(2^{m}),
apply the `.^`

operator and the `log`

function to Galois
arrays. For more information, see Example: Exponentiation and Example: Elementwise Logarithm.

### For All Syntaxes

`gftuple`

serves to simplify the polynomial or exponential format of
Galois field elements, or to convert from one format to another. For an explanation of the
formats that `gftuple`

uses, see Representing Elements of Galois Fields.

In this discussion, the format of an element of
GF(`p`

^{m}) is called
*simplest* if all exponents of the primitive element are

In the range [0, (

`m`

– 1)] for the polynomial formatEither

`-Inf`

, or in the range [0, (`p`

^{m}– 2)], for the exponential format

For all syntaxes, `a`

is a matrix, each row of which represents an
element of a Galois field. The format of `a`

determines how MATLAB interprets
it:

If

`a`

is a column of integers, MATLAB interprets each row as an*exponential*format of an element. Negative integers are equivalent to`-Inf`

in that they all represent the zero element of the field.If

`a`

has more than one column, MATLAB interprets each row as a*polynomial*format of an element. Each entry of`a`

must be an integer in the range [0, (`p`

– 1)].

The exponential or polynomial formats mentioned above are all relative to a primitive
element specified by the *second* input argument. The second argument is
described below.

### For Specific Syntaxes

`tp = gftuple(a,m)`

returns the simplest polynomial
format of the elements that `a`

represents, where the kth row of
`tp`

corresponds to the kth row of `a`

. The formats are
relative to a root of the default primitive polynomial for
GF(2^{m}), where `m`

is a
positive integer.

`tp = gftuple(a,prim_poly)`

is the same as the syntax
above, except that `prim_poly`

is a polynomial character vector or a row vector
that lists the coefficients of a degree `m`

primitive polynomial for
GF(2^{m}) in order of ascending exponents.

`tp = gftuple(a,m,p)`

is the same as ```
tp =
gftuple(a,m)
```

except that 2 is replaced by a prime number
`p`

.

`tp = gftuple(a,prim_poly,p)`

is the same as
`tp = gftuple(a,prim_poly)`

except that 2 is replaced by a prime number
`p`

.

`tp = gftuple(a,prim_poly,p,prim_ck)`

is the same as
`tp = gftuple(a,prim_poly,p)`

except that `gftuple`

checks
whether `prim_poly`

represents a polynomial that is indeed primitive. If not,
then `gftuple`

generates an error and `tp`

is not
returned. The input argument `prim_ck`

can be any number or character vector;
only its existence matters.

`[tp,expform] = gftuple(...)`

returns the additional
matrix `expform`

. The kth row of `expform`

is the simplest
exponential format of the element that the kth row of `a`

represents. All
other features are as described in previous syntaxes, depending on the input arguments.

## Examples

As another example, the `gftuple`

command below generates a list of
elements of GF(`p`

), arranged relative to a root of
the default primitive polynomial. Some functions in Communications Toolbox™ use such a list as an input argument.^{m}

p = 5; % Or any prime number m = 4; % Or any positive integer field = gftuple([-1:p^m-2]',m,p);

Finally, the two commands below illustrate the influence of the *shape*
of the input matrix. In the first command, a column vector is treated as a sequence of elements
expressed in exponential format. In the second command, a row vector is treated as a single
element expressed in polynomial format.

tp1 = gftuple([0; 1],3,3) tp2 = gftuple([0, 0, 0, 1],3,3)

The output is below.

tp1 = 1 0 0 0 1 0 tp2 = 2 1 0

The outputs reflect that, according to the default primitive polynomial for
GF(3^{3}), the relations below are true.

$$\begin{array}{l}{\alpha}^{0}=1+0\alpha +0{\alpha}^{2}\\ {\alpha}^{1}=0+1\alpha +0{\alpha}^{2}\\ 0+0\alpha +0{\alpha}^{2}+{\alpha}^{3}=2+\alpha +0{\alpha}^{2}\end{array}$$

## Algorithms

`gftuple`

uses recursive callbacks to determine the exponential
format.

## Version History

**Introduced before R2006a**