The storage requirements of conventional enumerative schemes can be reduced by using floating point arithmetical operations instead of the conventional fixed point operations. The enumeration scheme will incur coding loss. The relationship between the storage requirements and the coding loss is derived.

In channel coding schemes we are usually faced with the problem of translating a given source word into another codeword and vice versa that satisfies some prescribed constraints. In the absence of an algorithmic rule defining the relationship between the source word and codeword, the translation operation will be simple look-up tables. As hardware grows with the number of codewords used, i.e. exponentially with the codeword length, there is a technological limit to the length of the words that can be translated using such a simple look-up table.
A preferable alternative technique, called enumerative coding, makes it possible to perform the translation by invoking an algorithmic procedure. Essentially, enumerative decoding is accomplished by forming the weighted sum of the codeword received. The integer-valued weights used in forming the sum are a function of the channel constraints in force. Encoding is done by a method which is similar to decimal-to-binary conversion where, instead of the usual powers of two, the weights are used. The weights are usually pre-computed and stored in a look-up table. Translation using enumeration has the virtue that the complexity (weight storage) grows polynomially with the codeword length. This relationship between complexity and word length can be approximated by, say, n^t, n>>1, where n denotes the word length and t is an arbitrary positive integer. Note that the fixed-point binary representation of each weight requires Rn bits.
In an alternative scheme where a floating point instead of a fixed point representation of the weights is employed, the binary representation of each weight requires e_p bits, where e_p is a fixed integer chosen by the designer. As a result, the complexity grows with n^t-1, which could be beneficial for large n. As a penalty, we will incur some coding loss because the full set of constrained codewords cannot be used.
The article addresses the problem of quantitatively assessing the coding loss in the case of (dk) constrained sequences. We start with a description of the state of the art followed by an exposition of the floating point enumeration scheme. Next, we develop a relationship between the coding loss and the weight storage hardware.

Key Words: enumerative coding, constrained code, recording code, run-length-limited