Abstract:
Discrete Fourier transformation is applied to an analog system so that a signal be transfering, the analog data can be corrected before being quantized and after being transferred and received. In the DFT cyclic decoder and the method of the same, a cyclic property of DFT code is used to induce a decoding way in the receiving end of a communication system. This way is used to design a basic decoding circuit and a fast decoding circuit structure. Since the decoding process is quick and the structure is simple so that the analog error correcting code is used widely.

Description:
FIELD OF THE INVENTION 
     The present invention relates to decoding of a communication system, and especially to cyclic step by step decoding method used in discrete Fourier transform cyclic code of a communication system. 
     BACKGROUND OF THE INVENTION 
     Error control coding is one of efficient techniques for error control in many digital systems. In particular, the class of Reed-Solomon codes (RS code) has been widely used in reliable communication systems and data storage systems. An (n, k) RS code is encoding and decoding by using the arithmetic of Galois fields GF(P m ). Since the minimum distance of the code is n−k+1, it is called a maximum-distance-separable code (MDS code). Although the RS has many important advantages; for example, it has high error correcting capability and can simultaneously correct random errors and multiple burst errors. However its code length is constrained to be p m −1 or a factor of p m −1, and each byte in a code word should be m bits (if p=2), besides any error bit caused by a low noise will be counted as an error of the whole byte. Discrete Fourier Transforms are playing on increasing implement role in many practical applications. There are same branches for investigation of the discrete transform; for example, as indicated by Marshall [1], the using of error control coding for discrete signals, and by Lin and Shiu [2], using DCT in Real-valued error control coding. However, the Wu-Shiu&#39;s code has not cyclic structure such that it cannot be encoded and decoded by using a step-by-step manner. 
     SUMMARY OF THE INVENTION 
     In this invention, a (N, N−d min +1) cyclic code is presented based on complex-valued discrete Fourier transform, the cyclic structure of the code makes the encoding and decoding procedures much easier than that of Marshall&#39;s and Wu-Shiu&#39;s codes. Since the code length N of the code can be any positive integer and each symbol in a code word is a complex value (consists of two real value), the code can be directly applied to analog communication systems and analog signal storage systems. Moreover, small amount of errors caused from low noise, computation truncating or rounding can be deleted by using a proper threshold for syndrome values. Finally, a (N, N−2) code is used as an example to illustrate the encoding and decoding procedures. 
    
    
     DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is show the signal transferring construction of the present invention. 
     FIG. 2 shows the (N, N−2) DFT cyclic circuit for correcting the error of single symbol or double symbol. 
     FIG. 3 shows the decoding process of the decoder in the present invention. 
     FIG. 4 is a fast decoding circuit of a (N, N−2) DFT according to the present invention. 
     FIG. 5 shows a circuit of the processing unit in the present invention. 
    
    
     DESCRIPTION OF THE PREFERRED EMBODIMENT 
     The Transmission structure of discrete signal can be simplified as FIG.  1 . Then we expand the transmission of a discrete-time signal, i.e. a sequence of complex numbers {u i } by a complex-valued (n, k) block coding procedure involves the following step: 
     (i) The information vector U={u i } is encoded into an N-tuple V, called a code vector, as shown by 
     
       
           V=U·G   (1) 
       
     
     Where G is a k·n matrix of rank k, call the generator matrix. 
     (ii) Let R be the received vector at the other end of the transmission channel and suppose that an unknown error E is introduced as 
     
       
           R=V+E   (2) 
       
     
     Where we assume the channel noise to be random and additives, and the operation ‘+’ is a traditional addition rather then a modular  2  addition. As is well known, for each k·n matrix G of rank k, there will be an (n−k)·n matrix H of ranks n−k such that G is in the null space of H T , i e. matrices G and H are related by 
     
       
           G·H   T =0  (3) 
       
     
     H is the parity check matrix of F the syndrome vector S of a received vector R is defined as 
     
       
         
           S=R·H 
           T 
         
       
     
     
       
         =( V+E )· H   T   
       
     
     
       
         = V·H   T   +E·H   T   
       
     
     
       
         = E·H   T   (4) 
       
     
     If E=0, no error occurs, then 
     
       
           S=R·H   T =0  (5) 
       
     
     I.e. the syndrome vector of any code vector is 0. 
     (iii) After identify the syndromes of the received vector R, the decoder must determine the optimal estimate of E, say E′. According to the maximum-likelihood decoding rule, the optimal estimate E′ is the error pattern, generated from the calculated syndromes, which has the fewest nonzero elements. Finally, the estimated V′ and U′ of the corresponding actual sequences are, respectively obtained by 
     
       
           V′=R−E′   (6) 
       
     
     
       
           U′=V′·G   −1   (7) 
       
     
     Where the matrix G −1  is an n·k matrix right inverse of G, such that 
     
       
           G·G   −1   =I   k   (8) 
       
     
     Basic Ideal of the Present Invention 
     Select generator matrix G is                    G   =            [                      w   00           w   01         …         w     0                   (     N   -   1     )                   w   10           w   11         …         w     1                   (     N   -   1     )                 ⋮       ⋮         w   kn         ⋮             w       (     K   -   1     )                   0             w       (     K   -   1     )                   1           …         w       (     K   -   1     )                     (     N   -   1     )               ]                   =            [                    1       1       …       1           1         w   11         …         w     1                   (     N   -   1     )                 ⋮       ⋮         w   kn         ⋮           1         w       (     K   -   1     )                   1           …         w       (     K   -   1     )                     (     N   -   1     )                          ]                                (   9   )                                
     Since G is a k·n matrix of rank k. if G satisfies (3) and (5), then G will generate a (n, k) linear code. 
     Let the (N−K)·K matrix H consist of the remaining N−K rows, say K, K+1, . . . , N−1, which are called parities, as its N−K rows, then we select H as                    H   =            [           w     K                   (     N   -   1     )               w     K                   (     N   -   2     )             …         w   K0               w       (     K   +   1     )                     (     N   +   1     )               w       (     K   +   1     )                     (     N   -   2     )             …         w       (     K   +   1     )                   0               ⋮       ⋮         w   kn         ⋮             w       (     N   -   1     )                     (     N   -   1     )               w       (     N   -   1     )                     (     N   -   2     )             …         w       (     N   -   1     )                   0             ]                 =            [           w     K                   (     N   -   1     )               w     K                   (     N   -   2     )             …       1             w       (     K   +   1     )                     (     N   -   1     )               w       (     K   +   1     )                     (     N   -   2     )             …       1           ⋮       ⋮         w   kn         ⋮             w       (     N   -   1     )                     (     N   -   1     )               w       (     N   -   1     )                     (     N   -   2     )             …       1         ]                   (   10   )                                
     1. Technical Consideration 
     For a (N, K) cyclic code, if the shortest distance between codewords is dmin=3, then an error symbol can be corrected. Now, consider that (N, N−2), k=N−2, N−K=2, therefor the number of syndrome is equal to 2. Therefore, from the view point of circulation, the decoder can be designed as FIG.  2 . 
     Wherein the decoder has the following components: 
     A signal receiving gate  20  for receiving input signals; 
     N series connected buffer registers  21  connected in series, each buffer register serving for registering one symbol; 
     A shift control gate  22  connected between a first and a Nth buffer registers for right-round-shifting the symbol in each buffer register through one register; 
     A syndrome vector calculating unit  23  connected to an output of Nth buffer register in parallel for calculating a first and a second elements of the syndrome vector; 
     A processing unit  24  for comparing the syndrome elements in the syndrome vector; controlling operations of the signal receiving gate and the shift control gate; and 
     A subtract  25  for performing an operation of subtraction to outputs of the buffer registers and the processing unit; and outputting the result; 
     The cyclic step by step decoding device performs the steps of receiving a discrete signal having N symbols; storing the discrete signal into N stage buffer registers; setting a number of i and an initial value of i being to 0; (i) if i is equal to N, it considers that the receiving signal is incorrect; and the process comes to an end; (ii) if i is unequal to N, then the process entering into the following step; calculating a first element and a second element of the syndrome vector according to the received symbols; determining whether the first element and second element of the syndrome vector are larger than a threshold; if both the first and second elements are smaller than the threshold, then it represent the error of N−1−i is 0; then all the symbols in the registers are outputted, which are decoded signals; the process the stop; if one of the first and second elements is larger than a threshold; subtracting the two elements, taking an absolute value of the result and comparing the absolute value to the threshold; if smaller than the threshold, then (N−1−i)th error being the first element of the syndrome vector; subtracted the error from the (N−1−i) symbol; then ouputting all the symbols in the registers, which are signals decoded; if larger than the threshold, then round-shifting the symbols in N registers to right with one a length of one register; and thus acquiring a new register series; the number i is added by one and returning the process to the step of calculating the syndrome vector and repeat the above process. 
     Let us consider three conditions as follow 
     (i) If there is no error: 
     Error pattern=[e 0  e 1  . . . e N−1 ], then e 0 =e 1 = . . . =e N−1 =0. So that syndrome 
     
       
           s   1   =s   2 =0 
       
     
     
       
           s   1   (1)   =s   2   (1) =0, 
       
     
       s   1   (N−1)   =s   2   (N−1) =0 
     Where s 1   (i)  is s 1  cyclic shift i times. We can verify there is no error. 
     (ii) If there is one error: 
     Error pattern=[e 0  e 1  . . . e N−1 ], and the error location is at δ. So some one 
     
       
           e   δ   =a+jb  for 0 ≦δ≦N −1 
       
     
     
       
           e   i =0 for  i≠δ   
       
     
     When one block data received in register R 0  R 1  . . . R N−1 ,                      [           s   1           s   2           ]     =              [           r   0           r   1         …         r     N   -   1             ]     ·     [           w     K                   (     N   -   1     )               w       (     K   +   1     )                     (     N   -   1     )                   w     K                   (     N   -   2     )               w       (     K   +   1     )                     (     N   -   2     )                 …       …             w   K1           w       (     K   +   1     )                   1               1       1         ]                   =              [           e   0           e   1         …         e     N   -   1             ]     ·     [           w     K                   (     N   -   1     )               w       (     K   +   1     )                     (     N   -   1     )                   w     K                   (     N   -   2     )               w       (     K   +   1     )                     (     N   -   2     )                 …       …             w   K1           w       (     K   +   1     )                   1               1       1         ]                     (   11   )                                s   1   =e   0   w   k(N−1)   +e   1   w   k(N−2)   + . . . +e   N−2   w   k1   +e   N−1   (12) 
     
       
           s   2   =e   0   w   (k+1)(N−1)   +e   1   w   (k+1)(N−2)   + . . . +e   N−2   w   (k+1)1   +e   N−1   (13) 
       
     
     We assume the error location is at position N−1, i.e. e N−1 =a+jb. 
     And e 0 =e 1 = . . . =e N−2 =0 
     Then s 1 =e N−1 =a+jb 
     s 2 =e N−1 =a+jb 
     So we can detect error location=N−1, error value=a+jb. 
     If error locate is not at position N−1, 
     
       
           e   N−1 =0 , e   δ   =a+jb, δ≠N −1, then 
       
     
       s   1   =e   δ   w   kδ   =c+jd   
     
       
         
           s 
           2 
           =e 
           δ 
           w 
           (k+1)δ 
           =f+jg 
         
       
     
     
       
         ∵ w   kδ   ≠w   (k+1)δ   ∴c+jd≠f+jg   
       
     
     So we verify there are some errors, but not at position N−1. 
     When the register data cyclic shift δ times, then                [           s   1     (   δ   )             s   2     (   δ   )             ]     =            [           e   δ           e     δ   +   1           …           e     N   -   1       ,       e   0                   …                   e     δ   -   1                 ]     ·     [           w     K                   (     N   -   1     )               w       (     K   +   1     )                     (     N   -   1     )                   w     K                   (     N   -   2     )               w       (     K   +   1     )                     (     N   -   2     )                 …       …             w   K1           w       (     K   +   1     )                   1               1       1         ]                 (   14   )                                
     We assume e δ =a+jb, e i =0, for i≠δ and 0≦i≦N−1, then 
     
       
         
           s 
           1 
           (δ) 
           =a+jb 
         
       
     
     
       
         
           s 
           2 
           (δ) 
           =a+jb 
         
       
     
     So we can verify the error location is δ, and error value is a+jb. 
     (iii) If there are more than one errors: 
     
       
         
           s 
           1 
           (i) 
           =c+jd 
         
       
     
     
       
         
           s 
           2 
           (i) 
           =f+jg 
         
       
     
     When we shift the register data right i times, i from 0 to N−1, can&#39;t get the same syndrome. So we verify there are more than one error and can&#39;t be correct. 
     In summery, referring to FIG. 3, the DFT has a cyclic property, and thus the step-by-step decoding rule is that: 
     (a) If the syndrome equation s 1 =s 2 =0, then the receiving block is correct, and the decoding work is accomplished. 
     (b) If the syndrome equation s 1 =s 2 , but unequal to 0, then e N−1−i =s 1 , and others are correct, then the decoding process is complete. 
     (c) Otherwise e N−1−i =0 
     The decoding process is listed in the following: 
     (1) receiving a discrete signal having N symbols; 
     (2) storing the discrete signal into N stage buffer registers; 
     (3) setting a number of i and an initial value of i being to 0; 
     (i) if i is equal to N, it considers that the receiving signal is incorrect; and the process comes to an end; 
     (ii) if i is unequal to N, then the process entering into the following step; 
     (4) calculating a first element and a second element of the syndrome vector according to the received symbols; 
     (5) determining whether the first element and second element of the syndrome vector are larger than a threshold; 
     (6) if both the first and second elements are smaller than the threshold, then it represent the error of N−1−i is 0; then all the symbols in the registers are outputted, which are decoded signals; the process the stop; 
     (7) if one of the first and second elements is larger than a threshold; subtracting the two elements, taking an absolute value of the result and comparing the absolute value to the threshold; 
     (i) if smaller than the threshold, then (N−1−i)th error being the first element of the syndrome vector; the (N−1−i) symbol being added with the error; then ouputting all the symbols in the registers, which are signals decoded; 
     (ii) if larger than the threshold, then round-shifting the symbols in N registers to right with one a length of one register; and thus acquiring a new register series; 
     (8) the number i is added by one and returning the process to step (3). 
     2. A Fast Decoding Algorithm for (N, N−2) DFT Cyclic Codes 
     From (21) 
     
       
         
           s 
           1 
           =e 
           0 
           w 
           k(N−1) 
           +e 
           1 
           w 
           k(N−2) 
           + . . . +e 
           N−2 
           w 
           k1 
           +e 
           N−1 
         
       
     
     
       
         = e   0   w   −k   +e   1   w   −k2   + . . . +e   N−1   w   −k(N−2)   +e   N−1   w   −kN   
       
     
     
       
         = w   −k   ·[e   0   +e   1   w   −k1   + . . . +e   N−1   w   −k(N−1)]   (15) 
       
     
     From (22) 
     
       
         
           s 
           2 
           =e 
           0 
           w 
           (k+1)(N−1) 
           +e 
           1 
           w 
           (k+1)(N−2) 
           + . . . +e 
           N−2 
           w 
           (k+1)1 
           +e 
           N−1 
         
       
     
     
       
         = e   0   w   −(k+1)   +e   1   w   −(k+1)2   + . . . +e   N−1   w   −(k+1)(N−2)   +e   N−1   w   −(k+1)N   
       
     
     
       
         = w   −(k+1)   ·[e   0   +e   1   w   −(k+1)1   + . . . +e   N−1   w   −(k+1)(N−1) ]  (16) 
       
     
     From (23) 
     
       
         
           s 
           1 
           (1) 
           =e 
           N−1 
           w 
           k(N−1) 
           +e 
           0 
           w 
           k(N−2) 
           + . . . +e 
           N−2 
           w 
           k(N−1) 
         
       
     
     
       
         = w   −k   ·[e   0   w   k(N−1)   + . . . +e   N−2   w   k(N−1)   +e   N−1   w   kN ] 
       
     
     
       
         = w   −k   ·s   1   (17) 
       
     
     
       
         
           s 
           2 
           (1) 
           =e 
           N−1 
           w 
           (k+1)(N−1) 
           +e 
           0 
           w 
           (k+1)(N+2) 
           + . . . +e 
           N−2 
           w 
           (k+1)(N−1) 
         
       
     
     
       
         = w   −(k+1)   ·[e   0   w   (k+1)(N−1)   + . . . +e   N−2   w   (k+1)(N−1)   +e   N−1   w   (k+1)N ] 
       
     
     
       
         = w   −(k+1)   ·s   2   (18) 
       
     
     So that the general cases are 
     
       
           s   1   (i+1)   =w   −k   ·s   1   i   (19) 
       
     
     
       
           s   2   (i+1)   =w   −(k+1)   ·s   2   i   (20) 
       
     
     A circuit can be designed according to this algorithm, as shown in FIG. 4, the circuit includes the following components: 
     A signal receiving gate  40  for receiving input signals; 
     N series connected buffer registers  41  connected in series, each buffer register serving for registering one symbol; 
     A syndrome vector calculating unit  42  connected to an output of Nth buffer register in series for calculating a first and a second elements of the syndrome vector; 
     A control gate  43  serially connected between the first buffer register and the signal receiving gate for controlling signals from the receiving gate to the syndrome vector calculation unit; 
     A processing unit  44  for comparing the syndrome elements in the syndrome vector; controlling operations of the signal receiving gate and the shift control gate; and 
     A subtractor  45  for performing an operation of subtraction to outputs of the buffer registers and the processing unit; and outputting the result; 
     The cyclic step by step decoding device performs the steps of receiving a discrete signal having N symbols; storing the discrete signal into N stage buffer registers; setting a number of i and an initial value of i being to 0; (i) if i is equal to N, it considers that the receiving signal is incorrect; and the process comes to an end; (ii) if i is unequal to N, then the process entering into the following step; calculating a first element and a second element of the syndrome vector according to the received symbols; determining whether the first element and second element of the syndrome vector are larger than a threshold; if both the first and second elements are smaller than the threshold, then it represent the error of N−1−i is 0; then all the symbols in the registers are outputted, which are decoded signals; the process the stop; if one of the first and second elements is larger than a threshold; subtracting the two elements, taking an absolute value of the result and comparing the absolute value to the threshold; if smaller than the threshold, then (N−1−i)th error being the first element of the syndrome vector; subtracted the error from the (N−1−i) symbol; then ouputting all the symbols in the registers, which are signals decoded; if larger than the threshold, then round-shifting the symbols in N registers to right with one a length of one register; and thus acquiring a new register series; the number i is added by one and returning the process to the step of calculating the syndrome vector and repeat the above process. 
     In the present invention, when the symbol has only one word, as shown in FIG. 5, the circuit structure is constructed by the following component: 
     A subtractor  50  with an input of the first and second elements of the syndrome vector for performing a subtracting opertion; 
     A first comparator  51  with an input from an output of the subtrator and a threshold; 
     A second comparator  52  with an input of first element of the syndrome vector and a threshold; 
     An AND gate  57  having an input end connected to the outputs of the first and second comparators; 
     A first gate  53  enabled by an output of the AND gate and having an input end connected to the first element of the syndrome vector; 
     A second gate  54  enabled by an output of the second comparator and having an input of 0; 
     A first OR gate  55  connected to an output of the second comparator and an output of the AND gate; and 
     A second OR gate  56  connected to outputs of the first and second amplifiers. 
     3. Conclusion 
     In the present invention, we have introduced a new class of complex-valued cyclic codes and have shown that a subclass of them has a similar structure to the Reed-Solomon code defined over finite field. The BCH bound on code capacity and conventional BCH decoding algorithms can be applied to this new subclass. And we also proof this subclass code is a cyclic code. This result supports the well-known concept that the RS code should be a subclass of a cyclic code. There exist a RS-like subclass cyclic code in frequency domain too. These results are derived using transform domain techniques. Furthermore we demonstrated how standard signal processing techniques could be applied to derive new decoding algorithms for cyclic error correcting codes. 
     4. References 
     [1] T. G. Marshall, Jr.: ‘Coding of real-number sequences for error correction: a digital processing problem’, IEEE Journal on Selected Areas in Communications, 1984, SAC-2 (2), pp. 381-391 
     [2] Ja-Ling Wu, Jiun Shiu: ‘Real-valued error control coding by using DCT’, IEE proceeding-I vol. 139, No 2, April 1992, pp. 133-139 
     [3] R. E. Blahut: ‘Theory and practice of error control codes’. Addision-Wesley, New York, 1983 
     [4] Valdemar C. Da Rocha, Jr.: ‘Maximum Distance Separable Multilevel Codes’, IEEE Transactions On Information Theory, Vol. IT-30 No. 3, May 1984 
     [5] W. W. Peterson and E. J. Weldon, Jr., ‘Error-Correcting Codes, 2 nd  ed. Cambridge, Mass.: MIT, 1972 
     [6] Alan V. Oppenheim, Ronald W. Schafer: ‘Discrete-Time Signal Process’. 2 nd  ed. Prentice Hall 1999, pp.542-546 
     [7] F. J. MacWilliams, N. J. A. Sloane: ‘The Theory of Error-Correcting Codes’. 1 st  edition. 10 th  impression. North-holland 1998 
     [8] Shu Lin/Daniel J. Costello, Tr. ‘Error Control Coding: Fundmentals and Applications’ Prentice-Hall Inc, 1983 
     5. Appendix 
     
       
         
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
             
               
               
               
               
               
               
             
               
               
             
               
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
               
               
               
               
               
             
               
               
             
           
               
                   
               
             
             
               
                 (A) 
                 (8, 6) code. Input error e3= 0.50−j3.2 
               
               
                   
                 &lt;&lt; Input Data &gt;&gt; 
               
             
          
           
               
                   
                 X[0]:1.000000 
                 X[1]:1.000000 
                 X[2]:1.000000 
                 X[3]:1.000000 
               
               
                   
                 X[4]:0.000000 
                 X[5]:0.000000 
               
             
          
           
               
                   
                 &lt;&lt; After Encoder Data &gt;&gt; 
               
             
          
           
               
                   
                 [0]:4.000000 
                 j0.000000 
                 [1]:1.000001 
                 j−2.414214 
                 [2]:−0.000001 
               
               
                   
                 j−0.000001 
                 [3]:1.000000 
                 j−0.414213 
               
               
                   
                 [4]:0.000000 
                 j−0.000001 
                 [5]:0.999999 
                 j0.414215 
                 [6]:0.000002 
               
               
                   
                 j−0.000002 
                 [7]:0.999994 
                 j2.414212 
               
             
          
           
               
                   
                 &lt;&lt; Syndrome Data &gt;&gt; 
               
             
          
           
               
                   
                 s1:0.000012 
                 j−0.000004 
                 s2:0.000022 
                 j−0.000001 
               
             
          
           
               
                   
                 &lt;&lt; After add noise Data &gt;&gt; 
               
             
          
           
               
                   
                 [0]:4.000000 
                 j0.000000 
                 [1]:1.000001 
                 j−2.414214 
                 [2]:−0.000001 
               
               
                   
                 j−0.000001 
                 [3]:1.500000 
                 j−3.614213 
               
               
                   
                 [4]:0.000000 
                 j−0.000001 
                 [5]:0.999999 
                 j0.414215 
                 [6]:0.000002 
               
               
                   
                 j−0.000002 
                 [7]:0.999994 
                 j2.414212 
               
             
          
           
               
                   
                 &lt;&lt; shift 0 Syndrome, Check 7 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:0.500024 
                 j−3.200003 
                 s2:−0.499993 
                 j3.199996 
               
             
          
           
               
                   
                 &lt;&lt; shift 1 Syndrome, Check 6 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−3.199995 
                 j−0.500002 
                 s2:1.909185 
                 j2.616307 
               
             
          
           
               
                   
                 &lt;&lt; shift 2 Syndrome, Check 5 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−0.499999 
                 j3.199996 
                 s2:3.200007 
                 j0.500008 
               
             
          
           
               
                   
                 &lt;&lt; shift 3 Syndrome, Check 4 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:3.200004 
                 j0.499999 
                 s2:2.616307 
                 j−1.909181 
               
             
          
           
               
                   
                 &lt;&lt; shift 4 Syndrome, Check 3 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:0.499996 
                 j−3.200005 
                 s2:0.500010 
                 j=3.200004 
               
             
          
           
               
                   
                 &lt;&lt; shift 5 Syndrome, Check 2 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−3.199993 
                 j−0.500021 
                 s2:−1.909154 
                 j−2.616316 
               
             
          
           
               
                   
                 &lt;&lt; shift 6 Syndrome, Check 1 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−0.500018 
                 j3.199994 
                 s2:−3.199991 
                 j−0.500035 
               
             
          
           
               
                   
                 &lt;&lt; shift 7 Syndrome, Check 0 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:3.200002 
                 j0.499996 
                 s2:−2.616290 
                 j1.909151 
               
             
          
           
               
                   
                 &lt;&lt; After Decoder Data &gt;&gt; 
               
               
                   
                 Detect:1 ==&gt; There is One error, can be correct 
               
             
          
           
               
                   
                 Item=3 
                 ErrValue: 0.500010 
                 j−3.200004 
               
             
          
           
               
                   
                 [0]:4.000000 
                 j0.000000 
                 [1]:1.000001 
                 j−2.414214 
                 [2]:−0.000001 
               
               
                   
                 j−0.000001 
                 [3]:0.999991 
                 j−0.414209 
               
               
                   
                 [4]:0.000000 
                 j−0.000001 
                 [5]:0.999999 
                 j0.414215 
                 [6]:0.000002 
               
               
                   
                 j−0.000002 
                 [7]:0.999994 
                 j2.414212 
               
             
          
           
               
                   
                 &lt;&lt; After IDFKT Data &gt;&gt; 
               
             
          
           
               
                   
                 [0]:0.999998 
                 j0.000000 
                 [1]:1.000000 
                 j−0.000001 
                 [2]:1.000000 
               
               
                   
                 j0.000001 
                 [3]:0.999998 
                 j−0.000000 
               
               
                   
                 [4]:0.000001 
                 j.0.000000 
                 [5]:−0.000001 
                 j0.000002 
               
             
          
           
               
                 (B) 
                 (8, 6) code. Input more than one error, e1=1.0+j0.4 and e3 = 0.50−j3.2 
               
               
                   
                 &lt;&lt; Input Data &gt;&gt; 
               
             
          
           
               
                   
                 X[0]:1.000000 
                 X[1]:1.000000 
                 X[2]:1.000000 
                 X[3]:1.000000 
               
               
                   
                 X[4]:0.000000 
                 X[5]:0.000000 
               
             
          
           
               
                   
                 &lt;&lt; After Encoder Data &gt;&gt; 
               
             
          
           
               
                   
                 [0]:4.000000 
                 j0.000000 
                 [1]:1.000001 
                 j−2.414214 
                 [2]:−0.000001 
               
               
                   
                 j−0.000001 
                 [3]:1.000000 
                 j−0.414213 
               
               
                   
                 [4]:0.000000 
                 j−0.000001 
                 [5]:0.999999 
                 j0.414215 
                 [6]:0.000002 
               
               
                   
                 j−0.000002 
                 [7]:0.999994 
                 j2.414212 
               
             
          
           
               
                   
                 &lt;&lt; Syndrome Data &gt;&gt; 
               
             
          
           
               
                   
                 s1:0.000012 
                 j−0.000004 
                 s2:0.000022 
                 j−0.000001 
               
             
          
           
               
                   
                 &lt;&lt; After add noise Data &gt;&gt; 
               
             
          
           
               
                   
                 [0]:4.000000 
                 j0.000000 
                 [1]:2.000001 
                 j−2.014214 
                 [2]:−0.000001 
               
               
                   
                 j−0.000001 
                 [3]:1.500000 
                 j−3.614213 
               
               
                   
                 [4:]0.000000 
                 j−0.000001 
                 [5]:0.999999 
                 j0.414215 
                 [6]:0.000002 
               
               
                   
                 j−0.000002 
                 [7]:0.999994 
                 j2.414212 
               
             
          
           
               
                   
                 &lt;&lt; shift 0 Syndrome, Check 7 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−0.499973 
                 j−3.600008 
                 s2:−0.099986 
                 j2.199999 
               
             
          
           
               
                   
                 &lt;&lt; shift 1 Syndrome, Check 6 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−3.600000 
                 j0.499996 
                 s2:1.484926 
                 j1.626356 
               
             
          
           
               
                   
                 &lt;&lt; shift 2 Syndrome, Check 5 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:0.499999 
                 j3.600000 
                 s2:2.200009 
                 j0.100003 
               
             
          
           
               
                   
                 &lt;&lt; shift 3 Syndrome, Check 4 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:3.600007 
                 j−0.500000 
                 s2:1.626356 
                 j−1.484921 
               
             
          
           
               
                   
                 &lt;&lt; shift 4 Syndrome, Check 3 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−0.500003 
                 j−3.600006 
                 s2:0.100007 
                 j−2.200005 
               
             
          
           
               
                   
                 &lt;&lt; shift 5 Syndrome, Check 2 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:−3.599994 
                 j0.499978 
                 s2:−1.484891 
                 j−1.626366 
               
             
          
           
               
                   
                 &lt;&lt; shift 6 Syndrome, Check 1 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:0.499982 
                 j3.599994 
                 s2:−2.199991 
                 j−0.100035 
               
             
          
           
               
                   
                 &lt;&lt; shift 7 Syndrome, Check 0 Symbol &gt;&gt; 
               
             
          
           
               
                   
                 s1:3.600009 
                 j−0.500001 
                 s2:−1.626337 
                 j1.484895 
               
             
          
           
               
                   
                 &lt;&lt; After Decoder Data &gt;&gt; 
               
               
                   
                 Detect:2 ==&gt; There are more than One error, can not be correct