# 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(pm), where p is prime. To perform equivalent computations in GF(2m), 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(pm) is called “simplest” if all exponents of the primitive element are

• Between 0 and m-1 for the polynomial format

• Either `-Inf`, or between 0 and pm-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 between 0 and `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 earlier parts of this “Description” section, depending on the input arguments.

## Examples

As another example, the `gftuple` command below generates a list of elements of GF(`p^m`), arranged relative to a root of the default primitive polynomial. Some functions in this toolbox use such a list as an input argument.

```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(33), 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.