Abstract:
An improved method of generating a compressed representation of a source data string, each symbol of which is taken from a finite set of m+1 symbols, a o  to a m . The method is based on an arithmetic coding procedure wherein the source data string is recursively generated as successive subintervals within a predetermined interval. The width of each subinterval is theoretically equal to the width of the previous subinterval multiplied by the probability of the current symbol. The improvement derives from approximating the width of the previous subinterval so that the approximation can be achieved by a single SHIFT and ADD operation using a suitable shift register.

Description:
FIELD OF THE INVENTION 
     This invention relates to a method of generating a compressed representation of a source data string. By &#34;compression&#34; is meant reducing the amount of data associated with the source data string without reducing its information content so that output data may be constructed having a lower data content than the original source data, while still permitting the source data in its entirety to be reconstructed. In particular, the invention relates to a method for high efficiency, multiplication-free arithmetic coding. Arithmetic coding is a technique which is commonly employed in order to compress data in data processing systems. 
     BACKGROUND OF THE INVENTION 
     Such compression is rendered possible by the high degree of intercorrelation and nonuniform statistical distribution associated with the symbols usually characterizing large data bases. When the source data is represented in digital form, the object of compression is to produce an output string of data having fewer data bits than the original source data string. When a statistically significant sample of source data strings is compressed, the expected length of the compressed output data string corresponds to the &#34;entropy&#34; of the source data string. 
     One way to achieve compression of source data is by means of the arithmetic coder developed by Jorma Rissanen and first published in an article entitled &#34;Generalized Kraft Inequality Arithmetic Coding&#34;, IBM Journal of Research and Development, Vol. 20, No. 3, May 1976. The arithmetic coding procedure introduced by Rissanen permits the compression of multi-alphabet data, i.e., data each of whose symbols may be found within a multi-symbol alphabet. 
     In order to employ an arithmetic coding procedure, it is first necessary to determine the probability of occurrence for each symbol within the source alphabet. Typically, the probabilities will vary from one source data string to another, so that if, for example, an arithmetic coding procedure is being used to compress the data corresponding to a television image, the probabilities of occurrence for each picture element must first be determined. This may be determined in real time or, alternatively, may be predetermined statistically. However, the actual method for determining these probabilities is not a feature of the present invention which is equally applicable regardless of how the probabilities are determined. 
     Having determined the probabilities of occurrence for each different symbol within the source alphabet, the cumulative probability for each symbol may then be determined. Thus, the cumulative probability S(1) for the first symbol of the data string will be equal to zero and, in general, the cumulative probability S(n) for the nth symbol will be equal to the sum of the probabilities of occurrence for each of the preceding n-1 symbols. 
     Arithmetic coding procedures normally represent the output data string as a binary fraction within the unit interval (0,1). As explained by G. Langdon in &#34;An Introduction to Arithmetic Coding&#34;, IBM Journal of Research and Development, Vol. 28, No. 2, Mar. 1984, arithmetic coding is related to the process of subdividing the unit interval. This subdivision is achieved by marking along the unit interval code points C n  for each symbol within the source alphabet, each code point being equal to the sum of the probabilities of occurrence of the preceding symbols. The width or size A n  of the subinterval to the right of each code point represents the probability of occurrence of the source data string up to the corresponding symbol (FIG. 1). 
     Consider, for example, a source data string whose alphabet comprises symbols a 0  to a m , having probabilities of occurrence equal to p(0) to p(m), respectively. If the source data string is a a 0  a 5  a 3  . . . , then the first symbol a 0  will be encoded within the subinterval (0,p(0)). This represents a first subinterval within the original unit interval whose width A 1  is equal to p(0) corresponding simply to the probability of occurrence of symbol a 0 . In order to encode the second symbol a 5  of the source data string, its probability of occurrence, conditional on the probability of symbol a 0  occurring, must be determined. Furthermore, the cumulative probability S(5) associated with the second symbol a 5  must be calculated. Thus, the subinterval corresponding to the second symbol a is a second subinterval within the first subinterval corresponding to a 0 . Mathematically, the width A 2  of the second subinterval is equal to p(0)*p(5), i.e., the product of the probabilities of occurrence of both symbols a 0  and a 5 . The starting point of the second subinterval within the unit interval depends on the width A 1  of the first subinterval and the cumulative probability S(5) associated with the second symbol a being equal to their product A 1  *S(5). 
     Thus, as each symbol of the source data string is successively encoded within the unit interval, a succession of subintervals is generated, each of which may be specified in terms of a specific code point and width. The code point for the current subinterval corresponds to the start of the current subinterval within the previous interval or subinterval. As explained above, this is equal to the cumulative probability associated with the current symbol. Thus, the code point associated with the nth subinterval will be equal to the width of the n-1th subinterval multiplied by the cumulative probability of the preceding n-1 symbols, i.e., A n  S(n). The width of the new subinterval itself will be equal to the product of the probabilities of all symbols (including the current one) so far encoded, i.e., p(0)*p(5)*p(3) . . . , for the above source data string. The data corresponding to the width A n  and code points C n  of the nth subinterval thus encode the first n+1 symbols in the source data string. Arithmetic coders therefore require two memory registers, usually called the A and C registers, for storing these data. 
     Since the width of the subinterval is equal to a product of probabilities, two factors emerge. First, as more symbols of the source data string are encoded, the width of the subinterval defining the arithmetic code representation will decrease (since each individual probability must necessarily be smaller than 1); and, furthermore, the process of arithmetic coding requires a succession of multiplication operations for its effective implementation. 
     Although arithmetic coders produce optimum compression corresponding to the entropy of the source data string, when based on the exact probabilities of occurrence of the symbols constituting the data string, prior implementations of arithmetic coding procedures have tended to introduce approximations on account of the difficulty in determining the exact probabilities Such approximations reduce the efficiency of the arithmetic coding operation and result in an output data string being generated which has more symbols than the theoretical minimum, or entropy. Moreover, further approximations have been introduced in order to eliminate the multiplication operation, which is required for determining the width of each successive subinterval. 
     Arithmetic coders are implemented on computers whose memory registers contain a finite number of bits. One problem associated with multiplication results from the fact that, since the successive multiplication of probabilities always produces smaller and smaller intervals, after only a few such multiplications the resulting subinterval may be too small to be satisfactorily stored in the computer register. For example, if each register has 16 bits and the multiplication of successive probabilities results in a number smaller than 2 -16 , this number will underflow the register. In other words, the register will be full of zeros, the significant bits of the probability product being lost. A further problem associated with successive multiplication operations is the time taken for these to be implemented. 
     The first of the above drawbacks has been solved using a technique called normalization, whereby the probability product is stored in floating point notation. In order to do this, a further bit register is employed for storing the exponent (to base 2) for the width of the subinterval when the most significant 1 of the binary fraction is shifted to the extreme leftmost position Thus, the binary fraction 1.0101×2 -20  which clearly cannot be stored in a 16-bit register, may satisfactorily be stored as 1.0101E-20, wherein the mantissa and the exponent are stored in separate registers. Since the most significant bit of the mantissa is thus arranged always to be 1, the actual number stored in the mantissa register will always be greater than 1.0. 
     The second problem described above and related to the time taken to perform multiplication operations has to some extent been solved by the implementation of so-called &#34;multiplication-free&#34; arithmetic coders. In computers which employ binary arithmetic, multiplication is implemented as a series of SHIFT and ADD operations. The term &#34;multiplication-free&#34; has variously been used in the prior art to imply either a single SHIFT or a single SHIFT and ADD operation for each coding step. Strictly speaking, mathematically even a single SHIFT operation constitutes multiplication. However, this is many orders of magnitude less time consuming than the multiplication operations associated with precise implementations of arithmetic coders involving multiple SHIFT and ADD operations. Thus, &#34;multiplication-free&#34; is often used to denote that multiplication operations are significantly simplified or reduced. It is in this context that &#34;multiplication-free&#34; has been used in the prior art and is used in the present invention. 
     Langdon et al., U.S. Pat. No. 4,286,256, &#34;Method and Means for Arithmetic Coding Utilizing a Reduced Number of Operations&#34;, issued Aug. 25, 1981, simplify the multiplication operation by truncating one of the inner products corresponding to the width of the subinterval prior to encoding the current codepoint. However, Langdon&#39;s method is suitable only for binary sources (i.e., alphabets containing only two symbols), wherein it is possible to encode each symbol of the source data string either as a more probable or less probable event. This procedure is unsuitable for multi-alphabet codes. 
     Mohiuddin et al., U.S. Pat. No. 4,652,856, &#34;Multiplication-free Multi-alphabet Arithmetic Code&#34;, issued Mar. 24, 1987, disclose an arithmetic code in which each subinterval is stored in floating point format, as explained above, such that the mantissa stored within the A register is a binary fraction greater than 0.1. In accordance with the approximation proposed by Mohiuddin, a variable criterion is adopted which either truncates the mantissa of the subinterval to exactly 0.1 (binary) or, alternatively, rounds it up to 1. Such an approximation still achieves the desired compression, but at a loss of efficiency. In other words, more bits than the minimum are required for representing the compressed data string. The inefficiency associated with Mohiuddin&#39;s procedure depends on the nature of the source data being compressed. 
     The major drawback with Mohiuddin results from the fact that rounding up the contents of the A register approximates the probability of the corresponding symbol to a value greater than its actual value. In order to ensure that the sum of the probabilities for all symbols in the alphabet cannot exceed 1.0, Mohiddiun approximates the last subinterval to ##EQU1## 
     While this approximation ensures that the sum of the probabilities of all symbols in the alphabet is equal to 1, it can achieve this at the expense of rendering the last subinterval so small that the coding is highly inefficient. 
     SUMMARY OF THE INVENTION 
     It is an object of this invention to provide a method for high efficiency, multiplication-free arithmetic coding wherein the disadvantages associated with prior art methods are significantly reduced or eliminated. 
     According to the invention, there is provided a method of generating a compressed representation R(comp) of a source data string STR, wherein: 
     each symbol is taken from a finite set of m+1 symbols a 0  . . . a m , 
     said compressed representation being a numeric value within a given range and being generated recursively in successive cycles for successive symbols in the string, 
     a probability value p(i) and a cumulative probability value S(i) being available for each symbol a i , 
     said cumulative probability value being ##EQU2##  and using a pair of shift registers A and C, each comprising ω binary digit positions, 
     the improvement comprising the steps of: 
     (a) initially setting the contents of the C register to all zeros and the contents of the A register to a predetermined value; and 
     for each successive symbol a i  in the string: 
     (b) determining a scaling factor K by taking the contents of the A register and eliminating all binary digits less significant than a predetermined binary one digit; 
     (c) adding the value K*S(i) to the contents of the C register; 
     (d) determining the contents of the A register: 
     (d1) if the symbol a i  is not the symbol a m  by inserting the value K*p(i) into the A register, or 
     (d2) if the symbol a i  is the symbol a m , by subtracting the value K*S(i) from the contents of the A register; 
     (e) shifting both the A register and the C register in a predetermined direction until the contents of the A register lie within a predetermined range, filling the vacated positions with zeros; and 
     (f) if the symbol a i  is not the last symbol in string STR, repeating steps (b)-(e) or, if the symbol a i  is the last symbol in string STR, shifting the contents of the C register by ω positions in said predetermined direction; 
     whereby the sequence of binary digits shifted out of the C register constitutes said compressed representation R(comp) of the symbol string STR. 
     Thus, in accordance with the invention, each symbol within the source data string STR is successively coded, the representative compressed code thereof being shifted out of the C register for post-processing as required. Typically, the compressed data which is successively read from the C register is transmitted to a suitable decoder which decodes the compressed string so as to reconstruct the original source data string STR. In common with the prior art arithmetic encoders referred to above, the method according to the invention is a first-in/first-out (FIFO) routine, whereby the first symbol in the source data string STR is also the first symbol to be encoded. 
     In a preferred embodiment, the A register is initialized to a value of 1.000, the compressed arithmetic code then being a value between 0 and 1. 
     Since each symbol within the source data string STR is encoded successively, it may occur that the code developed for subsequent symbols of the source data string STR will affect the code already generated for a previous symbol, owing to the effect of &#34;carry over&#34;. The effect of carry over is well known in the literature. Several solutions to the problem have been published, any one of which may suitably be used in conjunction with the proposed invention. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The invention will now be described with regard to a method for generating a compressed representation R(comp) of a source data string STR, each symbol of which is taken from a finite set of m+1 symbols, and with reference to the accompanying drawings. 
     FIG. 1 illustrates, for an example of an ordered symbol set comprising five symbols, the probabilities and the resulting cumulative probabilities. 
     FIG. 2 is a flow diagram showing a coding procedure according to the invention. 
     FIG. 3 relates to FIG. 2 and illustrates the flow of data between registers when performing the coding procedure according to FIG. 2. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     FIG. 1 shows a table of probabilities p(i) and resulting cumulative probabilities S(i) for an ordered symbol set comprising five symbols, a 0  to a 4 , together with the corresponding code points C n  plotted on the unit interval (0,1). As explained above, the process of recursively encoding successive symbols of a symbol set as a subinterval within the unit interval from the probabilities p(i) and the cumulative probabilities S(i) for the symbol a i  to be encoded, is a characteristic feature of arithmetic coding procedures per se. 
     Referring now to FIG. 2, there is shown a flow diagram of an encoding procedure according to the invention. The four main steps of the procedure are numbered (1)-(4), inclusive, for reasons which will become apparent below with reference to FIG. 3 of the drawings. 
     It is seen that at the start of the procedure, the C register is set to 0.000 and the A register is set to 1.000. In step (1), the probability p(i) and cumulative probability S(i) are determined for each symbol a i  in the source data string STR. This can be done using any one of several known procedures. Alternatively, a fixed, predetermined set of probability values may be employed. A scaling factor K is then determined, as shown in step (2), by taking the contents of the A register and eliminating all binary digits less significant than the second most: significant binary 1 digit. The A register represents the width of the current subinterval, the scaling factor K being, in effect, an approximation of the width of the current subinterval. This width is normalized between 1.0000 (binary) and 1.1111 . . . , and the scaling factor K is merely an approximation for the value of the A register, eliminating all ones less significant than the second. 
     In the description which follows, the symbols of the finite set of m+1 symbols are designated as a 0 ,a 1 , . . . ,a m . The probability and cumulative probability for the symbol a i  is designated p(i) and S(i), respectively. Thus for example, if the eighth symbol of the multi-symbol alphabet is &#34;h&#34;, then a 8  =h and the respective probabilities are p(8) and S(8). 
     Step (3) shows that for each symbol in the source data string STR, the product of K and S(i) is added to the C register, and the A register is set to the product K*p(i) if i&lt;m and is reduced by the product K*S(m) if i=m. Thus, where the current symbol to be encoded does not correspond to the last symbol a m  within the multi-symbol alphabet, the A register is set simply to the probability of the current symbol times K, being an approximation for the width of the current subinterval. On the other hand, when the current symbol to be encoded corresponds to the last symbol of the alphabet, the value of the A register is reduced by the product of K times the cumulative probabilitY of the last symbol of the alphabet. This compensates for the fact that the probabilities p(i) are only approximate and, in effect, ensures that the sum of the probabilities of all the symbols in the multi-symbol alphabet is equal to 1. This follows since for the mth symbol of the alphabet: A←A-K*S(m), and since K is an approximation for A: A←A-A*S(m). ##EQU3## 
     Step (4) in the algorithm is to normalize the A register so that its contents lie within a predetermined range. In order to do this, the contents of the A register are multiplied by an appropriate multiple of 2. This is achieved by a simple SHIFT operation by means of which the contents of the A register are shifted left by a specified number of bits, depending on the present contents of the A register. The C register is then shifted left by the same number of bits, the most significant bits thereof being read from the C register and constituting part of the arithmetic code for the source data string STR. This procedure is repeated for all symbols in the source data string STR and, on completion, the complete contents of the C register are shifted out of the C register and concatenated to the previously generated code string, the resulting code string representing the compressed output data string. 
     It will thus be seen that the method according to the invention generates a compressed output data string recursively for each symbol within the source data string STR. As the code is generated, it is shifted out of the C register while, at the same time, normalizing the A register. 
     The method according to the invention will perhaps best be understood with reference to the following example. 
     EXAMPLE 
     A source data string is to be derived from a 5-symbol alphabet having symbols a 0  to a 4  equal to a,b,c,d,e, respectively, with probabilities (in binary) as follows: 
     
         ______________________________________p(0) = 0.000001p(1) = 0.000011p(2) = 0.000110p(3) = 0.001010p(4) = 0.101100______________________________________ 
    
     Thus, the number of symbols m+1 in the multi-system alphabet is equal to 5, and it may be verified that the sum of the probabilities is equal to one, i.e: ##EQU4## 
     The cumulative probabilities for each symbol are as follows: 
     
         ______________________________________S(0) = 0.000000S(1) = 0.000001S(2) = 0.000100S(3) = 0.001010S(4) = 0.010100______________________________________ 
    
     Using the method in accordance with the preferred embodiment as described above, encode the source data string given by: STR=b,c,e,d,a,c,b, in conjunction with 6-bit A and C registers. 
     Proceed as follows: initialize the A register to 1.00000 and the C register to 0.000000. 
     It will be appreciated that the binary point is understood, the actual contents of the A and C registers being 100000 and 000000, respectively. 
     Encode first symbol b (=a 1 ): 
     
         ______________________________________K         = 1,          i      = 1 ≠ mp(1)      = 000011      S(1)   = 000001C = 0.0 + 1.0 × 0.000001 = 0.000001______________________________________ 
    
     giving: 
     
         ______________________________________   A     C______________________________________   .000011         .000001______________________________________ 
    
     Normalize A and shift C: 
     
         ______________________________________   A     C______________________________________   1.10000         00000.100000______________________________________ 
    
     where the binary point denotes the boundary of the C register. Thus, the five binary bits 00000 to the left of the binary point denote the first five bits of the resultant arithmetic code shifted out of the C register, while the six binary bits 100000 to the right of the binary point denote the new contents of the C register. Note that the contents of both the A and C registers are right-packed with zeros after the corresponding left shifts. Since the symbol is not the end of the string STR, processing continues. 
     Encode second symbol c (=a 2 ): 
     
         ______________________________________K         = 1.1         i      = 2 ≠ mp(2)      = 000110      S(2)   = 000100C = 0.100000 + 1.1 × 0.0001 = 0.10011______________________________________ 
    
     giving: 
     
         ______________________________________  A     C______________________________________  .001001        00000.100110______________________________________ 
    
     Normalize A and shift C: 
     
         ______________________________________A           C______________________________________1.00100     00000100.110000______________________________________ 
    
     Since this symbol is not the end of the string STR, processing continues. 
     Encode third symbol e (=a 4 ): 
     
         ______________________________________K         = 1.001       i      = 4 = mp(4)      = 101100      S(4)   = 010100______________________________________ 
    
     Since C&gt;1, the leading 1 generates carry-over, giving: 
     
         ______________________________________A           C______________________________________.110010     00000101.000110______________________________________ 
    
     Normalize A and shift C: 
     
         ______________________________________A           C______________________________________1.10010     000001010.001100______________________________________ 
    
     Since this symbol is not the end of the string STR, processing continues. 
     Encode fourth symbol d (=a 3 ): 
     
         ______________________________________K         = 1.1         i      = 3 ≠ mp(3)      = 001010      S(3)   = 001010C = 0.001100 + 1.1 × 0.00101 = 0.011011______________________________________ 
    
     giving: 
     
         ______________________________________A           C______________________________________.001111     000001010.011011______________________________________ 
    
     Normalize A and shift C: 
     
         ______________________________________A           C______________________________________1.11100     000001010011.011000______________________________________ 
    
     Since this symbol is not the end of the string STR, processing continues. 
     Encode fifth symbol a (=a 0 ): 
     
         ______________________________________K         = 1.1         i      = 0 ≠ mp(0)      = 000001      S(0)   = 000000C = 0.011000 + 0.0 = 0.011000______________________________________ 
    
     giving: 
     
         ______________________________________A           C______________________________________.000001     000001010011.011000______________________________________ 
    
     Normalize A and shift C: 
     
         ______________________________________A          C______________________________________1.00000    000001010011011000.000000______________________________________ 
    
     Since this symbol is not the end of the string STR, processing continues. 
     Encode sixth symbol c (=a 2 ): 
     
         ______________________________________K         = 1.0         i      = 2 ≠ mp(2)      = 000110      S(2)   = 000100C = 0.0 + 1.0 × 0.000100 = 0.000100______________________________________ 
    
     giving: 
     
         ______________________________________A          C______________________________________.000110    000001010011011000.000100______________________________________ 
    
     Normalize A and shift C: 
     
         ______________________________________A         C______________________________________1.10000   0000010100110110000001.000000______________________________________ 
    
     Since this symbol is not the end of the string STR, processing continues. 
     Encode seventh symbol b (=a 1 ): 
     
         ______________________________________K         = 1.1         i      = 1 ≠ mp(1)      = 000011      S(1)   = 000001C = 0.0 + 1.1 × 0.000001 = 0.000001______________________________________ 
    
     giving: 
     
         ______________________________________A         C______________________________________.000100   0000010100110110000001.000001______________________________________ 
    
     Normalize A and shift C: 
     
         ______________________________________A        C______________________________________1.00000  00000101001101100000010000.010000______________________________________ 
    
     Since this is the last symbol in the string STR, now shift the contents of the C register left six places to produce the complete output string: 
     C=00000101001101100000010000010000 
     FIG. 3 shows the flow of data between the registers for each of the steps (1)-(4) of the procedure described above with reference to FIG. 2. 
     Thus, during step (1) of the encoding procedure, each symbol a i  in turn is extracted from the INPUT string, a flag &#34;END&#34; being generated to indicate whether or not the symbol a i  is the last symbol in the INPUT string. The symbol a i  is input to a TABLE OF PROBABILITIES which may constantly be updated so as to derive therefrom the probabilities p(i) and S(i). A flag &#34;i=m&#34; is also generated and indicates whether or not the symbol a 1  corresponds to the last symbol of the source alphabet. 
     During step (2), the contents of the A register are truncated in order to provide the scaling factor K. 
     During step (3), the values of p(i) and S(i) are multiplied by the value of K derived in step (2) using a single SHIFT and ADD operation, generating the values K*p(i) and K*S(i), respectively, which are stored in temporary buffers as shown. The values of A and K*S(i) are fed to a SUBTRACTOR whose output is equal to A-K*S(i). Likewise, the values of C and K*S(i) are fed to an ADDER whose output is equal to C+K*S(i). The output A-K*S(i) from the SUBTRACTOR and the value of K*p(i) are fed to a SELECT logic unit together with the value of the flag &#34;i=m&#34;. The output from the SELECT unit is equal to K*p(i) if i≠m, and to A-K*S(i) if i=m. 
     Finally, during step (4) a SHIFT CONTROL unit shifts the A and C registers until the contents of the A register lie within a specified range, when a STOP flag is generated, thereby stopping the SHIFT operations. The &#34;END&#34; flag derived from step (1) is fed to the SHIFT CONTROL unit, so that at the end of the INPUT string, the SHIFT CONTROL unit shifts the C register six places (6-bit A and C registers being employed), thereby emptying the C register. As the C register is shifted by the SHIFT CONTROL unit in response to the STOP or END flags-, the data shifted out of the C register are concatenated in order to produce the OUTPUT STRING. Where required, a CARRY bit is also concatenated to the OUTPUT STRING, as explained with reference to FIG. 2 and the detailed example above. 
     Note that in the example just described, the A register is normalized such that it always lies within the range 1.0 to 2.0, i.e., A ε (1,2). It will readily be understood that the A register could be normalized between 0.1 and 1.0 (binary), or any multiple of 2 thereof by employing exactly the same algorithm but dividing the probabilities by appropriate multiples of 2 (or multiplying them by appropriate multiples of the binary number 0.1). Furthermore, in the particular example shown, carry-over occurs when encoding the third symbol of the source data string STR. In the example shown, it is assumed that the resultant code is transmitted to the decoder only when all the symbols of the source data string STR have been encoded. Obviously, in practice it is desired to transmit the compressed code in real time as it is generated, rather than storing the concatenated string as it is shifted out of the C register and transmitting it only when the complete source data string STR has been encoded. 
     If desired, the invention may be employed within a modified method wherein the approximation effected to K is slightly more refined. Thus, if instead of truncating the A register after the second binary 1, it is truncated after the third binary 1, the method can still be employed at the price of a second SHIFT and ADD operation. Obviously, this refinement can be extended even further such that in the limit the scaling factor K is exactly equal to the contents of the A register. This represents unapproximated arithmetic coding. In practice, however, the method described with reference to the Figure achieves greater than 98 percent efficiency while approximating the contents of the A register as explained. 
     The process of decoding a compressed output data string as derived in accordance with the principles of the invention is essentially the reverse of encoding. Thus, initially the A register is filled with one (1.000 . . . ) and the C register is filled with the first six symbols of the compressed string R(comp). 
     Each symbol of the source data string STR is now decoded successively by determining the largest value of j such that C&gt;K*S(j), where K and S(j) are the same as defined above with respect to the encoder. Having thus determined j, the current symbol is a j , where a 0  . . . a m  is the multi-symbol alphabet defined above. 
     The value of K*S(j) is next subtracted from the contents of the C register, while the A register is modified according to whether or not j=m. If j≠m, then the value of K*p(j) is inserted into the A register. On the other hand, if j =m, then the value of K*S(j) is subtracted from the contents of the A register. 
     Finally, the A and C registers are shifted in a predetermined direction until the contents of the A register lie with the range A ε (1,2). The vacated positions in the A register are filled with zeros, and those in the C register are filled with the corresponding number of most significant digits remaining in the compressed data string R(comp), the complete process being repeated until the compressed data string R(comp) is empty.