```--- a/doc/comms.txi
+++ b/doc/comms.txi
@@ -80,7 +80,7 @@

The signal creation functions here fall into to two classes. Those that
treat discrete data and those that treat continuous data. The basic
-function to create discrete data is @dfn{randint}, that creates a
+function to create discrete data is @code{randint}, that creates a
random matrix of equi-probable integers in a desired range. For example

@example
@@ -93,7 +93,7 @@
@end example

creates a 3-by-3 matrix of random integers in the range -1 to 1. To allow
-for repeated analysis with the same random data, the function @dfn{randint}
+for repeated analysis with the same random data, the function @code{randint}
allows the seed-value of the random number generator to be set. For instance

@example
@@ -108,7 +108,7 @@
will always produce the same set of random data. The range of the integers
to produce can either be a two element vector or an integer. In the case
of a two element vector all elements within the defined range can be produced.
-In the case of an integer range @var{M}, @dfn{randint} returns the equi-probable
+In the case of an integer range @var{M}, @code{randint} returns the equi-probable
integers in the range
@tex
\$[0:2^m-1]\$.
@@ -117,7 +117,7 @@
[0:2^@var{m}-1].
@end ifnottex

-The function @dfn{randsrc} differs from @dfn{randint} in that it allows
+The function @code{randsrc} differs from @code{randint} in that it allows
a random set of symbols to be created with a given probability. The symbols
can be real, complex or even characters. However characters and scalars
can not be mixed. For example
@@ -152,12 +152,12 @@

defines that the symbol '1' has a 60% probability, the symbol '1i' has
a 20% probability and the remaining symbols have 10% probability each.
-The sum of the probabilities must equal one. Like @dfn{randint},
-@dfn{randsrc} accepts a fourth argument as the seed of the random
+The sum of the probabilities must equal one. Like @code{randint},
+@code{randsrc} accepts a fourth argument as the seed of the random
number generator allowing the same random set of data to be reproduced.

-The function @dfn{randerr} allows a matrix of random bit errors to be
-created, for binary encoded messages. By default, @dfn{randerr} creates
+The function @code{randerr} allows a matrix of random bit errors to be
+created, for binary encoded messages. By default, @code{randerr} creates
exactly one errors per row, flagged by a non-zero value in the returned
matrix. That is

@@ -173,7 +173,7 @@
@end example

The number of errors per row can be specified as the third argument to
-@dfn{randerr}. This argument can be either a scalar, a row vector or
+@code{randerr}. This argument can be either a scalar, a row vector or
a two row matrix. In the case of a scalar value, exactly this number of
errors will be created per row in the returned matrix. In the case of
a row vector, each element of the row vector gives a possible number of
@@ -190,14 +190,14 @@

creates a vector @var{msg}, encodes it with a [15,11] BCH code, and then
add either none or one error per symbol with the chances of an error being
-30%. As previously, @dfn{randerr} accepts a fourth argument as the seed of
+30%. As previously, @code{randerr} accepts a fourth argument as the seed of
the random number generator allowing the same random set of data to be
reproduced.

All of the above functions work on discrete random signals. The functions
-@dfn{wgn} and @dfn{awgn} create and add white Gaussian noise to continuous
-signals. The function @dfn{wgn} creates a matrix of white Gaussian noise
-of a certain power. A typical call to @dfn{wgn} is then
+@code{wgn} and @code{awgn} create and add white Gaussian noise to continuous
+signals. The function @code{wgn} creates a matrix of white Gaussian noise
+of a certain power. A typical call to @code{wgn} is then

@example
octave:1> nse = wgn(10,10,0);
@@ -219,7 +219,7 @@
octave:1> nse = randn(10,10);
@end example

-The reference impedance and units of power to the function @dfn{wgn}
+The reference impedance and units of power to the function @code{wgn}
can however be modified, for example

@example
@@ -240,7 +240,7 @@
50 Ohm
@end ifnottex
impedance. Matlab uses the misnomer "dB" for "dBW", and therefore "dB" is
-an accepted type for @dfn{wgn} and will be treated as for "dBW".
+an accepted type for @code{wgn} and will be treated as for "dBW".

In all cases, the returned matrix @var{v}, will be related to the input
power @var{p} and the impedance @var{Z} as
@@ -252,7 +252,7 @@
@var{p} = sum(@var{v}(:) .^ 2 ) / @var{imp} Watts
@end ifnottex

-By default @dfn{wgn} produces real vectors of white noise. However, it can
+By default @code{wgn} produces real vectors of white noise. However, it can
produce both real and complex vectors like

@example
@@ -266,7 +266,7 @@

which shows that with a complex return value that the total power is the
same as a real vector, but that it is equally shared between the real and
-imaginary parts. As previously, @dfn{wgn} accepts a fourth numerical argument
+imaginary parts. As previously, @code{wgn} accepts a fourth numerical argument
as the seed of the random number generator allowing the same random set of
data to be reproduced. That is

@@ -277,9 +277,9 @@
will always produce the same set of data.

The final function to deal with the creation of random signals is
-@dfn{awgn}, that adds noise at a certain level relative to a desired
+@code{awgn}, that adds noise at a certain level relative to a desired
signal. This function adds noise at a certain level to a desired
-signal. An example call to @dfn{awgn} is
+signal. An example call to @code{awgn} is

@example
octave:1> x = [0:0.1:2*pi];
@@ -296,28 +296,28 @@
@end ifnotinfo

which adds noise with a 10dB signal-to-noise ratio to the measured power
-in the desired signal. By default @dfn{awgn} assumes that the desired
+in the desired signal. By default @code{awgn} assumes that the desired
signal is at 0dBW, and the noise is added relative to this assumed
-power. This behavior can be modified by the third argument to @dfn{awgn}.
+power. This behavior can be modified by the third argument to @code{awgn}.
If the third argument is a numerical value, it is assumed to define the
power in the input signal, otherwise if the third argument is the string
'measured', as above, the power in the signal is measured prior to the

-The final argument to @dfn{awgn} defines the definition of the power and
-signal-to-noise ratio in a similar manner to @dfn{wgn}. This final
+The final argument to @code{awgn} defines the definition of the power and
+signal-to-noise ratio in a similar manner to @code{wgn}. This final
argument can be either 'dB' or 'linear'. In the first case the numerical
value of the input power is assumed to be in dBW and the signal-to-noise
ratio in dB.  In the second case, the power is assumed to be in Watts
and the signal-to-noise ratio is expressed as a ratio.

-The return value of @dfn{awgn} will be in the same form as the input
+The return value of @code{awgn} will be in the same form as the input
signal. In addition if the input signal is real, the additive noise will
be real. Otherwise the additive noise will also be complex and the noise
will be equally split between the real and imaginary parts.

As previously the seed to the random number generator can be specified
-as the last argument to @dfn{awgn} to allow repetition of the same
+as the last argument to @code{awgn} to allow repetition of the same
scenario. That is

@example
@@ -333,7 +333,7 @@

It is important to be able to evaluate the performance of a
communications system in terms of its bit-error and symbol-error
-rates. Two functions @dfn{biterr} and @dfn{symerr} exist within this
+rates. Two functions @code{biterr} and @code{symerr} exist within this
package to calculate these values, both taking as arguments the
expected and the actually received data. The data takes the form
of matrices or vectors, with each element representing a single
@@ -359,7 +359,7 @@
minimum number of bits needed to represent the largest element in the
two matrices supplied. However, the number of bits per symbol can (and
in the case of random data should) be specified. As an example of the
-use of @dfn{biterr} and @dfn{symerr}, consider the example
+use of @code{biterr} and @code{symerr}, consider the example

@example
octave:1> m = 8;
@@ -378,12 +378,12 @@

Two other means of displaying the integrity of a signal are the
eye-diagram and the scatterplot. Although the functions
-@dfn{eyediagram} and @dfn{scatterplot} have different appearance, the
+@code{eyediagram} and @code{scatterplot} have different appearance, the
information presented is similar and so are their inputs. The difference
-between @dfn{eyediagram} and @dfn{scatterplot} is that @dfn{eyediagram}
+between @code{eyediagram} and @code{scatterplot} is that @code{eyediagram}
segments the data into time intervals and plots the in-phase and
quadrature components of the signal against this time interval. While
-@dfn{scatterplot} uses a parametric plot of quadrature versus in-phase
+@code{scatterplot} uses a parametric plot of quadrature versus in-phase
components.

Both functions can accept real or complex signals in the following
@@ -401,7 +401,7 @@
quadrature components of a complex signal.
@end table

-An example of the use of the function @dfn{eyediagram} is
+An example of the use of the function @code{eyediagram} is

@example
octave:1> n = 50;
@@ -416,14 +416,14 @@

@ifnotinfo
which produces a eye-diagram of a noisy signal as seen in Figure 2. Similarly
-an example of the use of the function @dfn{scatterplot} is
+an example of the use of the function @code{scatterplot} is

@center @image{eyediagram}

@center Figure 2: Eye-diagram of a QPSK like signal with 15dB signal-to-noise ratio
@end ifnotinfo
@ifinfo
-Similarly an example of the use of the function @dfn{scatterplot} is
+Similarly an example of the use of the function @code{scatterplot} is
@end ifinfo

@example
@@ -464,8 +464,8 @@
An important aspect of converting an analog signal to the digital domain
is quantization. This is the process of mapping a continuous signal to a
set of defined values. Octave contains two functions to perform quantization,
-@dfn{lloyds} creates an optimal mapping of the continuous signal to a fixed
-number of levels and @dfn{quantiz} performs the actual quantization.
+@code{lloyds} creates an optimal mapping of the continuous signal to a fixed
+number of levels and @code{quantiz} performs the actual quantization.

The set of quantization points to use is represented by a partitioning
table (@var{table}) of the data and the signal levels (@var{codes} to
@@ -478,15 +478,15 @@
@multitable @columnfractions 0.1 0.4 0.4 0.1
@item @tab x < table(1)               @tab codes(1)   @tab
@item @tab table(1) <= x < table(2)   @tab codes(2)   @tab
-@item @tab ...                        @tab ...       @tab
+@item @tab @dots{}                    @tab @dots{}    @tab
@item @tab table(i-1) <= x < table(i) @tab codes(i)   @tab
-@item @tab ...                        @tab ...       @tab
+@item @tab @dots{}                    @tab @dots{}    @tab
@item @tab table(n-1) <= x < table(n) @tab codes(n)   @tab
@item @tab table(n-1) <= x            @tab codes(n+1) @tab
@end multitable

These partition and coding tables can either be created by the user of
-using the function @dfn{lloyds}. For instance the use of a linear
+using the function @code{lloyds}. For instance the use of a linear
mapping can be seen in the following example.

@example
@@ -500,7 +500,7 @@
@end example

If a training signal is known that well represents the expected signals,
-the quantization levels can be optimized using the @dfn{lloyds} function.
+the quantization levels can be optimized using the @code{lloyds} function.
For example the above example can be continued

@example
@@ -508,16 +508,16 @@
octave:9> [i,z2] = quantiz(y, table2, codes2);
@end example

-Which the mapping suggested by the function @dfn{lloyds}. It should be
-noted that the mapping given by @dfn{lloyds} is highly dependent on the
+Which the mapping suggested by the function @code{lloyds}. It should be
+noted that the mapping given by @code{lloyds} is highly dependent on the
training signal used. So if this signal does not represent a realistic
-signal to be quantized, then the partitioning suggested by @dfn{lloyds}
+signal to be quantized, then the partitioning suggested by @code{lloyds}
will be sub-optimal.

@node PCM Coding, Arithmetic Coding, Quantization, Source Coding
@section PCM Coding

-The DPCM function @dfn{dpcmenco}, @dfn{dpcmdeco} and @dfn{dpcmopt}
+The DPCM function @code{dpcmenco}, @code{dpcmdeco} and @code{dpcmopt}
implement a form of predictive quantization, where the predictability
of the signal is used to further compress it. These functions are
not yet implemented.
@@ -525,16 +525,16 @@
@node Arithmetic Coding, Dynamic Range Compression, PCM Coding, Source Coding
@section Arithmetic Coding

-The arithmetic coding functions @dfn{arithenco} and @dfn{arithdeco} are
+The arithmetic coding functions @code{arithenco} and @code{arithdeco} are
not yet implemented.

@node Dynamic Range Compression, , Arithmetic Coding, Source Coding
@section Dynamic Range Compression

-The final source coding function is @dfn{compand} which is used to
+The final source coding function is @code{compand} which is used to
compress and expand the dynamic range of a signal. For instance
consider a logarithm quantized by a linear partitioning. Such a
-partitioning is very poor for this large dynamic range. @dfn{compand}
+partitioning is very poor for this large dynamic range. @code{compand}
can then be used to compress the signal prior to quantization, with
the signal being expanded afterwards. For example

@@ -554,7 +554,7 @@
0.0053885  0.0029935
@end example

-which demonstrates that the use of @dfn{compand} can significantly
+which demonstrates that the use of @code{compand} can significantly
reduce the distortion due to the quantization of signals with a large
dynamic range.

@@ -728,10 +728,10 @@
the generator or parity check matrix.

The user can create their own generator and parity check matrices, or
-they can rely on the functions @dfn{hammgen}, @dfn{cyclgen} and
-@dfn{cyclpoly}. The function @dfn{hammgen} creates parity check and
-generator matrices for Hamming codes, while @dfn{cyclpoly} and
-@dfn{cyclgen} create generator polynomials and matrices for generic
+they can rely on the functions @code{hammgen}, @code{cyclgen} and
+@code{cyclpoly}. The function @code{hammgen} creates parity check and
+generator matrices for Hamming codes, while @code{cyclpoly} and
+@code{cyclgen} create generator polynomials and matrices for generic
cyclic codes. An example of their use is

@example
@@ -746,14 +746,14 @@
[7,4] Hamming code.

The syndrome table of the codes can be created with the function
-@dfn{syndtable}, in the following manner
+@code{syndtable}, in the following manner

@example
octave:1> [par, gen] = hammgen(3);
octave:2> st = syndtable(par);
@end example

-There exists two auxiliary functions @dfn{gen2par} and @dfn{gfweight},
+There exists two auxiliary functions @code{gen2par} and @code{gfweight},
that convert between generator and parity check matrices and calculate
the Hamming distance of the codes. For instance

@@ -772,8 +772,8 @@
with these codes. These limitations do not apply to the Reed-Solomon
or BCH codes.

-The top-level encode and decode functions are @dfn{encode} and
-@dfn{decode}, which can be used with all codes, except the Reed-Solomon
+The top-level encode and decode functions are @code{encode} and
+@code{decode}, which can be used with all codes, except the Reed-Solomon
code. The basic call to both of these functions passes the message
to code/decode, the codeword length, the message length and the type
of coding to use. There are four basic types that are available with
@@ -792,7 +792,7 @@

It is not possible to distinguish between a binary vector and a decimal
vector coding of the messages that just happens to only have ones and
-zeros. Therefore the functions @dfn{encode} and @dfn{decode} must be
+zeros. Therefore the functions @code{encode} and @code{decode} must be
told the format of the messages in the following manner.

@example
@@ -806,12 +806,12 @@

which codes a binary matrix and a non-binary vector representation of a
message, returning the coded message in the same format. The functions
-@dfn{encode} and @dfn{decode} by default accept binary coded
+@code{encode} and @code{decode} by default accept binary coded
messages. Therefore 'hamming' is equivalent to 'hamming/binary'.

-Except for the BCH codes, the function @dfn{encode} and @dfn{decode}
+Except for the BCH codes, the function @code{encode} and @code{decode}
internally create the generator, parity check and syndrome table
-matrices.  Therefore if repeated calls to @dfn{encode} and @dfn{decode}
+matrices.  Therefore if repeated calls to @code{encode} and @code{decode}
are made it will often be faster to create these matrices externally,
and pass them as an argument. For example

@@ -828,7 +828,7 @@
@end example

In the case of the BCH codes the low-level functions described in the
-next section are used directly by the @dfn{encode} and @dfn{decode}
+next section are used directly by the @code{encode} and @code{decode}
functions.

@@ -840,7 +840,7 @@
and has been converted for use as an Octave oct-file.

@iftex
-Called without arguments, @dfn{bchpoly} returns a table of valid BCH
+Called without arguments, @code{bchpoly} returns a table of valid BCH
error correcting codes and their error-correction capability
as seen in Table 1.

@@ -884,12 +884,12 @@

@end iftex
@ifnottex
-Called without arguments, @dfn{bchpoly} returns a table of valid BCH
+Called without arguments, @code{bchpoly} returns a table of valid BCH
error correcting codes and their error-correction capability.
@end ifnottex
-The first returned column of @dfn{bchpoly} is the codeword length,
+The first returned column of @code{bchpoly} is the codeword length,
the second the message length and the third the error correction capability
-of the code. Called with one argument, @dfn{bchpoly} returns similar
+of the code. Called with one argument, @code{bchpoly} returns similar
output, but only for the specified codeword length. In this manner codes
with codeword length greater than 511 can be found.

@@ -898,7 +898,7 @@
code, then it is also possible to use a shortened BCH form of the form
@code{[@var{n}-@var{x},@var{k}-@var{x}]}.

-With two or more arguments, @dfn{bchpoly} is used to find the generator
+With two or more arguments, @code{bchpoly} is used to find the generator
polynomial of a valid BCH code. For instance

@example
@@ -940,13 +940,13 @@
@end example

It is recommend not to convert the generator polynomials created by
-@dfn{bchpoly} into generator and parity check matrices with the
+@code{bchpoly} into generator and parity check matrices with the
BCH codes, as the underlying BCH software is faster than the generic
coding software and can treat significantly longer codes.

-As well as using the @dfn{encode} and @dfn{decode} functions previously
+As well as using the @code{encode} and @code{decode} functions previously
discussed, the user can directly use the low-level BCH functions
-@dfn{bchenco} and @dfn{bchdeco}. In this case the messages must be
+@code{bchenco} and @code{bchdeco}. In this case the messages must be
in the format of a binary matrix with @var{k} columns

@example
@@ -1031,7 +1031,7 @@
GF(2^M). Normally, The order of the Galois Field (M), is related to the
codeword length by @code{@var{n} = 2^@var{m} - 1}. Another important
parameter when determining the behavior of the Reed-Solomon coder is
-the primitive polynomial of the Galois Field (see @dfn{gf}). Thus
+the primitive polynomial of the Galois Field (see @code{gf}). Thus
the messages

@example
@@ -1049,10 +1049,10 @@
determine which end of the message is the most-significant term of the
polynomial representing the message. The parity symbols are therefore
different in these two cases. The position of the parity symbols can be
-chosen by specifying 'beginning' or 'end' to @dfn{rsenc} and @dfn{rsdec}.
+chosen by specifying 'beginning' or 'end' to @code{rsenc} and @code{rsdec}.
By default the parity symbols are placed after the message.

-Valid generator polynomials can be constructed with the @dfn{rsgenpoly}
+Valid generator polynomials can be constructed with the @code{rsgenpoly}
function. The roots of the generator polynomial are then defined by

@tex
@@ -1063,16 +1063,16 @@
@ifnottex

@example
-@var{g} = (@var{x} - A^(@var{b}*@var{s})) * (@var{x} - A^((@var{b}+1)*@var{s})) * ... * (@var{x} - A^((@var{b}+2*@var{t}-1)*@var{s})).
+@var{g} = (@var{x} - A^(@var{b}*@var{s})) * (@var{x} - A^((@var{b}+1)*@var{s})) * @dots{} * (@var{x} - A^((@var{b}+2*@var{t}-1)*@var{s})).
@end example
@end ifnottex

where @var{t} is @code{(@var{n}-@var{k})/2}, A is the primitive element
of the Galois Field, @var{b} is the first consecutive root, and @var{s}
is the step between roots. Generator polynomial of this form are constructed
-by @dfn{rsgenpoly} and can be passed to both @dfn{rsenc} and @dfn{rsdec}.
+by @code{rsgenpoly} and can be passed to both @code{rsenc} and @code{rsdec}.
It is also possible to pass the @var{b} and @var{s} values directly to
-@dfn{rsenc} and @dfn{rsdec}. In the case of @dfn{rsdec} passing @var{b}
+@code{rsenc} and @code{rsdec}. In the case of @code{rsdec} passing @var{b}
and @var{s} can make the decoding faster.

Consider the example below.
@@ -1293,7 +1293,7 @@
error: evaluating assignment expression near line 3, column 3
@end example

-The function @dfn{gftable} is included for compatibility with Matlab. In
+The function @code{gftable} is included for compatibility with Matlab. In
Matlab this function is used to create the lookup tables used to accelerate
the computations over the Galois Field and store them to a file. However
Octave stores these parameters for all of the fields currently in use and
@@ -1305,7 +1305,7 @@
The function @code{gf(@var{a},@var{m})} creates a Galois Field using the default primitive
polynomial. However there exists many possible primitive polynomials for most
Galois Fields. Two functions exist for identifying primitive polynomials,
-@dfn{isprimitive} and @dfn{primpoly}. @code{primpoly(@var{m},@var{opt})} is
+@code{isprimitive} and @code{primpoly}. @code{primpoly(@var{m},@var{opt})} is
used to identify the primitive polynomials of the fields GF(2^M). For example

@example
@@ -1337,7 +1337,7 @@
@end example

while @code{primpoly(@var{m},"max")} returns the maximum primitive polynomial
-of the field, which for the case above is 25. The function @dfn{primpoly}
+of the field, which for the case above is 25. The function @code{primpoly}
can also be used to identify the primitive polynomials having only a
certain number of non-zero terms. For instance

@@ -1356,7 +1356,7 @@

identifies the polynomials with only three terms that can be used as
primitive polynomials of GF(2^5). If no primitive polynomials existing
-having the requested number of terms then @dfn{primpoly} returns an
+having the requested number of terms then @code{primpoly} returns an
empty vector. That is

@example
@@ -1366,7 +1366,7 @@
ans = [](1x0)
@end example

-As can be seen above, @dfn{primpoly} displays the polynomial forms the
+As can be seen above, @code{primpoly} displays the polynomial forms the
the polynomials that it finds. This output can be suppressed with the
'nodisplay' option, while the returned value is left unchanged.

@@ -1381,8 +1381,8 @@
be used as primitive polynomials of the Galois Fields GF(2^M). Consider
as an example the fields GF(2^4). The primitive polynomials of these fields
must have an order m and so their integer representation must be between
-16 and 31. Therefore @dfn{isprimitive} can be used in a similar manner to
-@dfn{primpoly} as follows
+16 and 31. Therefore @code{isprimitive} can be used in a similar manner to
+@code{primpoly} as follows

@example
octave:1> find(isprimitive(16:31)) + 15
@@ -1447,7 +1447,7 @@

An important consideration in the use of the Galois Field package is
-that many of the internal functions of Octave, such as @dfn{roots}, can
+that many of the internal functions of Octave, such as @code{roots}, can
not accept Galois Fields as an input. This package therefore uses Octave
classes to @emph{overload} the internal Octave functions with equivalent
functions that work with Galois Fields, so that the standard function names
@@ -1457,14 +1457,14 @@
argument of the function. This is a temporary situation until the
Galois Field class constructor can be rewritten to allow the use of the
@code{superiorto} function to define the galois class with a higher
-precedence. So, considering the @dfn{filter} function,
+precedence. So, considering the @code{filter} function,
if the first argument is a @emph{Matrix}, then the normal version of
the function is called regardless of whether the other arguments of the
function are Galois vectors or not.

Other Octave functions work correctly with Galois Fields and so overloaded
-versions are not necessary. This include such functions as @dfn{size} and
-@dfn{polyval}.
+versions are not necessary. This include such functions as @code{size} and
+@code{polyval}.

It is also useful to use the '.x' option discussed in the previous section,
to extract the raw data of the Galois field for use with some functions. An
@@ -1511,7 +1511,7 @@

where @var{a} is a Galois variable. To reload the variable within
Octave, the Galois type must be installed prior to a call to

@example
octave:1> dummy = gf(1);
@@ -1878,7 +1878,7 @@
@end example

To test if any or all of the values in a Galois array are non-zero, the
-functions @dfn{any} and @dfn{all} can be used as normally.
+functions @code{any} and @code{all} can be used as normally.

In addition the comparison operators @code{>}, @code{>=}, @code{<} and
@code{<=} are available. As elements of the Galois Field are modulus
@@ -1966,7 +1966,7 @@
operation to the multiplication.

To evaluate a polynomial for a certain value in GF(2^M), use the Octave
-function @dfn{polyval}.
+function @code{polyval}.

@example
octave:1> poly1 = gf([2, 4, 5, 1],3);  ## a*x^3+a^2*x^2+(a^2+1)*x+1
@@ -1990,7 +1990,7 @@
@end example

It is equally possible to find the roots of Galois polynomials with the
-@dfn{roots} function. Using the polynomial above over GF(2^3), we can
+@code{roots} function. Using the polynomial above over GF(2^3), we can
find its roots in the following manner

@example
@@ -2007,7 +2007,7 @@
@end example

Thus the example polynomial has 3 roots in GF(2^3) with one root of
-multiplicity 2. We can check this answer with the @dfn{polyval} function
+multiplicity 2. We can check this answer with the @code{polyval} function
as follows

@example
@@ -2043,7 +2043,7 @@
The minimum polynomial of an element of GF(2^M) is the minimum degree
polynomial in GF(2), excluding the trivial zero polynomial, that has
that element as a root. The fact that the minimum polynomial is in GF(2)
-means that its coefficients are one or zero only. The @dfn{minpol}
+means that its coefficients are one or zero only. The @code{minpol}
function can be used to find the minimum polynomial as follows

@example
@@ -2060,7 +2060,7 @@
Note that the minimum polynomial of the primitive element is the primitive
polynomial. Elements of GF(2^M) sharing the same minimum polynomial form a
partitioning of the field. This partitioning can be found with the
-@dfn{cosets} function as follows
+@code{cosets} function as follows

@example
octave:1> c = cosets(3)
@@ -2092,7 +2092,7 @@

which returns a cell array containing all of the elements of the GF(2^3),
partitioned into groups sharing the same minimum polynomial. The function
-@dfn{cosets} can equally accept a second argument defining the primitive
+@code{cosets} can equally accept a second argument defining the primitive
polynomial to use in its calculations (i.e. @code{cosets(@var{a},@var{p})}).

@node Linear Algebra, Signal Processing, Polynomial manipulations, Manipulating Galois Fields
@@ -2154,7 +2154,7 @@

Signal processing functions such as filtering, convolution, de-convolution
and Fourier transforms can be performed over Galois Fields. For instance
-the @dfn{filter} function can be used with Galois vectors in the same
+the @code{filter} function can be used with Galois vectors in the same
manner as usual. For instance

@example
@@ -2173,13 +2173,13 @@
gives the impulse response of the filter defined by @var{a} and @var{b}.

Two equivalent ways are given to perform the convolution of two Galois
-vectors. Firstly the function @dfn{conv} can be used, or alternatively
-the function @dfn{convmtx} can be used. The first of these function is
+vectors. Firstly the function @code{conv} can be used, or alternatively
+the function @code{convmtx} can be used. The first of these function is
identical to the convolution function over real vectors, and has been
described in the section about multiplying two Galois polynomials.

In the case where many Galois vectors will be convolved with the same
-vector, the second function @dfn{convmtx} offers an alternative method
+vector, the second function @code{convmtx} offers an alternative method
to calculate the convolution. If @var{a} is a column vector and @var{x}
is a column vector of length @var{n}, then

@@ -2198,12 +2198,12 @@

The final signal processing function available in this package are the
functions to perform Fourier transforms over a Galois field. Three
-functions are available, @dfn{fft}, @dfn{ifft} and @dfn{dftmtx}. The
+functions are available, @code{fft}, @code{ifft} and @code{dftmtx}. The
first two functions use the third to perform their work. Given an element
-@var{a} of the Galois field GF(2^M), @dfn{dftmtx} returns the @code{2^M - 1}
+@var{a} of the Galois field GF(2^M), @code{dftmtx} returns the @code{2^M - 1}
square matrix used in the Fourier transforms with respect to @var{a}. The
minimum polynomial of @var{a} must be primitive in GF(2^M). In the case of
-the @dfn{fft} function @dfn{dftmtx} is called with the primitive element of
+the @code{fft} function @code{dftmtx} is called with the primitive element of
the Galois Field as an argument. As an example

@example
@@ -2220,7 +2220,7 @@
@end example

In all cases, the length of the vector to be transformed must be
-@code{2^M -1}. As the @dfn{dftmtx} creates a matrix representing the
+@code{2^M -1}. As the @code{dftmtx} creates a matrix representing the
Fourier transform, to limit the computational task only Fourier
transforms in GF(2^M), where M is less than or equal to 8, can be treated.

```