--- 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
 addition of the noise.
 
-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 @@
 @subsection Function Overloading
 
 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
-@dfn{load}. That is
+@code{load}. That is
 
 @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.